From: Alan Cox Date: Thu, 6 Aug 2009 19:45:57 +0000 (+0100) Subject: Staging: sep: indent pass X-Git-Tag: MMI-PSA29.97-13-9~26941^2~214 X-Git-Url: https://git.stricted.de/?a=commitdiff_plain;h=d19cf32fddeb05a13799fd766fced4204cc9164d;p=GitHub%2FMotorolaMobilityLLC%2Fkernel-slsi.git Staging: sep: indent pass Ok time to indent and get the code in vague shape. No other changes in this patch. Signed-off-by: Alan Cox Signed-off-by: Greg Kroah-Hartman --- diff --git a/drivers/staging/sep/sep_dev.h b/drivers/staging/sep/sep_dev.h index 1baff8993889..0e8a09926f4d 100644 --- a/drivers/staging/sep/sep_dev.h +++ b/drivers/staging/sep/sep_dev.h @@ -66,15 +66,15 @@ struct sep_device { /* counter for the messages from sep */ unsigned long sep_to_host_reply_counter; /* counter for the number of bytes allocated in the pool for the current - transaction */ + transaction */ unsigned long data_pool_bytes_allocated; /* array of pointers to the pages that represent input data for the synchronic - DMA action */ + DMA action */ struct page **in_page_array; /* array of pointers to the pages that represent out data for the synchronic - DMA action */ + DMA action */ struct page **out_page_array; /* number of pages in the sep_in_page_array */ @@ -121,9 +121,8 @@ static inline void sep_wait_sram_write(struct sep_device *dev) u32 reg_val; do reg_val = sep_read_reg(dev, HW_SRAM_DATA_READY_REG_ADDR); - while(!(reg_val & 1)); + while (!(reg_val & 1)); } #endif - diff --git a/drivers/staging/sep/sep_driver_api.h b/drivers/staging/sep/sep_driver_api.h index 6a3be5dbfffd..b35bd5b8d089 100644 --- a/drivers/staging/sep/sep_driver_api.h +++ b/drivers/staging/sep/sep_driver_api.h @@ -106,11 +106,11 @@ init command struct */ struct sep_driver_init_t { - /* start of the 1G of the host memory address that SEP can access */ - unsigned long message_addr; + /* start of the 1G of the host memory address that SEP can access */ + unsigned long message_addr; - /* start address of resident */ - unsigned long message_size_in_words; + /* start address of resident */ + unsigned long message_size_in_words; }; @@ -119,168 +119,168 @@ struct sep_driver_init_t { realloc cache resident command */ struct sep_driver_realloc_cache_resident_t { - /* base address */ - unsigned long base_addr; + /* base address */ + unsigned long base_addr; - /* current cache address */ - unsigned long cache_addr; + /* current cache address */ + unsigned long cache_addr; - /* cache size in bytes*/ - unsigned long cache_size_in_bytes; + /* cache size in bytes */ + unsigned long cache_size_in_bytes; - /* current resident address */ - unsigned long resident_addr; + /* current resident address */ + unsigned long resident_addr; - /* resident size in bytes*/ - unsigned long resident_size_in_bytes; + /* resident size in bytes */ + unsigned long resident_size_in_bytes; - /* new cache address */ - unsigned long new_cache_addr; + /* new cache address */ + unsigned long new_cache_addr; - /* new resident address */ - unsigned long new_resident_addr; + /* new resident address */ + unsigned long new_resident_addr; - /* new resident address */ - unsigned long new_shared_area_addr; + /* new resident address */ + unsigned long new_shared_area_addr; - /* new base address */ - unsigned long new_base_addr; + /* new base address */ + unsigned long new_base_addr; }; /* set api mode command struct */ struct sep_driver_set_api_mode_t { - /* mode to set - 1 - blocking, 0 - non-blocking */ - unsigned long mode; + /* mode to set - 1 - blocking, 0 - non-blocking */ + unsigned long mode; }; struct sep_driver_alloc_t { - /* virtual address of allocated space */ - unsigned long offset; + /* virtual address of allocated space */ + unsigned long offset; - /* physical address of allocated space */ - unsigned long phys_address; + /* physical address of allocated space */ + unsigned long phys_address; - /* number of bytes to allocate */ - unsigned long num_bytes; + /* number of bytes to allocate */ + unsigned long num_bytes; }; /* */ struct sep_driver_write_t { - /* application space address */ - unsigned long app_address; + /* application space address */ + unsigned long app_address; - /* address of the data pool */ - unsigned long datapool_address; + /* address of the data pool */ + unsigned long datapool_address; - /* number of bytes to write */ - unsigned long num_bytes; + /* number of bytes to write */ + unsigned long num_bytes; }; /* */ struct sep_driver_read_t { - /* application space address */ - unsigned long app_address; + /* application space address */ + unsigned long app_address; - /* address of the data pool */ - unsigned long datapool_address; + /* address of the data pool */ + unsigned long datapool_address; - /* number of bytes to read */ - unsigned long num_bytes; + /* number of bytes to read */ + unsigned long num_bytes; }; /* */ struct sep_driver_build_sync_table_t { - /* address value of the data in */ - unsigned long app_in_address; + /* address value of the data in */ + unsigned long app_in_address; - /* size of data in */ - unsigned long data_in_size; + /* size of data in */ + unsigned long data_in_size; - /* address of the data out */ - unsigned long app_out_address; + /* address of the data out */ + unsigned long app_out_address; - /* the size of the block of the operation - if needed, - every table will be modulo this parameter */ - unsigned long block_size; + /* the size of the block of the operation - if needed, + every table will be modulo this parameter */ + unsigned long block_size; - /* the physical address of the first input DMA table */ - unsigned long in_table_address; + /* the physical address of the first input DMA table */ + unsigned long in_table_address; - /* number of entries in the first input DMA table */ - unsigned long in_table_num_entries; + /* number of entries in the first input DMA table */ + unsigned long in_table_num_entries; - /* the physical address of the first output DMA table */ - unsigned long out_table_address; + /* the physical address of the first output DMA table */ + unsigned long out_table_address; - /* number of entries in the first output DMA table */ - unsigned long out_table_num_entries; + /* number of entries in the first output DMA table */ + unsigned long out_table_num_entries; - /* data in the first input table */ - unsigned long table_data_size; + /* data in the first input table */ + unsigned long table_data_size; - /* distinct user/kernel layout */ - bool isKernelVirtualAddress; + /* distinct user/kernel layout */ + bool isKernelVirtualAddress; }; /* */ struct sep_driver_build_flow_table_t { - /* flow type */ - unsigned long flow_type; + /* flow type */ + unsigned long flow_type; - /* flag for input output */ - unsigned long input_output_flag; + /* flag for input output */ + unsigned long input_output_flag; - /* address value of the data in */ - unsigned long virt_buff_data_addr; + /* address value of the data in */ + unsigned long virt_buff_data_addr; - /* size of data in */ - unsigned long num_virtual_buffers; + /* size of data in */ + unsigned long num_virtual_buffers; - /* the physical address of the first input DMA table */ - unsigned long first_table_addr; + /* the physical address of the first input DMA table */ + unsigned long first_table_addr; - /* number of entries in the first input DMA table */ - unsigned long first_table_num_entries; + /* number of entries in the first input DMA table */ + unsigned long first_table_num_entries; - /* data in the first input table */ - unsigned long first_table_data_size; + /* data in the first input table */ + unsigned long first_table_data_size; - /* distinct user/kernel layout */ - bool isKernelVirtualAddress; + /* distinct user/kernel layout */ + bool isKernelVirtualAddress; }; struct sep_driver_add_flow_table_t { - /* flow id */ - unsigned long flow_id; + /* flow id */ + unsigned long flow_id; - /* flag for input output */ - unsigned long inputOutputFlag; + /* flag for input output */ + unsigned long inputOutputFlag; - /* address value of the data in */ - unsigned long virt_buff_data_addr; + /* address value of the data in */ + unsigned long virt_buff_data_addr; - /* size of data in */ - unsigned long num_virtual_buffers; + /* size of data in */ + unsigned long num_virtual_buffers; - /* address of the first table */ - unsigned long first_table_addr; + /* address of the first table */ + unsigned long first_table_addr; - /* number of entries in the first table */ - unsigned long first_table_num_entries; + /* number of entries in the first table */ + unsigned long first_table_num_entries; - /* data size of the first table */ - unsigned long first_table_data_size; + /* data size of the first table */ + unsigned long first_table_data_size; - /* distinct user/kernel layout */ - bool isKernelVirtualAddress; + /* distinct user/kernel layout */ + bool isKernelVirtualAddress; }; @@ -288,49 +288,49 @@ struct sep_driver_add_flow_table_t { command struct for set flow id */ struct sep_driver_set_flow_id_t { - /* flow id to set */ - unsigned long flow_id; + /* flow id to set */ + unsigned long flow_id; }; /* command struct for add tables message */ struct sep_driver_add_message_t { - /* flow id to set */ - unsigned long flow_id; + /* flow id to set */ + unsigned long flow_id; - /* message size in bytes */ - unsigned long message_size_in_bytes; + /* message size in bytes */ + unsigned long message_size_in_bytes; - /* address of the message */ - unsigned long message_address; + /* address of the message */ + unsigned long message_address; }; /* command struct for static pool addresses */ struct sep_driver_static_pool_addr_t { - /* physical address of the static pool */ - unsigned long physical_static_address; + /* physical address of the static pool */ + unsigned long physical_static_address; - /* virtual address of the static pool */ - unsigned long virtual_static_address; + /* virtual address of the static pool */ + unsigned long virtual_static_address; }; /* command struct for getiing offset of the physical address from the start of the mapped area */ struct sep_driver_get_mapped_offset_t { - /* physical address of the static pool */ - unsigned long physical_address; + /* physical address of the static pool */ + unsigned long physical_address; - /* virtual address of the static pool */ - unsigned long offset; + /* virtual address of the static pool */ + unsigned long offset; }; /* command struct for getting time value and address */ struct sep_driver_get_time_t { - /* physical address of stored time */ - unsigned long time_physical_address; + /* physical address of stored time */ + unsigned long time_physical_address; - /* value of the stored time */ - unsigned long time_value; + /* value of the stored time */ + unsigned long time_value; }; @@ -338,34 +338,34 @@ struct sep_driver_get_time_t { structure that represent one entry in the DMA LLI table */ struct sep_lli_entry_t { - /* physical address */ - unsigned long physical_address; + /* physical address */ + unsigned long physical_address; - /* block size */ - unsigned long block_size; + /* block size */ + unsigned long block_size; }; /* structure that reperesents data needed for lli table construction */ struct sep_lli_prepare_table_data_t { - /* pointer to the memory where the first lli entry to be built */ - struct sep_lli_entry_t *lli_entry_ptr; + /* pointer to the memory where the first lli entry to be built */ + struct sep_lli_entry_t *lli_entry_ptr; - /* pointer to the array of lli entries from which the table is to be built */ - struct sep_lli_entry_t *lli_array_ptr; + /* pointer to the array of lli entries from which the table is to be built */ + struct sep_lli_entry_t *lli_array_ptr; - /* number of elements in lli array */ - int lli_array_size; + /* number of elements in lli array */ + int lli_array_size; - /* number of entries in the created table */ - int num_table_entries; + /* number of entries in the created table */ + int num_table_entries; - /* number of array entries processed during table creation */ - int num_array_entries_processed; + /* number of array entries processed during table creation */ + int num_array_entries_processed; - /* the totatl data size in the created table */ - int lli_table_total_data_size; + /* the totatl data size in the created table */ + int lli_table_total_data_size; }; /* @@ -373,19 +373,19 @@ struct sep_lli_prepare_table_data_t { to show what table looks like */ struct sep_lli_table_t { - /* number of pages mapped in this tables. If 0 - means that the table - is not defined (used as a valid flag)*/ - unsigned long num_pages; - /* - pointer to array of page pointers that represent the mapping of the - virtual buffer defined by the table to the physical memory. If this - pointer is NULL, it means that the table is not defined - (used as a valid flag) - */ - struct page **table_page_array_ptr; - - /* maximum flow entries in table */ - struct sep_lli_entry_t lli_entries[SEP_DRIVER_MAX_FLOW_NUM_ENTRIES_IN_TABLE]; + /* number of pages mapped in this tables. If 0 - means that the table + is not defined (used as a valid flag) */ + unsigned long num_pages; + /* + pointer to array of page pointers that represent the mapping of the + virtual buffer defined by the table to the physical memory. If this + pointer is NULL, it means that the table is not defined + (used as a valid flag) + */ + struct page **table_page_array_ptr; + + /* maximum flow entries in table */ + struct sep_lli_entry_t lli_entries[SEP_DRIVER_MAX_FLOW_NUM_ENTRIES_IN_TABLE]; }; @@ -393,61 +393,61 @@ struct sep_lli_table_t { structure for keeping the mapping of the virtual buffer into physical pages */ struct sep_flow_buffer_data { - /* pointer to the array of page structs pointers to the pages of the - virtual buffer */ - struct page **page_array_ptr; + /* pointer to the array of page structs pointers to the pages of the + virtual buffer */ + struct page **page_array_ptr; - /* number of pages taken by the virtual buffer */ - unsigned long num_pages; + /* number of pages taken by the virtual buffer */ + unsigned long num_pages; - /* this flag signals if this page_array is the last one among many that were - sent in one setting to SEP */ - unsigned long last_page_array_flag; + /* this flag signals if this page_array is the last one among many that were + sent in one setting to SEP */ + unsigned long last_page_array_flag; }; /* struct that keeps all the data for one flow */ struct sep_flow_context_t { - /* - work struct for handling the flow done interrupt in the workqueue - this structure must be in the first place, since it will be used - forcasting to the containing flow context - */ - struct work_struct flow_wq; + /* + work struct for handling the flow done interrupt in the workqueue + this structure must be in the first place, since it will be used + forcasting to the containing flow context + */ + struct work_struct flow_wq; - /* flow id */ - unsigned long flow_id; + /* flow id */ + unsigned long flow_id; - /* additional input tables exists */ - unsigned long input_tables_flag; + /* additional input tables exists */ + unsigned long input_tables_flag; - /* additional output tables exists */ - unsigned long output_tables_flag; + /* additional output tables exists */ + unsigned long output_tables_flag; - /* data of the first input file */ - struct sep_lli_entry_t first_input_table; + /* data of the first input file */ + struct sep_lli_entry_t first_input_table; - /* data of the first output table */ - struct sep_lli_entry_t first_output_table; + /* data of the first output table */ + struct sep_lli_entry_t first_output_table; - /* last input table data */ - struct sep_lli_entry_t last_input_table; + /* last input table data */ + struct sep_lli_entry_t last_input_table; - /* last output table data */ - struct sep_lli_entry_t last_output_table; + /* last output table data */ + struct sep_lli_entry_t last_output_table; - /* first list of table */ - struct sep_lli_entry_t input_tables_in_process; + /* first list of table */ + struct sep_lli_entry_t input_tables_in_process; - /* output table in process (in sep) */ - struct sep_lli_entry_t output_tables_in_process; + /* output table in process (in sep) */ + struct sep_lli_entry_t output_tables_in_process; - /* size of messages in bytes */ - unsigned long message_size_in_bytes; + /* size of messages in bytes */ + unsigned long message_size_in_bytes; - /* message */ - unsigned char message[SEP_MAX_ADD_MESSAGE_LENGTH_IN_BYTES]; + /* message */ + unsigned char message[SEP_MAX_ADD_MESSAGE_LENGTH_IN_BYTES]; }; @@ -478,54 +478,35 @@ void sep_send_msg_rdy_cmd(void); This function releases all the application virtual buffer physical pages, that were previously locked */ -int sep_free_dma_pages(struct page **page_array_ptr, - unsigned long num_pages, - unsigned long dirtyFlag); +int sep_free_dma_pages(struct page **page_array_ptr, unsigned long num_pages, unsigned long dirtyFlag); /* This function creates the input and output dma tables for symmetric operations (AES/DES) according to the block size from LLI arays */ -int sep_construct_dma_tables_from_lli( - struct sep_lli_entry_t *lli_in_array, - unsigned long sep_in_lli_entries, - struct sep_lli_entry_t *lli_out_array, - unsigned long sep_out_lli_entries, - unsigned long block_size, - unsigned long *lli_table_in_ptr, - unsigned long *lli_table_out_ptr, - unsigned long *in_num_entries_ptr, - unsigned long *out_num_entries_ptr, - unsigned long *table_data_size_ptr); +int sep_construct_dma_tables_from_lli(struct sep_lli_entry_t *lli_in_array, + unsigned long sep_in_lli_entries, + struct sep_lli_entry_t *lli_out_array, + unsigned long sep_out_lli_entries, + unsigned long block_size, unsigned long *lli_table_in_ptr, unsigned long *lli_table_out_ptr, unsigned long *in_num_entries_ptr, unsigned long *out_num_entries_ptr, unsigned long *table_data_size_ptr); /* This function builds input and output DMA tables for synhronic symmetric operations (AES, DES) It also checks that each table is of the modular block size */ -int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr, - unsigned long app_virt_out_addr, - unsigned long data_size, - unsigned long block_size, - unsigned long *lli_table_in_ptr, - unsigned long *lli_table_out_ptr, - unsigned long *in_num_entries_ptr, - unsigned long *out_num_entries_ptr, - unsigned long *table_data_size_ptr, - bool isKernelVirtualAddress); +int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr, + unsigned long app_virt_out_addr, + unsigned long data_size, + unsigned long block_size, + unsigned long *lli_table_in_ptr, unsigned long *lli_table_out_ptr, unsigned long *in_num_entries_ptr, unsigned long *out_num_entries_ptr, unsigned long *table_data_size_ptr, bool isKernelVirtualAddress); /* This function prepares only input DMA table for synhronic symmetric operations (HASH) */ -int sep_prepare_input_dma_table(unsigned long app_virt_addr, - unsigned long data_size, - unsigned long block_size, - unsigned long *lli_table_ptr, - unsigned long *num_entries_ptr, - unsigned long *table_data_size_ptr, - bool isKernelVirtualAddress); +int sep_prepare_input_dma_table(unsigned long app_virt_addr, unsigned long data_size, unsigned long block_size, unsigned long *lli_table_ptr, unsigned long *num_entries_ptr, unsigned long *table_data_size_ptr, bool isKernelVirtualAddress); /* this functions frees all the resources that were allocated for the building of the LLI DMA tables */ diff --git a/drivers/staging/sep/sep_driver_ext_api.h b/drivers/staging/sep/sep_driver_ext_api.h index 00cee0125592..0e986c804938 100644 --- a/drivers/staging/sep/sep_driver_ext_api.h +++ b/drivers/staging/sep/sep_driver_ext_api.h @@ -51,12 +51,7 @@ This functions copies the cache and resident from their source location into destination memory, which is external to Linux VM and is given as physical address */ -int sep_copy_cache_resident_to_area(unsigned long src_cache_addr, - unsigned long cache_size_in_bytes, - unsigned long src_resident_addr, - unsigned long resident_size_in_bytes, - unsigned long *dst_new_cache_addr_ptr, - unsigned long *dst_new_resident_addr_ptr); +int sep_copy_cache_resident_to_area(unsigned long src_cache_addr, unsigned long cache_size_in_bytes, unsigned long src_resident_addr, unsigned long resident_size_in_bytes, unsigned long *dst_new_cache_addr_ptr, unsigned long *dst_new_resident_addr_ptr); /* This functions maps and allocates the shared area on the external @@ -65,9 +60,7 @@ to allocate. The outputs are kernel_shared_area_addr_ptr - the kerenl address of the mapped and allocated shared area, and phys_shared_area_addr_ptr - the physical address of the shared area */ -int sep_map_and_alloc_shared_area(unsigned long shared_area_size, - unsigned long *kernel_shared_area_addr_ptr, - unsigned long *phys_shared_area_addr_ptr); +int sep_map_and_alloc_shared_area(unsigned long shared_area_size, unsigned long *kernel_shared_area_addr_ptr, unsigned long *phys_shared_area_addr_ptr); /* This functions unmaps and deallocates the shared area on the external @@ -76,9 +69,7 @@ deallocate,kernel_shared_area_addr_ptr - the kernel address of the mapped and allocated shared area,phys_shared_area_addr_ptr - the physical address of the shared area */ -void sep_unmap_and_free_shared_area(unsigned long shared_area_size, - unsigned long kernel_shared_area_addr, - unsigned long phys_shared_area_addr); +void sep_unmap_and_free_shared_area(unsigned long shared_area_size, unsigned long kernel_shared_area_addr, unsigned long phys_shared_area_addr); /* diff --git a/drivers/staging/sep/sep_driver_hw_defs.h b/drivers/staging/sep/sep_driver_hw_defs.h index 49ef8315886e..ea6abd8a14b4 100644 --- a/drivers/staging/sep/sep_driver_hw_defs.h +++ b/drivers/staging/sep/sep_driver_hw_defs.h @@ -229,4 +229,4 @@ #define HW_CLR_SRAM_BUSY_REG_REG_ADDR 0x0F0CUL #define HW_CC_SRAM_BASE_ADDRESS 0x5800UL -#endif /* ifndef HW_DEFS */ +#endif /* ifndef HW_DEFS */ diff --git a/drivers/staging/sep/sep_ext_with_pci_driver.c b/drivers/staging/sep/sep_ext_with_pci_driver.c index 1bebc940aa32..184c61f57704 100644 --- a/drivers/staging/sep/sep_ext_with_pci_driver.c +++ b/drivers/staging/sep/sep_ext_with_pci_driver.c @@ -85,12 +85,12 @@ static unsigned long CRYS_SEP_ROM[] = { /* 2M size */ -#endif /* SEP_DRIVER_ARM_DEBUG_MODE */ +#endif /* SEP_DRIVER_ARM_DEBUG_MODE */ #define BASE_ADDRESS_FOR_SYSTEM 0xfffc0000 #define SEP_RAR_IO_MEM_REGION_SIZE 0x40000 -irqreturn_t sep_inthandler(int irq , void* dev_id); +irqreturn_t sep_inthandler(int irq, void *dev_id); /* Keep this a single static object for now to keep the conversion easy */ @@ -107,12 +107,11 @@ unsigned long jiffies_future; /* function that is activated on the succesfull probe of the SEP device */ -static int __devinit sep_probe(struct pci_dev *pdev, - const struct pci_device_id *ent); +static int __devinit sep_probe(struct pci_dev *pdev, const struct pci_device_id *ent); static struct pci_device_id sep_pci_id_tbl[] = { - { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080c) }, - { 0 } + {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080c)}, + {0} }; MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl); @@ -141,12 +140,7 @@ void sep_lock_cache_resident_area(void) destination memory, which is external to Linux VM and is given as physical address */ -int sep_copy_cache_resident_to_area(unsigned long src_cache_addr, - unsigned long cache_size_in_bytes, - unsigned long src_resident_addr, - unsigned long resident_size_in_bytes, - unsigned long *dst_new_cache_addr_ptr, - unsigned long *dst_new_resident_addr_ptr) +int sep_copy_cache_resident_to_area(unsigned long src_cache_addr, unsigned long cache_size_in_bytes, unsigned long src_resident_addr, unsigned long resident_size_in_bytes, unsigned long *dst_new_cache_addr_ptr, unsigned long *dst_new_resident_addr_ptr) { /* resident address in user space */ unsigned long resident_addr; @@ -157,7 +151,7 @@ int sep_copy_cache_resident_to_area(unsigned long src_cache_addr, const struct firmware *fw; char *cache_name = "cache.image.bin"; - char *res_name = "resident.image.bin"; + char *res_name = "resident.image.bin"; /* error */ int error; @@ -167,14 +161,10 @@ int sep_copy_cache_resident_to_area(unsigned long src_cache_addr, -------------------------------------*/ error = 0; - edbg( - "SEP Driver:rar_virtual is %p\n", - sep_dev->rar_virtual_address); - edbg( - "SEP Driver:rar_physical is %08lx\n", - sep_dev->rar_physical_address); + edbg("SEP Driver:rar_virtual is %p\n", sep_dev->rar_virtual_address); + edbg("SEP Driver:rar_physical is %08lx\n", sep_dev->rar_physical_address); - sep_dev->rar_region_addr = (unsigned long)sep_dev->rar_virtual_address; + sep_dev->rar_region_addr = (unsigned long) sep_dev->rar_virtual_address; sep_dev->cache_physical_address = sep_dev->rar_physical_address; sep_dev->cache_virtual_address = sep_dev->rar_virtual_address; @@ -182,72 +172,50 @@ int sep_copy_cache_resident_to_area(unsigned long src_cache_addr, /* load cache */ error = request_firmware(&fw, cache_name, &sep_dev->sep_pci_dev_ptr->dev); if (error) { - edbg( - "SEP Driver:cant request cache fw\n"); + edbg("SEP Driver:cant request cache fw\n"); goto end_function; } - edbg( - "SEP Driver:cache data loc is %p\n", - (void *)fw->data); - edbg( - "SEP Driver:cache data size is %08Zx\n", - fw->size); + edbg("SEP Driver:cache data loc is %p\n", (void *) fw->data); + edbg("SEP Driver:cache data size is %08Zx\n", fw->size); - memcpy((void *)sep_dev->cache_virtual_address, (void *)fw->data, fw->size); + memcpy((void *) sep_dev->cache_virtual_address, (void *) fw->data, fw->size); sep_dev->cache_size = fw->size; - cache_addr = (unsigned long)sep_dev->cache_virtual_address; + cache_addr = (unsigned long) sep_dev->cache_virtual_address; release_firmware(fw); - sep_dev->resident_physical_address = sep_dev->cache_physical_address - + sep_dev->cache_size; - sep_dev->resident_virtual_address = sep_dev->cache_virtual_address - + sep_dev->cache_size; + sep_dev->resident_physical_address = sep_dev->cache_physical_address + sep_dev->cache_size; + sep_dev->resident_virtual_address = sep_dev->cache_virtual_address + sep_dev->cache_size; /* load resident */ error = request_firmware(&fw, res_name, &sep_dev->sep_pci_dev_ptr->dev); if (error) { - edbg( - "SEP Driver:cant request res fw\n"); + edbg("SEP Driver:cant request res fw\n"); goto end_function; } - edbg( - "SEP Driver:res data loc is %p\n", - (void *)fw->data); - edbg( - "SEP Driver:res data size is %08Zx\n", - fw->size); + edbg("SEP Driver:res data loc is %p\n", (void *) fw->data); + edbg("SEP Driver:res data size is %08Zx\n", fw->size); - memcpy((void *)sep_dev->resident_virtual_address, (void *)fw->data, fw->size); + memcpy((void *) sep_dev->resident_virtual_address, (void *) fw->data, fw->size); sep_dev->resident_size = fw->size; release_firmware(fw); - resident_addr = (unsigned long)sep_dev->resident_virtual_address; + resident_addr = (unsigned long) sep_dev->resident_virtual_address; - edbg( - "SEP Driver:resident_addr (physical )is %08lx\n", - sep_dev->resident_physical_address); - edbg( - "SEP Driver:cache_addr (physical) is %08lx\n", - sep_dev->cache_physical_address); + edbg("SEP Driver:resident_addr (physical )is %08lx\n", sep_dev->resident_physical_address); + edbg("SEP Driver:cache_addr (physical) is %08lx\n", sep_dev->cache_physical_address); - edbg( - "SEP Driver:resident_addr (logical )is %08lx\n", - resident_addr); - edbg( - "SEP Driver:cache_addr (logical) is %08lx\n", - cache_addr); + edbg("SEP Driver:resident_addr (logical )is %08lx\n", resident_addr); + edbg("SEP Driver:cache_addr (logical) is %08lx\n", cache_addr); - edbg( - "SEP Driver:resident_size is %08lx\n", sep_dev->resident_size); - edbg( - "SEP Driver:cache_size is %08lx\n", sep_dev->cache_size); + edbg("SEP Driver:resident_size is %08lx\n", sep_dev->resident_size); + edbg("SEP Driver:cache_size is %08lx\n", sep_dev->cache_size); @@ -255,7 +223,7 @@ int sep_copy_cache_resident_to_area(unsigned long src_cache_addr, *dst_new_cache_addr_ptr = sep_dev->cache_physical_address; *dst_new_resident_addr_ptr = sep_dev->resident_physical_address; -end_function: + end_function: return error; } @@ -270,15 +238,12 @@ end_function: shared area, and phys_shared_area_addr_ptr - the physical address of the shared area */ -int sep_map_and_alloc_shared_area(unsigned long shared_area_size, - unsigned long *kernel_shared_area_addr_ptr, - unsigned long *phys_shared_area_addr_ptr) +int sep_map_and_alloc_shared_area(unsigned long shared_area_size, unsigned long *kernel_shared_area_addr_ptr, unsigned long *phys_shared_area_addr_ptr) { // shared_virtual_address = ioremap_nocache(0xda00000,shared_area_size); sep_dev->shared_virtual_address = kmalloc(shared_area_size, GFP_KERNEL); if (!sep_dev->shared_virtual_address) { - edbg( - "sep_driver:shared memory kmalloc failed\n"); + edbg("sep_driver:shared memory kmalloc failed\n"); return -1; } @@ -286,19 +251,13 @@ int sep_map_and_alloc_shared_area(unsigned long shared_area_size, sep_dev->shared_physical_address = __pa(sep_dev->shared_virtual_address); // shared_physical_address = 0xda00000; - *kernel_shared_area_addr_ptr = (unsigned long)sep_dev->shared_virtual_address; + *kernel_shared_area_addr_ptr = (unsigned long) sep_dev->shared_virtual_address; /* set the physical address of the shared area */ *phys_shared_area_addr_ptr = sep_dev->shared_physical_address; - edbg( - "SEP Driver:shared_virtual_address is %p\n", - sep_dev->shared_virtual_address); - edbg( - "SEP Driver:shared_region_size is %08lx\n", - shared_area_size); - edbg( - "SEP Driver:shared_physical_addr is %08lx\n", - *phys_shared_area_addr_ptr); + edbg("SEP Driver:shared_virtual_address is %p\n", sep_dev->shared_virtual_address); + edbg("SEP Driver:shared_region_size is %08lx\n", shared_area_size); + edbg("SEP Driver:shared_physical_addr is %08lx\n", *phys_shared_area_addr_ptr); return 0; } @@ -311,11 +270,9 @@ int sep_map_and_alloc_shared_area(unsigned long shared_area_size, shared area,phys_shared_area_addr_ptr - the physical address of the shared area */ -void sep_unmap_and_free_shared_area(unsigned long shared_area_size, - unsigned long kernel_shared_area_addr, - unsigned long phys_shared_area_addr) +void sep_unmap_and_free_shared_area(unsigned long shared_area_size, unsigned long kernel_shared_area_addr, unsigned long phys_shared_area_addr) { - kfree((void *)kernel_shared_area_addr); + kfree((void *) kernel_shared_area_addr); return; } @@ -327,16 +284,10 @@ void sep_unmap_and_free_shared_area(unsigned long shared_area_size, */ unsigned long sep_shared_area_virt_to_phys(unsigned long virt_address) { - edbg( - "SEP Driver:sh virt to phys v %08lx\n", - virt_address); - edbg( - "SEP Driver:sh virt to phys p %08lx\n", - sep_dev->shared_physical_address - + (virt_address - (unsigned long)sep_dev->shared_virtual_address)); - - return (unsigned long)sep_dev->shared_physical_address + - (virt_address - (unsigned long)sep_dev->shared_virtual_address); + edbg("SEP Driver:sh virt to phys v %08lx\n", virt_address); + edbg("SEP Driver:sh virt to phys p %08lx\n", sep_dev->shared_physical_address + (virt_address - (unsigned long) sep_dev->shared_virtual_address)); + + return (unsigned long) sep_dev->shared_physical_address + (virt_address - (unsigned long) sep_dev->shared_virtual_address); } /* @@ -347,16 +298,14 @@ unsigned long sep_shared_area_virt_to_phys(unsigned long virt_address) */ unsigned long sep_shared_area_phys_to_virt(unsigned long phys_address) { - return (unsigned long)sep_dev->shared_virtual_address - + (phys_address - sep_dev->shared_physical_address); + return (unsigned long) sep_dev->shared_virtual_address + (phys_address - sep_dev->shared_physical_address); } /* function that is activaed on the succesfull probe of the SEP device */ -static int __devinit sep_probe(struct pci_dev *pdev, - const struct pci_device_id *ent) +static int __devinit sep_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { /* error */ int error; @@ -365,15 +314,13 @@ static int __devinit sep_probe(struct pci_dev *pdev, CODE ---------------------------*/ - edbg( - "Sep pci probe starting\n"); + edbg("Sep pci probe starting\n"); error = 0; /* enable the device */ error = pci_enable_device(pdev); if (error) { - edbg( - "error enabling pci device\n"); + edbg("error enabling pci device\n"); goto end_function; } @@ -383,111 +330,83 @@ static int __devinit sep_probe(struct pci_dev *pdev, /* get the io memory start address */ sep_dev->io_memory_start_physical_address = pci_resource_start(pdev, 0); if (!sep_dev->io_memory_start_physical_address) { - edbg( - "SEP Driver error pci resource start\n"); + edbg("SEP Driver error pci resource start\n"); goto end_function; } /* get the io memory end address */ sep_dev->io_memory_end_physical_address = pci_resource_end(pdev, 0); if (!sep_dev->io_memory_end_physical_address) { - edbg( - "SEP Driver error pci resource end\n"); + edbg("SEP Driver error pci resource end\n"); goto end_function; } - sep_dev->io_memory_size = sep_dev->io_memory_end_physical_address - - sep_dev->io_memory_start_physical_address + 1; + sep_dev->io_memory_size = sep_dev->io_memory_end_physical_address - sep_dev->io_memory_start_physical_address + 1; - edbg( - "SEP Driver:io_memory_start_physical_address is %08lx\n", - sep_dev->io_memory_start_physical_address); + edbg("SEP Driver:io_memory_start_physical_address is %08lx\n", sep_dev->io_memory_start_physical_address); - edbg( - "SEP Driver:io_memory_end_phyaical_address is %08lx\n", - sep_dev->io_memory_end_physical_address); + edbg("SEP Driver:io_memory_end_phyaical_address is %08lx\n", sep_dev->io_memory_end_physical_address); - edbg( - "SEP Driver:io_memory_size is %08lx\n", - sep_dev->io_memory_size); + edbg("SEP Driver:io_memory_size is %08lx\n", sep_dev->io_memory_size); - sep_dev->io_memory_start_virtual_address = - ioremap_nocache(sep_dev->io_memory_start_physical_address, - sep_dev->io_memory_size); + sep_dev->io_memory_start_virtual_address = ioremap_nocache(sep_dev->io_memory_start_physical_address, sep_dev->io_memory_size); if (!sep_dev->io_memory_start_virtual_address) { - edbg( - "SEP Driver error ioremap of io memory\n"); + edbg("SEP Driver error ioremap of io memory\n"); goto end_function; } - edbg( - "SEP Driver:io_memory_start_virtual_address is %p\n", - sep_dev->io_memory_start_virtual_address); + edbg("SEP Driver:io_memory_start_virtual_address is %p\n", sep_dev->io_memory_start_virtual_address); - sep_dev->reg_base_address = (void __iomem *)sep_dev->io_memory_start_virtual_address; + sep_dev->reg_base_address = (void __iomem *) sep_dev->io_memory_start_virtual_address; /* set up system base address and shared memory location */ - sep_dev->rar_virtual_address = kmalloc(2 * SEP_RAR_IO_MEM_REGION_SIZE, - GFP_KERNEL); + sep_dev->rar_virtual_address = kmalloc(2 * SEP_RAR_IO_MEM_REGION_SIZE, GFP_KERNEL); if (!sep_dev->rar_virtual_address) { - edbg( - "SEP Driver:cant kmalloc rar\n"); + edbg("SEP Driver:cant kmalloc rar\n"); goto end_function; - } + } /* FIXME */ sep_dev->rar_physical_address = __pa(sep_dev->rar_virtual_address); - edbg( - "SEP Driver:rar_physical is %08lx\n", - sep_dev->rar_physical_address); + edbg("SEP Driver:rar_physical is %08lx\n", sep_dev->rar_physical_address); - edbg( - "SEP Driver:rar_virtual is %p\n", - sep_dev->rar_virtual_address); + edbg("SEP Driver:rar_virtual is %p\n", sep_dev->rar_virtual_address); #if !SEP_DRIVER_POLLING_MODE - edbg( - "SEP Driver: about to write IMR and ICR REG_ADDR\n"); + edbg("SEP Driver: about to write IMR and ICR REG_ADDR\n"); /* clear ICR register */ - sep_write_reg(sep_dev, HW_HOST_ICR_REG_ADDR, - 0xFFFFFFFF); + sep_write_reg(sep_dev, HW_HOST_ICR_REG_ADDR, 0xFFFFFFFF); /* set the IMR register - open only GPR 2 */ - sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, - (~(0x1 << 13))); + sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13))); /* figure out our irq */ /* FIXME: */ - error = pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, (u8 *)&sep_dev->sep_irq); + error = pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, (u8 *) & sep_dev->sep_irq); - edbg( - "SEP Driver: my irq is %d\n", sep_irq); + edbg("SEP Driver: my irq is %d\n", sep_irq); - edbg( - "SEP Driver: about to call request_irq\n"); + edbg("SEP Driver: about to call request_irq\n"); /* get the interrupt line */ - error = request_irq(sep_irq, sep_inthandler, IRQF_SHARED, - "sep_driver", &sep_dev->reg_base_address); + error = request_irq(sep_irq, sep_inthandler, IRQF_SHARED, "sep_driver", &sep_dev->reg_base_address); if (error) goto end_function; goto end_function; - edbg( - "SEP Driver: about to write IMR REG_ADDR"); + edbg("SEP Driver: about to write IMR REG_ADDR"); /* set the IMR register - open only GPR 2 */ - sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, - (~(0x1 << 13))); + sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13))); -#endif /* SEP_DRIVER_POLLING_MODE */ +#endif /* SEP_DRIVER_POLLING_MODE */ -end_function: + end_function: return error; } @@ -515,26 +434,18 @@ void sep_load_rom_code(void) /* Loading ROM from SEP_ROM_image.h file */ k = sizeof(CRYS_SEP_ROM); - edbg( - "SEP Driver: DX_CC_TST_SepRomLoader start\n"); + edbg("SEP Driver: DX_CC_TST_SepRomLoader start\n"); - edbg( - "SEP Driver: k is %lu\n", k); - edbg( - "SEP Driver: sep_dev->reg_base_address is %p\n", - sep_dev->reg_base_address); - edbg( - "SEP Driver: CRYS_SEP_ROM_start_address_offset is %p\n", - CRYS_SEP_ROM_start_address_offset); + edbg("SEP Driver: k is %lu\n", k); + edbg("SEP Driver: sep_dev->reg_base_address is %p\n", sep_dev->reg_base_address); + edbg("SEP Driver: CRYS_SEP_ROM_start_address_offset is %p\n", CRYS_SEP_ROM_start_address_offset); for (i = 0; i < 4; i++) { /* write bank */ sep_write_reg(sep_dev, SEP_ROM_BANK_register_offset, i); for (j = 0; j < CRYS_SEP_ROM_length / 4; j++) { - sep_write_reg(sep_dev, - CRYS_SEP_ROM_start_address_offset + 4*j, - CRYS_SEP_ROM[i * 0x1000 + j]); + sep_write_reg(sep_dev, CRYS_SEP_ROM_start_address_offset + 4 * j, CRYS_SEP_ROM[i * 0x1000 + j]); k = k - 4; @@ -545,7 +456,7 @@ void sep_load_rom_code(void) } } - /* reset the SEP*/ + /* reset the SEP */ sep_write_reg(sep_dev, HW_HOST_SEP_SW_RST_REG_ADDR, 0x1); /* poll for SEP ROM boot finish */ @@ -553,49 +464,41 @@ void sep_load_rom_code(void) retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR); } while (!regVal); - edbg( - "SEP Driver: ROM polling ended\n"); + edbg("SEP Driver: ROM polling ended\n"); switch (regVal) { case 0x1: /* fatal error - read erro status from GPRO */ Error = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR); - edbg( - "SEP Driver: ROM polling case 1\n"); + edbg("SEP Driver: ROM polling case 1\n"); break; case 0x2: /* Boot First Phase ended */ warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR); - edbg( - "SEP Driver: ROM polling case 2\n"); + edbg("SEP Driver: ROM polling case 2\n"); break; case 0x4: /* Cold boot ended successfully */ warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR); - edbg( - "SEP Driver: ROM polling case 4\n"); + edbg("SEP Driver: ROM polling case 4\n"); Error = 0; break; case 0x8: /* Warmboot ended successfully */ warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR); - edbg( - "SEP Driver: ROM polling case 8\n"); + edbg("SEP Driver: ROM polling case 8\n"); Error = 0; break; case 0x10: /* ColdWarm boot ended successfully */ warning = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR); - edbg( - "SEP Driver: ROM polling case 16\n"); + edbg("SEP Driver: ROM polling case 16\n"); Error = 0; break; case 0x20: - edbg( - "SEP Driver: ROM polling case 32\n"); + edbg("SEP Driver: ROM polling case 32\n"); break; } #endif } - diff --git a/drivers/staging/sep/sep_main_mod.c b/drivers/staging/sep/sep_main_mod.c index 1822df8b9d2c..4bd3d0e08808 100644 --- a/drivers/staging/sep/sep_main_mod.c +++ b/drivers/staging/sep/sep_main_mod.c @@ -72,13 +72,13 @@ INT_MODULE_PARM(sepDebug, 0x0); MODULE_PARM_DESC(sepDebug, "Flag to enable SEP debug messages"); /* major and minor device numbers */ -static dev_t g_sep_device_number; +static dev_t g_sep_device_number; /* the files operations structure of the driver */ -static struct file_operations g_sep_fops; +static struct file_operations g_sep_fops; /* cdev struct of the driver */ -static struct cdev g_sep_cdev; +static struct cdev g_sep_cdev; /* mutex for the access to the internals of the sep driver @@ -103,7 +103,7 @@ irqreturn_t sep_inthandler(int irq, void *dev_id); /* this function registers the driver to the file system */ -static int sep_register_driver_to_fs(void); +static int sep_register_driver_to_fs(void); /* this function unregisters driver from fs @@ -115,26 +115,18 @@ static void sep_unregister_driver_from_fs(void); table from this array the condition is that either the table is full (all etnries are entered), or there are no more entries in the lli array */ -static unsigned long sep_calculate_lli_table_max_size( - struct sep_lli_entry_t *lli_in_array_ptr, - unsigned long num_array_entries); +static unsigned long sep_calculate_lli_table_max_size(struct sep_lli_entry_t *lli_in_array_ptr, unsigned long num_array_entries); /* this functions builds ont lli table from the lli_array according to the given size of data */ -static void sep_build_lli_table(struct sep_lli_entry_t *lli_array_ptr, - struct sep_lli_entry_t *lli_table_ptr, - unsigned long *num_processed_entries_ptr, - unsigned long *num_table_entries_ptr, - unsigned long table_data_size); +static void sep_build_lli_table(struct sep_lli_entry_t *lli_array_ptr, struct sep_lli_entry_t *lli_table_ptr, unsigned long *num_processed_entries_ptr, unsigned long *num_table_entries_ptr, unsigned long table_data_size); /* this function goes over the list of the print created tables and prints all the data */ -static void sep_debug_print_lli_tables(struct sep_lli_entry_t *lli_table_ptr, - unsigned long num_table_entries, - unsigned long table_data_size); +static void sep_debug_print_lli_tables(struct sep_lli_entry_t *lli_table_ptr, unsigned long num_table_entries, unsigned long table_data_size); @@ -219,53 +211,38 @@ static int sep_realloc_cache_resident_handler(unsigned long arg); static int sep_set_api_mode_handler(unsigned long arg); /* handler for flow done interrupt */ -static void sep_flow_done_handler(struct work_struct *work); +static void sep_flow_done_handler(struct work_struct *work); /* This function locks all the physical pages of the kernel virtual buffer and construct a basic lli array, where each entry holds the physical page address and the size that application data holds in this physical pages */ -static int sep_lock_kernel_pages(unsigned long kernel_virt_addr, - unsigned long data_size, - unsigned long *num_pages_ptr, - struct sep_lli_entry_t **lli_array_ptr, - struct page ***page_array_ptr); +static int sep_lock_kernel_pages(unsigned long kernel_virt_addr, unsigned long data_size, unsigned long *num_pages_ptr, struct sep_lli_entry_t **lli_array_ptr, struct page ***page_array_ptr); /* This function creates one DMA table for flow and returns its data, and pointer to its info entry */ -static int sep_prepare_one_flow_dma_table(unsigned long virt_buff_addr, - unsigned long virt_buff_size, - struct sep_lli_entry_t *table_data, - struct sep_lli_entry_t **info_entry_ptr, - struct sep_flow_context_t *flow_data_ptr, - bool isKernelVirtualAddress); +static int sep_prepare_one_flow_dma_table(unsigned long virt_buff_addr, unsigned long virt_buff_size, struct sep_lli_entry_t *table_data, struct sep_lli_entry_t **info_entry_ptr, struct sep_flow_context_t *flow_data_ptr, bool isKernelVirtualAddress); /* This function creates a list of tables for flow and returns the data for the first and last tables of the list */ -static int sep_prepare_flow_dma_tables(unsigned long num_virtual_buffers, - unsigned long first_buff_addr, - struct sep_flow_context_t *flow_data_ptr, - struct sep_lli_entry_t *first_table_data_ptr, - struct sep_lli_entry_t *last_table_data_ptr, - bool isKernelVirtualAddress); +static int sep_prepare_flow_dma_tables(unsigned long num_virtual_buffers, + unsigned long first_buff_addr, struct sep_flow_context_t *flow_data_ptr, struct sep_lli_entry_t *first_table_data_ptr, struct sep_lli_entry_t *last_table_data_ptr, bool isKernelVirtualAddress); /* this function find a space for the new flow dma table */ -static int sep_find_free_flow_dma_table_space( - unsigned long **table_address_ptr); +static int sep_find_free_flow_dma_table_space(unsigned long **table_address_ptr); /* this function goes over all the flow tables connected to the given table and deallocate them */ -static void sep_deallocated_flow_tables( - struct sep_lli_entry_t *first_table_ptr); +static void sep_deallocated_flow_tables(struct sep_lli_entry_t *first_table_ptr); /* This function handler the set flow id command @@ -276,8 +253,7 @@ static int sep_set_flow_id_handler(unsigned long arg); This function returns pointer to the flow data structure that conatins the given id */ -static int sep_find_flow_context(unsigned long flow_id, - struct sep_flow_context_t **flow_data_ptr); +static int sep_find_flow_context(unsigned long flow_id, struct sep_flow_context_t **flow_data_ptr); /* @@ -300,8 +276,7 @@ static int sep_get_time_handler(unsigned long arg); /* calculates time and sets it at the predefined address */ -static int sep_set_time(unsigned long *address_ptr, - unsigned long *time_in_sec_ptr); +static int sep_set_time(unsigned long *address_ptr, unsigned long *time_in_sec_ptr); /* PATCH for configuring the DMA to single burst instead of multi-burst @@ -314,11 +289,7 @@ static void sep_configure_dma_burst(void); array, where each entry holds the physical page address and the size that application data holds in this physical pages */ -static int sep_lock_user_pages(unsigned long app_virt_addr, - unsigned long data_size, - unsigned long *num_pages_ptr, - struct sep_lli_entry_t **lli_array_ptr, - struct page ***page_array_ptr); +static int sep_lock_user_pages(unsigned long app_virt_addr, unsigned long data_size, unsigned long *num_pages_ptr, struct sep_lli_entry_t **lli_array_ptr, struct page ***page_array_ptr); /*--------------------------------------------- FUNCTIONS @@ -329,9 +300,9 @@ static int sep_lock_user_pages(unsigned long app_virt_addr, */ int sep_lock() { - mutex_lock(&sep_mutex); + mutex_lock(&sep_mutex); - return 0; + return 0; } /* @@ -339,16 +310,16 @@ int sep_lock() */ void sep_unlock() { - /* release mutex */ - mutex_unlock(&sep_mutex); + /* release mutex */ + mutex_unlock(&sep_mutex); } /* this function returns the address of the message shared area */ -void sep_map_shared_area(unsigned long *mappedAddr_ptr) +void sep_map_shared_area(unsigned long *mappedAddr_ptr) { - *mappedAddr_ptr = sep_dev->shared_area_addr; + *mappedAddr_ptr = sep_dev->shared_area_addr; } /* @@ -356,31 +327,30 @@ void sep_map_shared_area(unsigned long *mappedAddr_ptr) */ void sep_send_msg_rdy_cmd() { - sep_send_command_handler(); + sep_send_command_handler(); } /* this functions frees all the resources that were allocated for the building of the LLI DMA tables */ void sep_free_dma_resources() { - sep_free_dma_table_data_handler(); + sep_free_dma_table_data_handler(); } /* poll(suspend), until reply from sep */ void sep_driver_poll() { - unsigned long retVal = 0; + unsigned long retVal = 0; #ifdef SEP_DRIVER_POLLING_MODE - while (sep_dev->host_to_sep_send_counter != (retVal & 0x7FFFFFFF)) - retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR2_REG_ADDR); + while (sep_dev->host_to_sep_send_counter != (retVal & 0x7FFFFFFF)) + retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR2_REG_ADDR); - sep_dev->sep_to_host_reply_counter++; + sep_dev->sep_to_host_reply_counter++; #else - /* poll, until reply from sep */ - wait_event(g_sep_event, - (sep_dev->host_to_sep_send_counter == sep_dev->sep_to_host_reply_counter)); + /* poll, until reply from sep */ + wait_event(g_sep_event, (sep_dev->host_to_sep_send_counter == sep_dev->sep_to_host_reply_counter)); #endif } @@ -391,40 +361,39 @@ void sep_driver_poll() ------------------------------------------------------------------------*/ static int sep_open(struct inode *inode_ptr, struct file *file_ptr) { - /* return value */ - int error; + /* return value */ + int error; /*----------------- CODE ---------------------*/ - dbg("SEP Driver:--------> open start\n"); + dbg("SEP Driver:--------> open start\n"); - error = 0; + error = 0; - /* check the blocking mode */ - if (sep_dev->block_mode_flag) - /* lock mutex */ - mutex_lock(&sep_mutex); - else - error = mutex_trylock(&sep_mutex); + /* check the blocking mode */ + if (sep_dev->block_mode_flag) + /* lock mutex */ + mutex_lock(&sep_mutex); + else + error = mutex_trylock(&sep_mutex); - /* check the error */ - if (error) { - edbg( - "SEP Driver: down_interruptible failed\n"); + /* check the error */ + if (error) { + edbg("SEP Driver: down_interruptible failed\n"); - goto end_function; - } + goto end_function; + } - /* release data pool allocations */ - sep_dev->data_pool_bytes_allocated = 0; + /* release data pool allocations */ + sep_dev->data_pool_bytes_allocated = 0; -end_function: + end_function: - dbg("SEP Driver:<-------- open end\n"); + dbg("SEP Driver:<-------- open end\n"); - return error; + return error; } @@ -439,23 +408,23 @@ static int sep_release(struct inode *inode_ptr, struct file *file_ptr) CODE ---------------------*/ - dbg("----------->SEP Driver: sep_release start\n"); + dbg("----------->SEP Driver: sep_release start\n"); -#if 0/*!SEP_DRIVER_POLLING_MODE*/ - /* close IMR */ - sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, 0x7FFF); +#if 0 /*!SEP_DRIVER_POLLING_MODE */ + /* close IMR */ + sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, 0x7FFF); - /* release IRQ line */ - free_irq(SEP_DIRVER_IRQ_NUM, &sep_dev->reg_base_address); + /* release IRQ line */ + free_irq(SEP_DIRVER_IRQ_NUM, &sep_dev->reg_base_address); #endif - /* unlock the sep mutex */ - mutex_unlock(&sep_mutex); + /* unlock the sep mutex */ + mutex_unlock(&sep_mutex); - dbg("SEP Driver:<-------- sep_release end\n"); + dbg("SEP Driver:<-------- sep_release end\n"); - return 0; + return 0; } @@ -464,252 +433,228 @@ static int sep_release(struct inode *inode_ptr, struct file *file_ptr) /*--------------------------------------------------------------- map function - this functions maps the message shared area -----------------------------------------------------------------*/ -static int sep_mmap(struct file *filp, struct vm_area_struct *vma) +static int sep_mmap(struct file *filp, struct vm_area_struct *vma) { - /* physical addr */ - unsigned long phys_addr; + /* physical addr */ + unsigned long phys_addr; /*----------------------- CODE -------------------------*/ - dbg("-------->SEP Driver: mmap start\n"); + dbg("-------->SEP Driver: mmap start\n"); - /* check that the size of the mapped range is as the size of the message - shared area */ - if ((vma->vm_end - vma->vm_start) > SEP_DRIVER_MMMAP_AREA_SIZE) { - edbg( - "SEP Driver mmap requested size is more than allowed\n"); - printk(KERN_WARNING "SEP Driver mmap requested size is more \ + /* check that the size of the mapped range is as the size of the message + shared area */ + if ((vma->vm_end - vma->vm_start) > SEP_DRIVER_MMMAP_AREA_SIZE) { + edbg("SEP Driver mmap requested size is more than allowed\n"); + printk(KERN_WARNING "SEP Driver mmap requested size is more \ than allowed\n"); - printk(KERN_WARNING "SEP Driver vma->vm_end is %08lx\n", - vma->vm_end); - printk(KERN_WARNING "SEP Driver vma->vm_end is %08lx\n", - vma->vm_start); - return -EAGAIN; - } - - edbg( - "SEP Driver:g_message_shared_area_addr is %08lx\n", - sep_dev->message_shared_area_addr); - - /* get physical address */ - phys_addr = sep_dev->phys_shared_area_addr; - - edbg( "SEP Driver: phys_addr is %08lx\n", -phys_addr); - - if (remap_pfn_range(vma, - vma->vm_start, - phys_addr >> PAGE_SHIFT, - vma->vm_end - vma->vm_start, - vma->vm_page_prot)) { - edbg( - "SEP Driver remap_page_range failed\n"); - printk(KERN_WARNING "SEP Driver remap_page_range failed\n"); - return -EAGAIN; - } - - dbg("SEP Driver:<-------- mmap end\n"); - - return 0; + printk(KERN_WARNING "SEP Driver vma->vm_end is %08lx\n", vma->vm_end); + printk(KERN_WARNING "SEP Driver vma->vm_end is %08lx\n", vma->vm_start); + return -EAGAIN; + } + + edbg("SEP Driver:g_message_shared_area_addr is %08lx\n", sep_dev->message_shared_area_addr); + + /* get physical address */ + phys_addr = sep_dev->phys_shared_area_addr; + + edbg("SEP Driver: phys_addr is %08lx\n", phys_addr); + + if (remap_pfn_range(vma, vma->vm_start, phys_addr >> PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot)) { + edbg("SEP Driver remap_page_range failed\n"); + printk(KERN_WARNING "SEP Driver remap_page_range failed\n"); + return -EAGAIN; + } + + dbg("SEP Driver:<-------- mmap end\n"); + + return 0; } /*----------------------------------------------- poll function *----------------------------------------------*/ -static unsigned int sep_poll(struct file *filp, poll_table *wait) +static unsigned int sep_poll(struct file *filp, poll_table * wait) { - unsigned long count; + unsigned long count; - unsigned int mask = 0; + unsigned int mask = 0; - /* flow id */ - unsigned long retVal = 0; + /* flow id */ + unsigned long retVal = 0; /*---------------------------------------------- CODE -------------------------------------------------*/ - dbg("---------->SEP Driver poll: start\n"); + dbg("---------->SEP Driver poll: start\n"); #if SEP_DRIVER_POLLING_MODE - while (sep_dev->host_to_sep_send_counter != (retVal & 0x7FFFFFFF)) { - retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR2_REG_ADDR); + while (sep_dev->host_to_sep_send_counter != (retVal & 0x7FFFFFFF)) { + retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR2_REG_ADDR); - for (count = 0; count < 10 * 4; count += 4) - edbg("Poll Debug Word %lu of the message is %lu\n", count, - *((unsigned long *)(sep_dev->shared_area_addr + - SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + count))); - } + for (count = 0; count < 10 * 4; count += 4) + edbg("Poll Debug Word %lu of the message is %lu\n", count, *((unsigned long *) (sep_dev->shared_area_addr + SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + count))); + } - sep_dev->sep_to_host_reply_counter++; + sep_dev->sep_to_host_reply_counter++; #else - /* add the event to the polling wait table */ - poll_wait(filp, &g_sep_event, wait); + /* add the event to the polling wait table */ + poll_wait(filp, &g_sep_event, wait); #endif - edbg( - "sep_dev->host_to_sep_send_counter is %lu\n", - sep_dev->host_to_sep_send_counter); - edbg( - "sep_dev->sep_to_host_reply_counter is %lu\n", - sep_dev->sep_to_host_reply_counter); - - /* check if the data is ready */ - if (sep_dev->host_to_sep_send_counter == sep_dev->sep_to_host_reply_counter) { - for (count = 0; count < 12 * 4; count += 4) - edbg("Sep Mesg Word %lu of the message is %lu\n", count, - *((unsigned long *)(sep_dev->shared_area_addr + count))); - - for (count = 0; count < 10 * 4; count += 4) - edbg("Debug Data Word %lu of the message is %lu\n", count, - *((unsigned long *)(sep_dev->shared_area_addr + 0x1800 + count))); - - retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR2_REG_ADDR); - edbg( "retVal is %lu\n", retVal); - /* check if the this is sep reply or request */ - if (retVal >> 31) { - edbg( - "SEP Driver: sep request in\n"); - /* request */ - mask |= POLLOUT | POLLWRNORM; - } else { - edbg( "SEP Driver: sep reply in\n"); - mask |= POLLIN | POLLRDNORM; + edbg("sep_dev->host_to_sep_send_counter is %lu\n", sep_dev->host_to_sep_send_counter); + edbg("sep_dev->sep_to_host_reply_counter is %lu\n", sep_dev->sep_to_host_reply_counter); + + /* check if the data is ready */ + if (sep_dev->host_to_sep_send_counter == sep_dev->sep_to_host_reply_counter) { + for (count = 0; count < 12 * 4; count += 4) + edbg("Sep Mesg Word %lu of the message is %lu\n", count, *((unsigned long *) (sep_dev->shared_area_addr + count))); + + for (count = 0; count < 10 * 4; count += 4) + edbg("Debug Data Word %lu of the message is %lu\n", count, *((unsigned long *) (sep_dev->shared_area_addr + 0x1800 + count))); + + retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR2_REG_ADDR); + edbg("retVal is %lu\n", retVal); + /* check if the this is sep reply or request */ + if (retVal >> 31) { + edbg("SEP Driver: sep request in\n"); + /* request */ + mask |= POLLOUT | POLLWRNORM; + } else { + edbg("SEP Driver: sep reply in\n"); + mask |= POLLIN | POLLRDNORM; + } } - } - dbg("SEP Driver:<-------- poll exit\n"); - return mask; + dbg("SEP Driver:<-------- poll exit\n"); + return mask; } -static int sep_ioctl(struct inode *inode, - struct file *filp, - unsigned int cmd, - unsigned long arg) +static int sep_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) { - /* error */ - int error; + /* error */ + int error; /*------------------------ CODE ------------------------*/ - error = 0; + error = 0; - dbg("------------>SEP Driver: ioctl start\n"); + dbg("------------>SEP Driver: ioctl start\n"); - edbg("SEP Driver: cmd is %x\n", cmd); + edbg("SEP Driver: cmd is %x\n", cmd); - /* check that the command is for sep device */ - if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) - error = -ENOTTY; + /* check that the command is for sep device */ + if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) + error = -ENOTTY; switch (cmd) { case SEP_IOCSENDSEPCOMMAND: - /* send command to SEP */ - sep_send_command_handler(); + /* send command to SEP */ + sep_send_command_handler(); - edbg( - "SEP Driver: after sep_send_command_handler\n"); + edbg("SEP Driver: after sep_send_command_handler\n"); - break; + break; case SEP_IOCSENDSEPRPLYCOMMAND: - /* send reply command to SEP */ - sep_send_reply_command_handler(); + /* send reply command to SEP */ + sep_send_reply_command_handler(); - break; + break; case SEP_IOCALLOCDATAPOLL: - /* allocate data pool */ - error = sep_allocate_data_pool_memory_handler(arg); + /* allocate data pool */ + error = sep_allocate_data_pool_memory_handler(arg); - break; + break; case SEP_IOCWRITEDATAPOLL: - /* write data into memory pool */ - error = sep_write_into_data_pool_handler(arg); + /* write data into memory pool */ + error = sep_write_into_data_pool_handler(arg); - break; + break; case SEP_IOCREADDATAPOLL: - /* read data from data pool into application memory */ - error = sep_read_from_data_pool_handler(arg); + /* read data from data pool into application memory */ + error = sep_read_from_data_pool_handler(arg); - break; + break; case SEP_IOCCREATESYMDMATABLE: - /* create dma table for synhronic operation */ - error = sep_create_sync_dma_tables_handler(arg); + /* create dma table for synhronic operation */ + error = sep_create_sync_dma_tables_handler(arg); - break; + break; case SEP_IOCCREATEFLOWDMATABLE: - /* create flow dma tables */ - error = sep_create_flow_dma_tables_handler(arg); + /* create flow dma tables */ + error = sep_create_flow_dma_tables_handler(arg); - break; + break; case SEP_IOCFREEDMATABLEDATA: - /* free the pages */ - error = sep_free_dma_table_data_handler(); + /* free the pages */ + error = sep_free_dma_table_data_handler(); - break; + break; case SEP_IOCSETFLOWID: - /* set flow id */ - error = sep_set_flow_id_handler(arg); + /* set flow id */ + error = sep_set_flow_id_handler(arg); - break; + break; case SEP_IOCADDFLOWTABLE: - /* add tables to the dynamic flow */ - error = sep_add_flow_tables_handler(arg); + /* add tables to the dynamic flow */ + error = sep_add_flow_tables_handler(arg); - break; + break; case SEP_IOCADDFLOWMESSAGE: - /* add message of add tables to flow */ - error = sep_add_flow_tables_message_handler(arg); + /* add message of add tables to flow */ + error = sep_add_flow_tables_message_handler(arg); - break; + break; case SEP_IOCSEPSTART: - /* start command to sep */ - error = sep_start_handler(); - break; + /* start command to sep */ + error = sep_start_handler(); + break; case SEP_IOCSEPINIT: - /* init command to sep */ - error = sep_init_handler(arg); - break; + /* init command to sep */ + error = sep_init_handler(arg); + break; case SEP_IOCSETAPIMODE: - /* set non- blocking mode */ - error = sep_set_api_mode_handler(arg); + /* set non- blocking mode */ + error = sep_set_api_mode_handler(arg); - break; + break; case SEP_IOCGETSTATICPOOLADDR: @@ -720,89 +665,86 @@ static int sep_ioctl(struct inode *inode, case SEP_IOCENDTRANSACTION: - error = sep_end_transaction_handler(arg); + error = sep_end_transaction_handler(arg); break; case SEP_IOCREALLOCCACHERES: - error = sep_realloc_cache_resident_handler(arg); + error = sep_realloc_cache_resident_handler(arg); - break; + break; case SEP_IOCGETMAPPEDADDROFFSET: - error = sep_get_physical_mapped_offset_handler(arg); + error = sep_get_physical_mapped_offset_handler(arg); - break; + break; case SEP_IOCGETIME: - error = sep_get_time_handler(arg); + error = sep_get_time_handler(arg); - break; + break; default: - error = -ENOTTY; - break; - } + error = -ENOTTY; + break; + } - dbg("SEP Driver:<-------- ioctl end\n"); + dbg("SEP Driver:<-------- ioctl end\n"); - return error; + return error; } /* this function registers the driver to the file system */ -static int sep_register_driver_to_fs(void) +static int sep_register_driver_to_fs(void) { - /* return value */ - int ret_val; + /* return value */ + int ret_val; /*--------------------- CODE -----------------------*/ - ret_val = alloc_chrdev_region(&g_sep_device_number, 0, 1, "sep_sec_driver"); - if (ret_val) { - edbg( - "sep_driver:major number allocation failed, retval is %d\n", ret_val); - goto end_function; - } + ret_val = alloc_chrdev_region(&g_sep_device_number, 0, 1, "sep_sec_driver"); + if (ret_val) { + edbg("sep_driver:major number allocation failed, retval is %d\n", ret_val); + goto end_function; + } - /* set the files operations structure */ - g_sep_fops.owner = THIS_MODULE; - g_sep_fops.ioctl = sep_ioctl; - g_sep_fops.poll = sep_poll; - g_sep_fops.open = sep_open; - g_sep_fops.release = sep_release; - g_sep_fops.mmap = sep_mmap; + /* set the files operations structure */ + g_sep_fops.owner = THIS_MODULE; + g_sep_fops.ioctl = sep_ioctl; + g_sep_fops.poll = sep_poll; + g_sep_fops.open = sep_open; + g_sep_fops.release = sep_release; + g_sep_fops.mmap = sep_mmap; - /* init cdev */ - cdev_init(&g_sep_cdev, &g_sep_fops); - g_sep_cdev.owner = THIS_MODULE; + /* init cdev */ + cdev_init(&g_sep_cdev, &g_sep_fops); + g_sep_cdev.owner = THIS_MODULE; - /* register the driver with the kernel */ - ret_val = cdev_add(&g_sep_cdev, g_sep_device_number, 1); + /* register the driver with the kernel */ + ret_val = cdev_add(&g_sep_cdev, g_sep_device_number, 1); - if (ret_val) { - edbg( - "sep_driver:cdev_add failed, retval is %d\n", - ret_val); - goto end_function_unregister_devnum; - } + if (ret_val) { + edbg("sep_driver:cdev_add failed, retval is %d\n", ret_val); + goto end_function_unregister_devnum; + } - goto end_function; + goto end_function; -end_function_unregister_devnum: + end_function_unregister_devnum: - /* unregister dev numbers */ - unregister_chrdev_region(g_sep_device_number, 1); + /* unregister dev numbers */ + unregister_chrdev_region(g_sep_device_number, 1); -end_function: + end_function: - return ret_val; + return ret_val; } /* @@ -814,10 +756,10 @@ static void sep_unregister_driver_from_fs(void) CODE ---------------------*/ - cdev_del(&g_sep_cdev); + cdev_del(&g_sep_cdev); - /* unregister dev numbers */ - unregister_chrdev_region(g_sep_device_number, 1); + /* unregister dev numbers */ + unregister_chrdev_region(g_sep_device_number, 1); } /*-------------------------------------------------------------- @@ -825,142 +767,125 @@ static void sep_unregister_driver_from_fs(void) ----------------------------------------------------------------*/ static int __init sep_init(void) { - /* return value */ - int ret_val; + /* return value */ + int ret_val; - /* counter */ - int counter; + /* counter */ + int counter; - /* size to of memory for allocation */ - int size; + /* size to of memory for allocation */ + int size; /*------------------------ CODE ------------------------*/ - dbg("SEP Driver:-------->Init start\n"); - edbg("sep->shared_area_addr = %lx\n", - (unsigned long)&sep_dev->shared_area_addr); + dbg("SEP Driver:-------->Init start\n"); + edbg("sep->shared_area_addr = %lx\n", (unsigned long) &sep_dev->shared_area_addr); - ret_val = 0; + ret_val = 0; /* transaction counter that coordinates the transactions between SEP and HOST */ - sep_dev->host_to_sep_send_counter = 0; + sep_dev->host_to_sep_send_counter = 0; /* counter for the messages from sep */ - sep_dev->sep_to_host_reply_counter = 0; + sep_dev->sep_to_host_reply_counter = 0; /* counter for the number of bytes allocated in the pool for the current transaction */ - sep_dev->data_pool_bytes_allocated = 0; + sep_dev->data_pool_bytes_allocated = 0; - /* set the starting mode to blocking */ - sep_dev->block_mode_flag = 1; + /* set the starting mode to blocking */ + sep_dev->block_mode_flag = 1; - ret_val = sep_register_driver_to_device(); - if (ret_val) { - edbg( - "sep_driver:sep_driver_to_device failed, ret_val is %d\n", - ret_val); - goto end_function_unregister_from_fs; - } + ret_val = sep_register_driver_to_device(); + if (ret_val) { + edbg("sep_driver:sep_driver_to_device failed, ret_val is %d\n", ret_val); + goto end_function_unregister_from_fs; + } - /* calculate the total size for allocation */ - size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + - SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_SIZE_IN_BYTES + - SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES + - SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES + - SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES + - SEP_DRIVER_SYSTEM_DATA_MEMORY_SIZE_IN_BYTES; + /* calculate the total size for allocation */ + size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_SIZE_IN_BYTES + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES + SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES + SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES + SEP_DRIVER_SYSTEM_DATA_MEMORY_SIZE_IN_BYTES; - /* allocate the shared area */ - if (sep_map_and_alloc_shared_area(size, - &sep_dev->shared_area_addr, - &sep_dev->phys_shared_area_addr)) { - ret_val = -ENOMEM; - /* allocation failed */ - goto end_function_unmap_io_memory; - } + /* allocate the shared area */ + if (sep_map_and_alloc_shared_area(size, &sep_dev->shared_area_addr, &sep_dev->phys_shared_area_addr)) { + ret_val = -ENOMEM; + /* allocation failed */ + goto end_function_unmap_io_memory; + } - /* now set the memory regions */ - sep_dev->message_shared_area_addr = sep_dev->shared_area_addr; + /* now set the memory regions */ + sep_dev->message_shared_area_addr = sep_dev->shared_area_addr; - edbg( - "SEP Driver: g_message_shared_area_addr is %08lx\n", - sep_dev->message_shared_area_addr); + edbg("SEP Driver: g_message_shared_area_addr is %08lx\n", sep_dev->message_shared_area_addr); #if (SEP_DRIVER_RECONFIG_MESSAGE_AREA == 1) - /* send the new SHARED MESSAGE AREA to the SEP */ - sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR1_REG_ADDR, - sep_dev->phys_shared_area_addr); + /* send the new SHARED MESSAGE AREA to the SEP */ + sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR1_REG_ADDR, sep_dev->phys_shared_area_addr); - /* poll for SEP response */ - retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR1_REG_ADDR); - while (retVal != 0xffffffff && retVal != sep_dev->phys_shared_area_addr) + /* poll for SEP response */ retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR1_REG_ADDR); + while (retVal != 0xffffffff && retVal != sep_dev->phys_shared_area_addr) + retVal = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR1_REG_ADDR); - /* check the return value (register) */ - if (retVal != sep_dev->phys_shared_area_addr) { - ret_val = -ENOMEM; - goto end_function_deallocate_message_area; - } - + /* check the return value (register) */ + if (retVal != sep_dev->phys_shared_area_addr) { + ret_val = -ENOMEM; + goto end_function_deallocate_message_area; + } #endif - /* init the flow contextes */ - for (counter = 0; counter < SEP_DRIVER_NUM_FLOWS; counter++) - sep_dev->flows_data_array[counter].flow_id = SEP_FREE_FLOW_ID; + /* init the flow contextes */ + for (counter = 0; counter < SEP_DRIVER_NUM_FLOWS; counter++) + sep_dev->flows_data_array[counter].flow_id = SEP_FREE_FLOW_ID; - sep_dev->flow_wq_ptr = create_singlethread_workqueue("sepflowwq"); - if (sep_dev->flow_wq_ptr == 0) { - ret_val = -ENOMEM; - edbg( - "sep_driver:flow queue creation failed\n"); - goto end_function_deallocate_sep_shared_area; - } + sep_dev->flow_wq_ptr = create_singlethread_workqueue("sepflowwq"); + if (sep_dev->flow_wq_ptr == 0) { + ret_val = -ENOMEM; + edbg("sep_driver:flow queue creation failed\n"); + goto end_function_deallocate_sep_shared_area; + } - edbg( - "SEP Driver: create flow workqueue \n"); + edbg("SEP Driver: create flow workqueue \n"); - /* register driver to fs */ - ret_val = sep_register_driver_to_fs(); - if (ret_val) - goto end_function_deallocate_sep_shared_area; + /* register driver to fs */ + ret_val = sep_register_driver_to_fs(); + if (ret_val) + goto end_function_deallocate_sep_shared_area; - /* load the rom code */ - sep_load_rom_code(); + /* load the rom code */ + sep_load_rom_code(); - goto end_function; + goto end_function; -end_function_unregister_from_fs: + end_function_unregister_from_fs: - /* unregister from fs */ - sep_unregister_driver_from_fs(); + /* unregister from fs */ + sep_unregister_driver_from_fs(); -end_function_deallocate_sep_shared_area: + end_function_deallocate_sep_shared_area: - /* de-allocate shared area */ - sep_unmap_and_free_shared_area(size, - sep_dev->shared_area_addr, - sep_dev->phys_shared_area_addr); + /* de-allocate shared area */ + sep_unmap_and_free_shared_area(size, sep_dev->shared_area_addr, sep_dev->phys_shared_area_addr); -end_function_unmap_io_memory: + end_function_unmap_io_memory: - iounmap((void *)sep_dev->reg_base_address); + iounmap((void *) sep_dev->reg_base_address); - /* release io memory region */ - release_mem_region(SEP_IO_MEM_REGION_START_ADDRESS, SEP_IO_MEM_REGION_SIZE); + /* release io memory region */ + release_mem_region(SEP_IO_MEM_REGION_START_ADDRESS, SEP_IO_MEM_REGION_SIZE); -end_function: + end_function: - dbg("SEP Driver:<-------- Init end\n"); + dbg("SEP Driver:<-------- Init end\n"); - return ret_val; + return ret_val; } @@ -971,45 +896,38 @@ end_function: --------------------------------------------------------------*/ static void __exit sep_exit(void) { - /* size */ - int size; + /* size */ + int size; /*----------------------------- CODE --------------------------------*/ - dbg("SEP Driver:--------> Exit start\n"); + dbg("SEP Driver:--------> Exit start\n"); - /* unregister from fs */ - sep_unregister_driver_from_fs(); + /* unregister from fs */ + sep_unregister_driver_from_fs(); - /* calculate the total size for de-allocation */ - size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + - SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_SIZE_IN_BYTES + - SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES + - SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES + - SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES + - SEP_DRIVER_SYSTEM_DATA_MEMORY_SIZE_IN_BYTES; + /* calculate the total size for de-allocation */ + size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_SIZE_IN_BYTES + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES + SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES + SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES + SEP_DRIVER_SYSTEM_DATA_MEMORY_SIZE_IN_BYTES; - /* free shared area */ - sep_unmap_and_free_shared_area(size, - sep_dev->shared_area_addr, - sep_dev->phys_shared_area_addr); + /* free shared area */ + sep_unmap_and_free_shared_area(size, sep_dev->shared_area_addr, sep_dev->phys_shared_area_addr); - edbg( - "SEP Driver: free pages SEP SHARED AREA \n"); + edbg("SEP Driver: free pages SEP SHARED AREA \n"); - iounmap((void *)sep_dev->reg_base_address); + iounmap((void *) sep_dev->reg_base_address); - edbg( "SEP Driver: iounmap \n"); + edbg("SEP Driver: iounmap \n"); - /* release io memory region */ - release_mem_region(SEP_IO_MEM_REGION_START_ADDRESS, SEP_IO_MEM_REGION_SIZE); + /* release io memory region */ + release_mem_region(SEP_IO_MEM_REGION_START_ADDRESS, SEP_IO_MEM_REGION_SIZE); - edbg( "SEP Driver: release_mem_region \n"); + edbg("SEP Driver: release_mem_region \n"); - dbg("SEP Driver:<-------- Exit end\n"); + dbg("SEP Driver:<-------- Exit end\n"); } @@ -1018,69 +936,68 @@ static void __exit sep_exit(void) */ irqreturn_t sep_inthandler(int irq, void *dev_id) { - /* int error */ - irqreturn_t int_error; + /* int error */ + irqreturn_t int_error; - /* error */ - unsigned long error; + /* error */ + unsigned long error; - /* reg value */ - unsigned long reg_val; + /* reg value */ + unsigned long reg_val; - /* flow id */ - unsigned long flow_id; + /* flow id */ + unsigned long flow_id; - /* flow context */ - struct sep_flow_context_t *flow_context_ptr; + /* flow context */ + struct sep_flow_context_t *flow_context_ptr; /*----------------------------- CODE -----------------------------*/ - int_error = IRQ_HANDLED; - - /* read the IRR register to check if this is SEP interrupt */ - reg_val = sep_read_reg(sep_dev, HW_HOST_IRR_REG_ADDR); - edbg( "SEP Interrupt - reg is %08lx\n", - reg_val); + int_error = IRQ_HANDLED; - /* check if this is the flow interrupt */ - if (0/*reg_val & (0x1 << 11)*/) { - /* read GPRO to find out the which flow is done */ - flow_id = sep_read_reg(sep_dev, HW_HOST_IRR_REG_ADDR); + /* read the IRR register to check if this is SEP interrupt */ + reg_val = sep_read_reg(sep_dev, HW_HOST_IRR_REG_ADDR); + edbg("SEP Interrupt - reg is %08lx\n", reg_val); - /* find the contex of the flow */ - error = sep_find_flow_context(flow_id >> 28, &flow_context_ptr); - if (error) - goto end_function_with_error; + /* check if this is the flow interrupt */ + if (0 /*reg_val & (0x1 << 11) */ ) { + /* read GPRO to find out the which flow is done */ + flow_id = sep_read_reg(sep_dev, HW_HOST_IRR_REG_ADDR); - INIT_WORK(&flow_context_ptr->flow_wq, sep_flow_done_handler); + /* find the contex of the flow */ + error = sep_find_flow_context(flow_id >> 28, &flow_context_ptr); + if (error) + goto end_function_with_error; - /* queue the work */ - queue_work(sep_dev->flow_wq_ptr, &flow_context_ptr->flow_wq); + INIT_WORK(&flow_context_ptr->flow_wq, sep_flow_done_handler); - } else { - /* check if this is reply interrupt from SEP */ - if (reg_val & (0x1 << 13)) { - /* update the counter of reply messages */ - sep_dev->sep_to_host_reply_counter++; + /* queue the work */ + queue_work(sep_dev->flow_wq_ptr, &flow_context_ptr->flow_wq); - /* wake up the waiting process */ - wake_up(&g_sep_event); } else { - int_error = IRQ_NONE; - goto end_function; + /* check if this is reply interrupt from SEP */ + if (reg_val & (0x1 << 13)) { + /* update the counter of reply messages */ + sep_dev->sep_to_host_reply_counter++; + + /* wake up the waiting process */ + wake_up(&g_sep_event); + } else { + int_error = IRQ_NONE; + goto end_function; + } } - } -end_function_with_error: + end_function_with_error: - /* clear the interrupt */ - sep_write_reg(sep_dev, HW_HOST_ICR_REG_ADDR, reg_val); + /* clear the interrupt */ + sep_write_reg(sep_dev, HW_HOST_ICR_REG_ADDR, reg_val); -end_function: + end_function: - return int_error; + return int_error; } @@ -1088,169 +1005,132 @@ end_function: This function prepares only input DMA table for synhronic symmetric operations (HASH) */ -int sep_prepare_input_dma_table(unsigned long app_virt_addr, - unsigned long data_size, - unsigned long block_size, - unsigned long *lli_table_ptr, - unsigned long *num_entries_ptr, - unsigned long *table_data_size_ptr, - bool isKernelVirtualAddress) - +int sep_prepare_input_dma_table(unsigned long app_virt_addr, unsigned long data_size, unsigned long block_size, unsigned long *lli_table_ptr, unsigned long *num_entries_ptr, unsigned long *table_data_size_ptr, bool isKernelVirtualAddress) { - /* pointer to the info entry of the table - the last entry */ - struct sep_lli_entry_t *info_entry_ptr; + /* pointer to the info entry of the table - the last entry */ + struct sep_lli_entry_t *info_entry_ptr; - /* array of pointers ot page */ - struct sep_lli_entry_t *lli_array_ptr; + /* array of pointers ot page */ + struct sep_lli_entry_t *lli_array_ptr; - /* points to the first entry to be processed in the lli_in_array */ - unsigned long current_entry; + /* points to the first entry to be processed in the lli_in_array */ + unsigned long current_entry; - /* num entries in the virtual buffer */ - unsigned long sep_lli_entries; + /* num entries in the virtual buffer */ + unsigned long sep_lli_entries; - /* lli table pointer */ - struct sep_lli_entry_t *in_lli_table_ptr; + /* lli table pointer */ + struct sep_lli_entry_t *in_lli_table_ptr; - /* the total data in one table */ - unsigned long table_data_size; + /* the total data in one table */ + unsigned long table_data_size; - /* number of entries in lli table */ - unsigned long num_entries_in_table; + /* number of entries in lli table */ + unsigned long num_entries_in_table; - /* next table address */ - unsigned long lli_table_alloc_addr; + /* next table address */ + unsigned long lli_table_alloc_addr; - /* result */ - unsigned long result; + /* result */ + unsigned long result; /*------------------------ CODE --------------------------*/ - dbg("SEP Driver:--------> sep_prepare_input_dma_table start\n"); - - edbg( "SEP Driver:data_size is %lu\n", data_size); - edbg( "SEP Driver:block_size is %lu\n", block_size); + dbg("SEP Driver:--------> sep_prepare_input_dma_table start\n"); - /* initialize the pages pointers */ - sep_dev->in_page_array = 0; - sep_dev->in_num_pages = 0; + edbg("SEP Driver:data_size is %lu\n", data_size); + edbg("SEP Driver:block_size is %lu\n", block_size); - if (data_size == 0) { - /* special case - created 2 entries table with zero data */ - in_lli_table_ptr = (struct sep_lli_entry_t *)(sep_dev->shared_area_addr + - SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES); - in_lli_table_ptr->physical_address = sep_dev->shared_area_addr + - SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; - in_lli_table_ptr->block_size = 0; + /* initialize the pages pointers */ + sep_dev->in_page_array = 0; + sep_dev->in_num_pages = 0; - in_lli_table_ptr++; - in_lli_table_ptr->physical_address = 0xFFFFFFFF; - in_lli_table_ptr->block_size = 0; + if (data_size == 0) { + /* special case - created 2 entries table with zero data */ + in_lli_table_ptr = (struct sep_lli_entry_t *) (sep_dev->shared_area_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES); + in_lli_table_ptr->physical_address = sep_dev->shared_area_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; + in_lli_table_ptr->block_size = 0; - *lli_table_ptr = sep_dev->phys_shared_area_addr + - SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; - *num_entries_ptr = 2; - *table_data_size_ptr = 0; + in_lli_table_ptr++; + in_lli_table_ptr->physical_address = 0xFFFFFFFF; + in_lli_table_ptr->block_size = 0; - goto end_function; - } - - /* check if the pages are in Kernel Virtual Address layout */ - if (isKernelVirtualAddress == true) - /* lock the pages of the kernel buffer and translate them to pages */ - result = sep_lock_kernel_pages(app_virt_addr, - data_size, - &sep_dev->in_num_pages, - &lli_array_ptr, - &sep_dev->in_page_array); - else - /* lock the pages of the user buffer and translate them to pages */ - result = sep_lock_user_pages(app_virt_addr, - data_size, - &sep_dev->in_num_pages, - &lli_array_ptr, - &sep_dev->in_page_array); - - if (result) - return result; + *lli_table_ptr = sep_dev->phys_shared_area_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; + *num_entries_ptr = 2; + *table_data_size_ptr = 0; - edbg( - "SEP Driver:output sep_dev->in_num_pages is %lu\n", - sep_dev->in_num_pages); - - current_entry = 0; - info_entry_ptr = 0; - sep_lli_entries = sep_dev->in_num_pages; - - /* initiate to point after the message area */ - lli_table_alloc_addr = sep_dev->shared_area_addr + - SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; - - /* loop till all the entries in in array are not processed */ - while (current_entry < sep_lli_entries) { - /* set the new input and output tables */ - in_lli_table_ptr = (struct sep_lli_entry_t *)lli_table_alloc_addr; - - lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * - SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; - - /* calculate the maximum size of data for input table */ - table_data_size = sep_calculate_lli_table_max_size( - &lli_array_ptr[current_entry], - (sep_lli_entries - current_entry)); - - /* now calculate the table size so that it will be module block size */ - table_data_size = (table_data_size / block_size) * block_size; - - edbg( - "SEP Driver:output table_data_size is %lu\n", - table_data_size); - - /* construct input lli table */ - sep_build_lli_table(&lli_array_ptr[current_entry], - in_lli_table_ptr, - ¤t_entry, - &num_entries_in_table, - table_data_size); - - if (info_entry_ptr == 0) { - /* set the output parameters to physical addresses */ - *lli_table_ptr = sep_shared_area_virt_to_phys( - (unsigned long)in_lli_table_ptr); - *num_entries_ptr = num_entries_in_table; - *table_data_size_ptr = table_data_size; - - edbg( - "SEP Driver:output lli_table_in_ptr is %08lx\n", - *lli_table_ptr); - } else { - /* update the info entry of the previous in table */ - info_entry_ptr->physical_address = sep_shared_area_virt_to_phys( - (unsigned long)in_lli_table_ptr); - info_entry_ptr->block_size = ((num_entries_in_table) << 24) | - (table_data_size); + goto end_function; } - /* save the pointer to the info entry of the current tables */ - info_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1; - } + /* check if the pages are in Kernel Virtual Address layout */ + if (isKernelVirtualAddress == true) + /* lock the pages of the kernel buffer and translate them to pages */ + result = sep_lock_kernel_pages(app_virt_addr, data_size, &sep_dev->in_num_pages, &lli_array_ptr, &sep_dev->in_page_array); + else + /* lock the pages of the user buffer and translate them to pages */ + result = sep_lock_user_pages(app_virt_addr, data_size, &sep_dev->in_num_pages, &lli_array_ptr, &sep_dev->in_page_array); + + if (result) + return result; + + edbg("SEP Driver:output sep_dev->in_num_pages is %lu\n", sep_dev->in_num_pages); + + current_entry = 0; + info_entry_ptr = 0; + sep_lli_entries = sep_dev->in_num_pages; - /* print input tables */ - sep_debug_print_lli_tables((struct sep_lli_entry_t *) - sep_shared_area_phys_to_virt(*lli_table_ptr), - *num_entries_ptr, - *table_data_size_ptr); + /* initiate to point after the message area */ + lli_table_alloc_addr = sep_dev->shared_area_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; - /* the array of the pages */ - kfree(lli_array_ptr); + /* loop till all the entries in in array are not processed */ + while (current_entry < sep_lli_entries) { + /* set the new input and output tables */ + in_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr; -end_function: + lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; - dbg("SEP Driver:<-------- sep_prepare_input_dma_table end\n"); + /* calculate the maximum size of data for input table */ + table_data_size = sep_calculate_lli_table_max_size(&lli_array_ptr[current_entry], (sep_lli_entries - current_entry)); - return 0; + /* now calculate the table size so that it will be module block size */ + table_data_size = (table_data_size / block_size) * block_size; + + edbg("SEP Driver:output table_data_size is %lu\n", table_data_size); + + /* construct input lli table */ + sep_build_lli_table(&lli_array_ptr[current_entry], in_lli_table_ptr, ¤t_entry, &num_entries_in_table, table_data_size); + + if (info_entry_ptr == 0) { + /* set the output parameters to physical addresses */ + *lli_table_ptr = sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr); + *num_entries_ptr = num_entries_in_table; + *table_data_size_ptr = table_data_size; + + edbg("SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_ptr); + } else { + /* update the info entry of the previous in table */ + info_entry_ptr->physical_address = sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr); + info_entry_ptr->block_size = ((num_entries_in_table) << 24) | (table_data_size); + } + + /* save the pointer to the info entry of the current tables */ + info_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1; + } + + /* print input tables */ + sep_debug_print_lli_tables((struct sep_lli_entry_t *) + sep_shared_area_phys_to_virt(*lli_table_ptr), *num_entries_ptr, *table_data_size_ptr); + + /* the array of the pages */ + kfree(lli_array_ptr); + + end_function: + + dbg("SEP Driver:<-------- sep_prepare_input_dma_table end\n"); + + return 0; } @@ -1259,141 +1139,98 @@ end_function: symmetric operations (AES, DES). It also checks that each table is of the modular block size */ -int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr, - unsigned long app_virt_out_addr, - unsigned long data_size, - unsigned long block_size, - unsigned long *lli_table_in_ptr, - unsigned long *lli_table_out_ptr, - unsigned long *in_num_entries_ptr, - unsigned long *out_num_entries_ptr, - unsigned long *table_data_size_ptr, - bool isKernelVirtualAddress) - +int sep_prepare_input_output_dma_table(unsigned long app_virt_in_addr, + unsigned long app_virt_out_addr, + unsigned long data_size, + unsigned long block_size, + unsigned long *lli_table_in_ptr, unsigned long *lli_table_out_ptr, unsigned long *in_num_entries_ptr, unsigned long *out_num_entries_ptr, unsigned long *table_data_size_ptr, bool isKernelVirtualAddress) { - /* array of pointers of page */ - struct sep_lli_entry_t *lli_in_array; + /* array of pointers of page */ + struct sep_lli_entry_t *lli_in_array; - /* array of pointers of page */ - struct sep_lli_entry_t *lli_out_array; + /* array of pointers of page */ + struct sep_lli_entry_t *lli_out_array; - /* result */ - int result; + /* result */ + int result; /*------------------------ CODE --------------------------*/ - dbg("SEP Driver:--------> sep_prepare_input_output_dma_table start\n"); + dbg("SEP Driver:--------> sep_prepare_input_output_dma_table start\n"); - result = 0; + result = 0; - /* initialize the pages pointers */ - sep_dev->in_page_array = 0; - sep_dev->out_page_array = 0; + /* initialize the pages pointers */ + sep_dev->in_page_array = 0; + sep_dev->out_page_array = 0; - /* check if the pages are in Kernel Virtual Address layout */ - if (isKernelVirtualAddress == true) { - /* lock the pages of the kernel buffer and translate them to pages */ - result = sep_lock_kernel_pages(app_virt_in_addr, - data_size, - &sep_dev->in_num_pages, - &lli_in_array, - &sep_dev->in_page_array); - if (result) { - edbg( - "SEP Driver: sep_lock_kernel_pages for input virtual buffer failed\n"); - goto end_function; - } - } else { - /* lock the pages of the user buffer and translate them to pages */ - result = sep_lock_user_pages(app_virt_in_addr, - data_size, - &sep_dev->in_num_pages, - &lli_in_array, - &sep_dev->in_page_array); - if (result) { - edbg( - "SEP Driver: sep_lock_user_pages for input virtual buffer failed\n"); - goto end_function; - } - } - - if (isKernelVirtualAddress == true) { - result = sep_lock_kernel_pages(app_virt_out_addr, - data_size, - &sep_dev->out_num_pages, - &lli_out_array, - &sep_dev->out_page_array); - if (result) { - edbg( - "SEP Driver: sep_lock_kernel_pages for output virtual buffer failed\n"); - goto end_function_with_error1; + /* check if the pages are in Kernel Virtual Address layout */ + if (isKernelVirtualAddress == true) { + /* lock the pages of the kernel buffer and translate them to pages */ + result = sep_lock_kernel_pages(app_virt_in_addr, data_size, &sep_dev->in_num_pages, &lli_in_array, &sep_dev->in_page_array); + if (result) { + edbg("SEP Driver: sep_lock_kernel_pages for input virtual buffer failed\n"); + goto end_function; + } + } else { + /* lock the pages of the user buffer and translate them to pages */ + result = sep_lock_user_pages(app_virt_in_addr, data_size, &sep_dev->in_num_pages, &lli_in_array, &sep_dev->in_page_array); + if (result) { + edbg("SEP Driver: sep_lock_user_pages for input virtual buffer failed\n"); + goto end_function; + } } - } else { - result = sep_lock_user_pages(app_virt_out_addr, - data_size, - &sep_dev->out_num_pages, - &lli_out_array, - &sep_dev->out_page_array); - if (result) { - edbg( - "SEP Driver: sep_lock_user_pages for output virtual buffer failed\n"); - goto end_function_with_error1; + + if (isKernelVirtualAddress == true) { + result = sep_lock_kernel_pages(app_virt_out_addr, data_size, &sep_dev->out_num_pages, &lli_out_array, &sep_dev->out_page_array); + if (result) { + edbg("SEP Driver: sep_lock_kernel_pages for output virtual buffer failed\n"); + goto end_function_with_error1; + } + } else { + result = sep_lock_user_pages(app_virt_out_addr, data_size, &sep_dev->out_num_pages, &lli_out_array, &sep_dev->out_page_array); + if (result) { + edbg("SEP Driver: sep_lock_user_pages for output virtual buffer failed\n"); + goto end_function_with_error1; + } } - } - edbg( - "sep_dev->in_num_pages is %lu\n", sep_dev->in_num_pages); - edbg( - "sep_dev->out_num_pages is %lu\n", sep_dev->out_num_pages); - edbg( - "SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n", - SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP); + edbg("sep_dev->in_num_pages is %lu\n", sep_dev->in_num_pages); + edbg("sep_dev->out_num_pages is %lu\n", sep_dev->out_num_pages); + edbg("SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n", SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP); - /* call the fucntion that creates table from the lli arrays */ - result = sep_construct_dma_tables_from_lli(lli_in_array, - sep_dev->in_num_pages, - lli_out_array, - sep_dev->out_num_pages, - block_size, - lli_table_in_ptr, - lli_table_out_ptr, - in_num_entries_ptr, - out_num_entries_ptr, - table_data_size_ptr); - if (result) { - edbg( - "SEP Driver: sep_construct_dma_tables_from_lli failed\n"); - goto end_function_with_error2; - } + /* call the fucntion that creates table from the lli arrays */ + result = sep_construct_dma_tables_from_lli(lli_in_array, sep_dev->in_num_pages, lli_out_array, sep_dev->out_num_pages, block_size, lli_table_in_ptr, lli_table_out_ptr, in_num_entries_ptr, out_num_entries_ptr, table_data_size_ptr); + if (result) { + edbg("SEP Driver: sep_construct_dma_tables_from_lli failed\n"); + goto end_function_with_error2; + } - /* fall through - free the lli entry arrays */ + /* fall through - free the lli entry arrays */ - dbg("in_num_entries_ptr is %08lx\n", - *in_num_entries_ptr); - dbg("out_num_entries_ptr is %08lx\n", - *out_num_entries_ptr); - dbg("table_data_size_ptr is %08lx\n", - *table_data_size_ptr); + dbg("in_num_entries_ptr is %08lx\n", *in_num_entries_ptr); + dbg("out_num_entries_ptr is %08lx\n", *out_num_entries_ptr); + dbg("table_data_size_ptr is %08lx\n", *table_data_size_ptr); -end_function_with_error2: + end_function_with_error2: - kfree(lli_out_array); + kfree(lli_out_array); -end_function_with_error1: + end_function_with_error1: - kfree(lli_in_array); + kfree(lli_in_array); -end_function: + end_function: - dbg("SEP Driver:<-------- sep_prepare_input_output_dma_table end result = %d\n", (int)result); + dbg("SEP Driver:<-------- sep_prepare_input_output_dma_table end result = %d\n", (int) result); - return result; + return result; } @@ -1402,188 +1239,144 @@ end_function: This function creates the input and output dma tables for symmetric operations (AES/DES) according to the block size from LLI arays */ -int sep_construct_dma_tables_from_lli(struct sep_lli_entry_t *lli_in_array, - unsigned long sep_in_lli_entries, - struct sep_lli_entry_t *lli_out_array, - unsigned long sep_out_lli_entries, - unsigned long block_size, - unsigned long *lli_table_in_ptr, - unsigned long *lli_table_out_ptr, - unsigned long *in_num_entries_ptr, - unsigned long *out_num_entries_ptr, - unsigned long *table_data_size_ptr) +int sep_construct_dma_tables_from_lli(struct sep_lli_entry_t *lli_in_array, + unsigned long sep_in_lli_entries, + struct sep_lli_entry_t *lli_out_array, + unsigned long sep_out_lli_entries, + unsigned long block_size, unsigned long *lli_table_in_ptr, unsigned long *lli_table_out_ptr, unsigned long *in_num_entries_ptr, unsigned long *out_num_entries_ptr, unsigned long *table_data_size_ptr) { - /* points to the area where next lli table can be allocated */ - unsigned long lli_table_alloc_addr; + /* points to the area where next lli table can be allocated */ + unsigned long lli_table_alloc_addr; - /* input lli table */ - struct sep_lli_entry_t *in_lli_table_ptr; + /* input lli table */ + struct sep_lli_entry_t *in_lli_table_ptr; - /* output lli table */ - struct sep_lli_entry_t *out_lli_table_ptr; + /* output lli table */ + struct sep_lli_entry_t *out_lli_table_ptr; - /* pointer to the info entry of the table - the last entry */ - struct sep_lli_entry_t *info_in_entry_ptr; + /* pointer to the info entry of the table - the last entry */ + struct sep_lli_entry_t *info_in_entry_ptr; - /* pointer to the info entry of the table - the last entry */ - struct sep_lli_entry_t *info_out_entry_ptr; + /* pointer to the info entry of the table - the last entry */ + struct sep_lli_entry_t *info_out_entry_ptr; - /* points to the first entry to be processed in the lli_in_array */ - unsigned long current_in_entry; + /* points to the first entry to be processed in the lli_in_array */ + unsigned long current_in_entry; - /* points to the first entry to be processed in the lli_out_array */ - unsigned long current_out_entry; + /* points to the first entry to be processed in the lli_out_array */ + unsigned long current_out_entry; - /* max size of the input table */ - unsigned long in_table_data_size; + /* max size of the input table */ + unsigned long in_table_data_size; - /* max size of the output table */ - unsigned long out_table_data_size; + /* max size of the output table */ + unsigned long out_table_data_size; - /* flag te signifies if this is the first tables build from the arrays */ - unsigned long first_table_flag; + /* flag te signifies if this is the first tables build from the arrays */ + unsigned long first_table_flag; - /* the data size that should be in table */ - unsigned long table_data_size; + /* the data size that should be in table */ + unsigned long table_data_size; - /* number of etnries in the input table */ - unsigned long num_entries_in_table; + /* number of etnries in the input table */ + unsigned long num_entries_in_table; - /* number of etnries in the output table */ - unsigned long num_entries_out_table; + /* number of etnries in the output table */ + unsigned long num_entries_out_table; /*--------------------- CODE ------------------------*/ - dbg("SEP Driver:--------> sep_construct_dma_tables_from_lli start\n"); - - /* initiate to pint after the message area */ - lli_table_alloc_addr = sep_dev->shared_area_addr + - SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; - - current_in_entry = 0; - current_out_entry = 0; - first_table_flag = 1; - info_in_entry_ptr = 0; - info_out_entry_ptr = 0; - - /* loop till all the entries in in array are not processed */ - while (current_in_entry < sep_in_lli_entries) { - /* set the new input and output tables */ - in_lli_table_ptr = (struct sep_lli_entry_t *)lli_table_alloc_addr; - - lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * - SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; - - /* set the first output tables */ - out_lli_table_ptr = (struct sep_lli_entry_t *)lli_table_alloc_addr; - - lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * - SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; - - /* calculate the maximum size of data for input table */ - in_table_data_size = - sep_calculate_lli_table_max_size( - &lli_in_array[current_in_entry], - (sep_in_lli_entries - current_in_entry)); - - /* calculate the maximum size of data for output table */ - out_table_data_size = - sep_calculate_lli_table_max_size( - &lli_out_array[current_out_entry], - (sep_out_lli_entries - current_out_entry)); - - edbg( - "SEP Driver:in_table_data_size is %lu\n", in_table_data_size); - edbg( - "SEP Driver:out_table_data_size is %lu\n", out_table_data_size); - - /* check where the data is smallest */ - table_data_size = in_table_data_size; - if (table_data_size > out_table_data_size) - table_data_size = out_table_data_size; - - /* now calculate the table size so that it will be module block size */ - table_data_size = (table_data_size / block_size) * block_size; - - dbg("SEP Driver:table_data_size is %lu\n", table_data_size); - - /* construct input lli table */ - sep_build_lli_table(&lli_in_array[current_in_entry], - in_lli_table_ptr, - ¤t_in_entry, - &num_entries_in_table, - table_data_size); - - /* construct output lli table */ - sep_build_lli_table(&lli_out_array[current_out_entry], - out_lli_table_ptr, - ¤t_out_entry, - &num_entries_out_table, - table_data_size); - - /* if info entry is null - this is the first table built */ - if (info_in_entry_ptr == 0) { - /* set the output parameters to physical addresses */ - *lli_table_in_ptr = - sep_shared_area_virt_to_phys((unsigned long)in_lli_table_ptr); - *in_num_entries_ptr = num_entries_in_table; - *lli_table_out_ptr = - sep_shared_area_virt_to_phys((unsigned long)out_lli_table_ptr); - *out_num_entries_ptr = num_entries_out_table; - *table_data_size_ptr = table_data_size; - - edbg( - "SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_in_ptr); - edbg( - "SEP Driver:output lli_table_out_ptr is %08lx\n", *lli_table_out_ptr); - } else { - /* update the info entry of the previous in table */ - info_in_entry_ptr->physical_address = - sep_shared_area_virt_to_phys((unsigned long)in_lli_table_ptr); - info_in_entry_ptr->block_size = - ((num_entries_in_table) << 24) | (table_data_size); - - /* update the info entry of the previous in table */ - info_out_entry_ptr->physical_address = - sep_shared_area_virt_to_phys((unsigned long)out_lli_table_ptr); - info_out_entry_ptr->block_size = - ((num_entries_out_table) << 24) | (table_data_size); + dbg("SEP Driver:--------> sep_construct_dma_tables_from_lli start\n"); + + /* initiate to pint after the message area */ + lli_table_alloc_addr = sep_dev->shared_area_addr + SEP_DRIVER_SYNCHRONIC_DMA_TABLES_AREA_OFFSET_IN_BYTES; + + current_in_entry = 0; + current_out_entry = 0; + first_table_flag = 1; + info_in_entry_ptr = 0; + info_out_entry_ptr = 0; + + /* loop till all the entries in in array are not processed */ + while (current_in_entry < sep_in_lli_entries) { + /* set the new input and output tables */ + in_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr; + + lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; + + /* set the first output tables */ + out_lli_table_ptr = (struct sep_lli_entry_t *) lli_table_alloc_addr; + + lli_table_alloc_addr += sizeof(struct sep_lli_entry_t) * SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; + + /* calculate the maximum size of data for input table */ + in_table_data_size = sep_calculate_lli_table_max_size(&lli_in_array[current_in_entry], (sep_in_lli_entries - current_in_entry)); + + /* calculate the maximum size of data for output table */ + out_table_data_size = sep_calculate_lli_table_max_size(&lli_out_array[current_out_entry], (sep_out_lli_entries - current_out_entry)); + + edbg("SEP Driver:in_table_data_size is %lu\n", in_table_data_size); + edbg("SEP Driver:out_table_data_size is %lu\n", out_table_data_size); + + /* check where the data is smallest */ + table_data_size = in_table_data_size; + if (table_data_size > out_table_data_size) + table_data_size = out_table_data_size; + + /* now calculate the table size so that it will be module block size */ + table_data_size = (table_data_size / block_size) * block_size; + + dbg("SEP Driver:table_data_size is %lu\n", table_data_size); + + /* construct input lli table */ + sep_build_lli_table(&lli_in_array[current_in_entry], in_lli_table_ptr, ¤t_in_entry, &num_entries_in_table, table_data_size); + + /* construct output lli table */ + sep_build_lli_table(&lli_out_array[current_out_entry], out_lli_table_ptr, ¤t_out_entry, &num_entries_out_table, table_data_size); + + /* if info entry is null - this is the first table built */ + if (info_in_entry_ptr == 0) { + /* set the output parameters to physical addresses */ + *lli_table_in_ptr = sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr); + *in_num_entries_ptr = num_entries_in_table; + *lli_table_out_ptr = sep_shared_area_virt_to_phys((unsigned long) out_lli_table_ptr); + *out_num_entries_ptr = num_entries_out_table; + *table_data_size_ptr = table_data_size; + + edbg("SEP Driver:output lli_table_in_ptr is %08lx\n", *lli_table_in_ptr); + edbg("SEP Driver:output lli_table_out_ptr is %08lx\n", *lli_table_out_ptr); + } else { + /* update the info entry of the previous in table */ + info_in_entry_ptr->physical_address = sep_shared_area_virt_to_phys((unsigned long) in_lli_table_ptr); + info_in_entry_ptr->block_size = ((num_entries_in_table) << 24) | (table_data_size); + + /* update the info entry of the previous in table */ + info_out_entry_ptr->physical_address = sep_shared_area_virt_to_phys((unsigned long) out_lli_table_ptr); + info_out_entry_ptr->block_size = ((num_entries_out_table) << 24) | (table_data_size); + } + + /* save the pointer to the info entry of the current tables */ + info_in_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1; + info_out_entry_ptr = out_lli_table_ptr + num_entries_out_table - 1; + + edbg("SEP Driver:output num_entries_out_table is %lu\n", (unsigned long) num_entries_out_table); + edbg("SEP Driver:output info_in_entry_ptr is %lu\n", (unsigned long) info_in_entry_ptr); + edbg("SEP Driver:output info_out_entry_ptr is %lu\n", (unsigned long) info_out_entry_ptr); } - /* save the pointer to the info entry of the current tables */ - info_in_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1; - info_out_entry_ptr = out_lli_table_ptr + num_entries_out_table - 1; - - edbg( - "SEP Driver:output num_entries_out_table is %lu\n", - (unsigned long)num_entries_out_table); - edbg( - "SEP Driver:output info_in_entry_ptr is %lu\n", - (unsigned long)info_in_entry_ptr); - edbg( - "SEP Driver:output info_out_entry_ptr is %lu\n", - (unsigned long)info_out_entry_ptr); - } - - /* print input tables */ - sep_debug_print_lli_tables( - (struct sep_lli_entry_t *) - sep_shared_area_phys_to_virt(*lli_table_in_ptr), - *in_num_entries_ptr, - *table_data_size_ptr); - - /* print output tables */ - sep_debug_print_lli_tables( - (struct sep_lli_entry_t *) - sep_shared_area_phys_to_virt(*lli_table_out_ptr), - *out_num_entries_ptr, - *table_data_size_ptr); - - dbg("SEP Driver:<-------- sep_construct_dma_tables_from_lli end\n"); - - return 0; + /* print input tables */ + sep_debug_print_lli_tables((struct sep_lli_entry_t *) + sep_shared_area_phys_to_virt(*lli_table_in_ptr), *in_num_entries_ptr, *table_data_size_ptr); + + /* print output tables */ + sep_debug_print_lli_tables((struct sep_lli_entry_t *) + sep_shared_area_phys_to_virt(*lli_table_out_ptr), *out_num_entries_ptr, *table_data_size_ptr); + + dbg("SEP Driver:<-------- sep_construct_dma_tables_from_lli end\n"); + + return 0; } /* @@ -1591,201 +1384,156 @@ int sep_construct_dma_tables_from_lli(struct sep_lli_entry_t *lli_in_array, table from this array the condition is that either the table is full (all etnries are entered), or there are no more entries in the lli array */ -unsigned long sep_calculate_lli_table_max_size( - struct sep_lli_entry_t *lli_in_array_ptr, - unsigned long num_array_entries) +unsigned long sep_calculate_lli_table_max_size(struct sep_lli_entry_t *lli_in_array_ptr, unsigned long num_array_entries) { - /* table data size */ - unsigned long table_data_size; + /* table data size */ + unsigned long table_data_size; - /* counter */ - unsigned long counter; + /* counter */ + unsigned long counter; /*--------------------- CODE ----------------------*/ - table_data_size = 0; + table_data_size = 0; - /* calculate the data in the out lli table if till we fill the whole - table or till the data has ended */ - for (counter = 0; - (counter < (SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP - 1)) && - (counter < num_array_entries); counter++) - table_data_size += lli_in_array_ptr[counter].block_size; + /* calculate the data in the out lli table if till we fill the whole + table or till the data has ended */ + for (counter = 0; (counter < (SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP - 1)) && (counter < num_array_entries); counter++) + table_data_size += lli_in_array_ptr[counter].block_size; - return table_data_size; + return table_data_size; } /* this functions builds ont lli table from the lli_array according to the given size of data */ -static void sep_build_lli_table(struct sep_lli_entry_t *lli_array_ptr, - struct sep_lli_entry_t *lli_table_ptr, - unsigned long *num_processed_entries_ptr, - unsigned long *num_table_entries_ptr, - unsigned long table_data_size) +static void sep_build_lli_table(struct sep_lli_entry_t *lli_array_ptr, struct sep_lli_entry_t *lli_table_ptr, unsigned long *num_processed_entries_ptr, unsigned long *num_table_entries_ptr, unsigned long table_data_size) { - /* current table data size */ - unsigned long curr_table_data_size; + /* current table data size */ + unsigned long curr_table_data_size; - /* counter of lli array entry */ - unsigned long array_counter; + /* counter of lli array entry */ + unsigned long array_counter; /*----------------------- CODE ---------------------------*/ - dbg("SEP Driver:--------> sep_build_lli_table start\n"); - - /* init currrent table data size and lli array entry counter */ - curr_table_data_size = 0; - array_counter = 0; - *num_table_entries_ptr = 1; - - edbg( - "SEP Driver:table_data_size is %lu\n", - table_data_size); - - /* fill the table till table size reaches the needed amount */ - while (curr_table_data_size < table_data_size) { - /* update the number of entries in table */ - (*num_table_entries_ptr)++; - - lli_table_ptr->physical_address = - lli_array_ptr[array_counter].physical_address; - lli_table_ptr->block_size = lli_array_ptr[array_counter].block_size; - curr_table_data_size += lli_table_ptr->block_size; - - edbg( - "SEP Driver:lli_table_ptr is %08lx\n", - (unsigned long)lli_table_ptr); - edbg( - "SEP Driver:lli_table_ptr->physical_address is %08lx\n", - lli_table_ptr->physical_address); - edbg( - "SEP Driver:lli_table_ptr->block_size is %lu\n", - lli_table_ptr->block_size); - - /* check for overflow of the table data */ - if (curr_table_data_size > table_data_size) { - edbg( - "SEP Driver:curr_table_data_size > table_data_size\n"); - - /* update the size of block in the table */ - lli_table_ptr->block_size -= (curr_table_data_size - table_data_size); - - /* update the physical address in the lli array */ - lli_array_ptr[array_counter].physical_address += - lli_table_ptr->block_size; - - /* update the block size left in the lli array */ - lli_array_ptr[array_counter].block_size = - (curr_table_data_size - table_data_size); - } else - /* advance to the next entry in the lli_array */ - array_counter++; - - edbg( - "SEP Driver:lli_table_ptr->physical_address is %08lx\n", - lli_table_ptr->physical_address); - edbg( - "SEP Driver:lli_table_ptr->block_size is %lu\n", - lli_table_ptr->block_size); - - /* move to the next entry in table */ - lli_table_ptr++; - } - - /* set the info entry to default */ - lli_table_ptr->physical_address = 0xffffffff; - lli_table_ptr->block_size = 0; - - edbg( - "SEP Driver:lli_table_ptr is %08lx\n", - (unsigned long)lli_table_ptr); - edbg( - "SEP Driver:lli_table_ptr->physical_address is %08lx\n", - lli_table_ptr->physical_address); - edbg( - "SEP Driver:lli_table_ptr->block_size is %lu\n", - lli_table_ptr->block_size); - - - /* set the output parameter */ - *num_processed_entries_ptr += array_counter; - - edbg( - "SEP Driver:*num_processed_entries_ptr is %lu\n", - *num_processed_entries_ptr); - - - dbg("SEP Driver:<-------- sep_build_lli_table end\n"); - - return; + dbg("SEP Driver:--------> sep_build_lli_table start\n"); + + /* init currrent table data size and lli array entry counter */ + curr_table_data_size = 0; + array_counter = 0; + *num_table_entries_ptr = 1; + + edbg("SEP Driver:table_data_size is %lu\n", table_data_size); + + /* fill the table till table size reaches the needed amount */ + while (curr_table_data_size < table_data_size) { + /* update the number of entries in table */ + (*num_table_entries_ptr)++; + + lli_table_ptr->physical_address = lli_array_ptr[array_counter].physical_address; + lli_table_ptr->block_size = lli_array_ptr[array_counter].block_size; + curr_table_data_size += lli_table_ptr->block_size; + + edbg("SEP Driver:lli_table_ptr is %08lx\n", (unsigned long) lli_table_ptr); + edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address); + edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size); + + /* check for overflow of the table data */ + if (curr_table_data_size > table_data_size) { + edbg("SEP Driver:curr_table_data_size > table_data_size\n"); + + /* update the size of block in the table */ + lli_table_ptr->block_size -= (curr_table_data_size - table_data_size); + + /* update the physical address in the lli array */ + lli_array_ptr[array_counter].physical_address += lli_table_ptr->block_size; + + /* update the block size left in the lli array */ + lli_array_ptr[array_counter].block_size = (curr_table_data_size - table_data_size); + } else + /* advance to the next entry in the lli_array */ + array_counter++; + + edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address); + edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size); + + /* move to the next entry in table */ + lli_table_ptr++; + } + + /* set the info entry to default */ + lli_table_ptr->physical_address = 0xffffffff; + lli_table_ptr->block_size = 0; + + edbg("SEP Driver:lli_table_ptr is %08lx\n", (unsigned long) lli_table_ptr); + edbg("SEP Driver:lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address); + edbg("SEP Driver:lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size); + + + /* set the output parameter */ + *num_processed_entries_ptr += array_counter; + + edbg("SEP Driver:*num_processed_entries_ptr is %lu\n", *num_processed_entries_ptr); + + + dbg("SEP Driver:<-------- sep_build_lli_table end\n"); + + return; } /* this function goes over the list of the print created tables and prints all the data */ -static void sep_debug_print_lli_tables(struct sep_lli_entry_t *lli_table_ptr, - unsigned long num_table_entries, - unsigned long table_data_size) +static void sep_debug_print_lli_tables(struct sep_lli_entry_t *lli_table_ptr, unsigned long num_table_entries, unsigned long table_data_size) { - unsigned long table_count; + unsigned long table_count; - unsigned long entries_count; + unsigned long entries_count; /*----------------------------- CODE -------------------------------*/ - dbg("SEP Driver:--------> sep_debug_print_lli_tables start\n"); - - table_count = 1; - while ((unsigned long)lli_table_ptr != 0xffffffff) { - edbg("SEP Driver: lli table %08lx, table_data_size is %lu\n", - table_count, table_data_size); - edbg("SEP Driver: num_table_entries is %lu\n", num_table_entries); - - /* print entries of the table (without info entry) */ - for (entries_count = 0; - entries_count < num_table_entries; - entries_count++, lli_table_ptr++) { - edbg("SEP Driver:lli_table_ptr address is %08lx\n", - (unsigned long)lli_table_ptr); - edbg("SEP Driver:phys address is %08lx block size is %lu\n", - lli_table_ptr->physical_address, lli_table_ptr->block_size); - } + dbg("SEP Driver:--------> sep_debug_print_lli_tables start\n"); - /* point to the info entry */ - lli_table_ptr--; + table_count = 1; + while ((unsigned long) lli_table_ptr != 0xffffffff) { + edbg("SEP Driver: lli table %08lx, table_data_size is %lu\n", table_count, table_data_size); + edbg("SEP Driver: num_table_entries is %lu\n", num_table_entries); - edbg( - "SEP Driver:phys lli_table_ptr->block_size is %lu\n", - lli_table_ptr->block_size); - edbg( - "SEP Driver:phys lli_table_ptr->physical_address is %08lx\n", - lli_table_ptr->physical_address); + /* print entries of the table (without info entry) */ + for (entries_count = 0; entries_count < num_table_entries; entries_count++, lli_table_ptr++) { + edbg("SEP Driver:lli_table_ptr address is %08lx\n", (unsigned long) lli_table_ptr); + edbg("SEP Driver:phys address is %08lx block size is %lu\n", lli_table_ptr->physical_address, lli_table_ptr->block_size); + } + /* point to the info entry */ + lli_table_ptr--; - table_data_size = lli_table_ptr->block_size & 0xffffff; - num_table_entries = (lli_table_ptr->block_size >> 24) & 0xff; - lli_table_ptr = (struct sep_lli_entry_t *) - (lli_table_ptr->physical_address); + edbg("SEP Driver:phys lli_table_ptr->block_size is %lu\n", lli_table_ptr->block_size); + edbg("SEP Driver:phys lli_table_ptr->physical_address is %08lx\n", lli_table_ptr->physical_address); - edbg("SEP Driver:phys table_data_size is %lu num_table_entries is %lu lli_table_ptr is%lu\n", - table_data_size, num_table_entries, (unsigned long)lli_table_ptr); - if ((unsigned long)lli_table_ptr != 0xffffffff) - lli_table_ptr = (struct sep_lli_entry_t *)sep_shared_area_phys_to_virt( - (unsigned long)lli_table_ptr); + table_data_size = lli_table_ptr->block_size & 0xffffff; + num_table_entries = (lli_table_ptr->block_size >> 24) & 0xff; + lli_table_ptr = (struct sep_lli_entry_t *) + (lli_table_ptr->physical_address); - table_count++; - } + edbg("SEP Driver:phys table_data_size is %lu num_table_entries is %lu lli_table_ptr is%lu\n", table_data_size, num_table_entries, (unsigned long) lli_table_ptr); - dbg("SEP Driver:<-------- sep_debug_print_lli_tables end\n"); + if ((unsigned long) lli_table_ptr != 0xffffffff) + lli_table_ptr = (struct sep_lli_entry_t *) sep_shared_area_phys_to_virt((unsigned long) lli_table_ptr); + + table_count++; + } + + dbg("SEP Driver:<-------- sep_debug_print_lli_tables end\n"); } @@ -1794,184 +1542,150 @@ static void sep_debug_print_lli_tables(struct sep_lli_entry_t *lli_table_ptr, and construct a basic lli array, where each entry holds the physical page address and the size that application data holds in this physical pages */ -int sep_lock_user_pages(unsigned long app_virt_addr, - unsigned long data_size, - unsigned long *num_pages_ptr, - struct sep_lli_entry_t **lli_array_ptr, - struct page ***page_array_ptr) - +int sep_lock_user_pages(unsigned long app_virt_addr, unsigned long data_size, unsigned long *num_pages_ptr, struct sep_lli_entry_t **lli_array_ptr, struct page ***page_array_ptr) { - /* error */ - int error; + /* error */ + int error; - /* the the page of the end address of the user space buffer */ - unsigned long end_page; + /* the the page of the end address of the user space buffer */ + unsigned long end_page; - /* the page of the start address of the user space buffer */ - unsigned long start_page; + /* the page of the start address of the user space buffer */ + unsigned long start_page; - /* the range in pages */ - unsigned long num_pages; + /* the range in pages */ + unsigned long num_pages; - /* array of pointers ot page */ - struct page **page_array; + /* array of pointers ot page */ + struct page **page_array; - /* array of lli */ - struct sep_lli_entry_t *lli_array; + /* array of lli */ + struct sep_lli_entry_t *lli_array; - /* count */ - unsigned long count; + /* count */ + unsigned long count; - /* result */ - int result; + /* result */ + int result; /*------------------------ CODE --------------------------*/ - dbg("SEP Driver:--------> sep_lock_user_pages start\n"); - - error = 0; - - /* set start and end pages and num pages */ - end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT; - start_page = app_virt_addr >> PAGE_SHIFT; - num_pages = end_page - start_page + 1; - - edbg( - "SEP Driver: app_virt_addr is %08lx\n", - app_virt_addr); - edbg( - "SEP Driver: data_size is %lu\n", - data_size); - edbg( - "SEP Driver: start_page is %lu\n", - start_page); - edbg( - "SEP Driver: end_page is %lu\n", - end_page); - edbg( - "SEP Driver: num_pages is %lu\n", - num_pages); - - /* allocate array of pages structure pointers */ - page_array = kmalloc(sizeof(struct page *) * num_pages, GFP_ATOMIC); - if (!page_array) { - edbg( - "SEP Driver: kmalloc for page_array failed\n"); - - error = -ENOMEM; - goto end_function; - } - - lli_array = kmalloc(sizeof(struct sep_lli_entry_t) * num_pages, GFP_ATOMIC); - if (!lli_array) { - edbg( - "SEP Driver: kmalloc for lli_array failed\n"); - - error = -ENOMEM; - goto end_function_with_error1; - } - - /* convert the application virtual address into a set of physical */ - down_read(¤t->mm->mmap_sem); - result = get_user_pages(current, current->mm, app_virt_addr, num_pages, 1, 0, - page_array, - 0); - up_read(¤t->mm->mmap_sem); - - /* check the number of pages locked - if not all then exit with error */ - if (result != num_pages) { - dbg("SEP Driver: not all pages locked by get_user_pages\n"); - - error = -ENOMEM; - goto end_function_with_error2; - } - - /* flush the cache */ - for (count = 0; count < num_pages; count++) - flush_dcache_page(page_array[count]); - - /* set the start address of the first page - app data may start not at - the beginning of the page */ - lli_array[0].physical_address = ( - (unsigned long)page_to_phys(page_array[0])) + - (app_virt_addr & (~PAGE_MASK)) ; - - /* check that not all the data is in the first page only */ - if ((PAGE_SIZE - (app_virt_addr & (~PAGE_MASK))) >= data_size) - lli_array[0].block_size = data_size; - else - lli_array[0].block_size = PAGE_SIZE - (app_virt_addr & (~PAGE_MASK)); - - /* debug print */ - dbg("lli_array[0].physical_address is %08lx, lli_array[0].block_size is %lu\n", - lli_array[0].physical_address, - lli_array[0].block_size); - - /* go from the second page to the prev before last */ - for (count = 1; count < (num_pages - 1); count++) { - lli_array[count].physical_address = - (unsigned long)page_to_phys(page_array[count]); - lli_array[count].block_size = PAGE_SIZE; - - edbg( - "lli_array[%lu].physical_address is %08lx, \ - lli_array[%lu].block_size is %lu\n", - count, lli_array[count].physical_address, - count, - lli_array[count].block_size); - } - - /* if more then 1 pages locked - then update for the last page size needed */ - if (num_pages > 1) { - /* update the address of the last page */ - lli_array[count].physical_address = - (unsigned long)page_to_phys(page_array[count]); - - /* set the size of the last page */ - lli_array[count].block_size = (app_virt_addr + data_size) & - (~PAGE_MASK); - - if (lli_array[count].block_size == 0) { - dbg("app_virt_addr is %08lx\n", app_virt_addr); - dbg("data_size is %lu\n", data_size); - while (1); + dbg("SEP Driver:--------> sep_lock_user_pages start\n"); + + error = 0; + + /* set start and end pages and num pages */ + end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT; + start_page = app_virt_addr >> PAGE_SHIFT; + num_pages = end_page - start_page + 1; + + edbg("SEP Driver: app_virt_addr is %08lx\n", app_virt_addr); + edbg("SEP Driver: data_size is %lu\n", data_size); + edbg("SEP Driver: start_page is %lu\n", start_page); + edbg("SEP Driver: end_page is %lu\n", end_page); + edbg("SEP Driver: num_pages is %lu\n", num_pages); + + /* allocate array of pages structure pointers */ + page_array = kmalloc(sizeof(struct page *) * num_pages, GFP_ATOMIC); + if (!page_array) { + edbg("SEP Driver: kmalloc for page_array failed\n"); + + error = -ENOMEM; + goto end_function; } - edbg( - "lli_array[%lu].physical_address is %08lx, \ - lli_array[%lu].block_size is %lu\n", - count, lli_array[count].physical_address, - count, - lli_array[count].block_size); - } - /* set output params */ - *lli_array_ptr = lli_array; - *num_pages_ptr = num_pages; - *page_array_ptr = page_array; + lli_array = kmalloc(sizeof(struct sep_lli_entry_t) * num_pages, GFP_ATOMIC); + if (!lli_array) { + edbg("SEP Driver: kmalloc for lli_array failed\n"); - goto end_function; + error = -ENOMEM; + goto end_function_with_error1; + } -end_function_with_error2: + /* convert the application virtual address into a set of physical */ + down_read(¤t->mm->mmap_sem); + result = get_user_pages(current, current->mm, app_virt_addr, num_pages, 1, 0, page_array, 0); + up_read(¤t->mm->mmap_sem); - /* release the cache */ - for (count = 0; count < num_pages; count++) - page_cache_release(page_array[count]); + /* check the number of pages locked - if not all then exit with error */ + if (result != num_pages) { + dbg("SEP Driver: not all pages locked by get_user_pages\n"); - /* free lli array */ - kfree(lli_array); + error = -ENOMEM; + goto end_function_with_error2; + } + + /* flush the cache */ + for (count = 0; count < num_pages; count++) + flush_dcache_page(page_array[count]); + + /* set the start address of the first page - app data may start not at + the beginning of the page */ + lli_array[0].physical_address = ((unsigned long) page_to_phys(page_array[0])) + (app_virt_addr & (~PAGE_MASK)); + + /* check that not all the data is in the first page only */ + if ((PAGE_SIZE - (app_virt_addr & (~PAGE_MASK))) >= data_size) + lli_array[0].block_size = data_size; + else + lli_array[0].block_size = PAGE_SIZE - (app_virt_addr & (~PAGE_MASK)); + + /* debug print */ + dbg("lli_array[0].physical_address is %08lx, lli_array[0].block_size is %lu\n", lli_array[0].physical_address, lli_array[0].block_size); + + /* go from the second page to the prev before last */ + for (count = 1; count < (num_pages - 1); count++) { + lli_array[count].physical_address = (unsigned long) page_to_phys(page_array[count]); + lli_array[count].block_size = PAGE_SIZE; + + edbg("lli_array[%lu].physical_address is %08lx, \ + lli_array[%lu].block_size is %lu\n", count, lli_array[count].physical_address, count, lli_array[count].block_size); + } + + /* if more then 1 pages locked - then update for the last page size needed */ + if (num_pages > 1) { + /* update the address of the last page */ + lli_array[count].physical_address = (unsigned long) page_to_phys(page_array[count]); + + /* set the size of the last page */ + lli_array[count].block_size = (app_virt_addr + data_size) & (~PAGE_MASK); + + if (lli_array[count].block_size == 0) { + dbg("app_virt_addr is %08lx\n", app_virt_addr); + dbg("data_size is %lu\n", data_size); + while (1); + } + edbg("lli_array[%lu].physical_address is %08lx, \ + lli_array[%lu].block_size is %lu\n", count, lli_array[count].physical_address, count, lli_array[count].block_size); + } + + /* set output params */ + *lli_array_ptr = lli_array; + *num_pages_ptr = num_pages; + *page_array_ptr = page_array; + + goto end_function; + + end_function_with_error2: -end_function_with_error1: + /* release the cache */ + for (count = 0; count < num_pages; count++) + page_cache_release(page_array[count]); + + /* free lli array */ + kfree(lli_array); + + end_function_with_error1: - /* free page array */ - kfree(page_array); + /* free page array */ + kfree(page_array); -end_function: + end_function: - dbg("SEP Driver:<-------- sep_lock_user_pages end\n"); + dbg("SEP Driver:<-------- sep_lock_user_pages end\n"); - return 0; + return 0; } /* @@ -1979,180 +1693,147 @@ end_function: and construct a basic lli array, where each entry holds the physical page address and the size that application data holds in this physical pages */ -int sep_lock_kernel_pages(unsigned long kernel_virt_addr, - unsigned long data_size, - unsigned long *num_pages_ptr, - struct sep_lli_entry_t **lli_array_ptr, - struct page ***page_array_ptr) - +int sep_lock_kernel_pages(unsigned long kernel_virt_addr, unsigned long data_size, unsigned long *num_pages_ptr, struct sep_lli_entry_t **lli_array_ptr, struct page ***page_array_ptr) { - /* error */ - int error; + /* error */ + int error; - /* the the page of the end address of the user space buffer */ - unsigned long end_page; + /* the the page of the end address of the user space buffer */ + unsigned long end_page; - /* the page of the start address of the user space buffer */ - unsigned long start_page; + /* the page of the start address of the user space buffer */ + unsigned long start_page; - /* the range in pages */ - unsigned long num_pages; + /* the range in pages */ + unsigned long num_pages; - /* array of lli */ - struct sep_lli_entry_t *lli_array; + /* array of lli */ + struct sep_lli_entry_t *lli_array; - /* next kernel address to map */ - unsigned long next_kernel_address; + /* next kernel address to map */ + unsigned long next_kernel_address; - /* count */ - unsigned long count; + /* count */ + unsigned long count; /*------------------------ CODE --------------------------*/ - dbg("SEP Driver:--------> sep_lock_kernel_pages start\n"); - - error = 0; - - /* set start and end pages and num pages */ - end_page = (kernel_virt_addr + data_size - 1) >> PAGE_SHIFT; - start_page = kernel_virt_addr >> PAGE_SHIFT; - num_pages = end_page - start_page + 1; - - edbg( - "SEP Driver: kernel_virt_addr is %08lx\n", - kernel_virt_addr); - edbg( - "SEP Driver: data_size is %lu\n", - data_size); - edbg( - "SEP Driver: start_page is %lx\n", - start_page); - edbg( - "SEP Driver: end_page is %lx\n", - end_page); - edbg( - "SEP Driver: num_pages is %lu\n", - num_pages); - - lli_array = kmalloc(sizeof(struct sep_lli_entry_t) * num_pages, GFP_ATOMIC); - if (!lli_array) { - edbg( - "SEP Driver: kmalloc for lli_array failed\n"); - - error = -ENOMEM; - goto end_function; - } - - /* set the start address of the first page - app data may start not at - the beginning of the page */ - lli_array[0].physical_address = - (unsigned long)virt_to_phys((unsigned long *)kernel_virt_addr); - - /* check that not all the data is in the first page only */ - if ((PAGE_SIZE - (kernel_virt_addr & (~PAGE_MASK))) >= data_size) - lli_array[0].block_size = data_size; - else - lli_array[0].block_size = - PAGE_SIZE - (kernel_virt_addr & (~PAGE_MASK)); - - /* debug print */ - dbg("lli_array[0].physical_address is %08lx, lli_array[0].block_size is %lu\n", - lli_array[0].physical_address, - lli_array[0].block_size); - - /* advance the address to the start of the next page */ - next_kernel_address = (kernel_virt_addr & PAGE_MASK) + PAGE_SIZE; - - /* go from the second page to the prev before last */ - for (count = 1; count < (num_pages - 1); count++) { - lli_array[count].physical_address = - (unsigned long)virt_to_phys((unsigned long *)next_kernel_address); - lli_array[count].block_size = PAGE_SIZE; - - edbg( - "lli_array[%lu].physical_address is %08lx, \ - lli_array[%lu].block_size is %lu\n", - count, lli_array[count].physical_address, count, - lli_array[count].block_size); - - next_kernel_address += PAGE_SIZE; - } - - /* if more then 1 pages locked - then update for the last page size needed */ - if (num_pages > 1) { - /* update the address of the last page */ - lli_array[count].physical_address = - (unsigned long)virt_to_phys((unsigned long *)next_kernel_address); - - /* set the size of the last page */ - lli_array[count].block_size = - (kernel_virt_addr + data_size) & (~PAGE_MASK); - - if (lli_array[count].block_size == 0) { - dbg("app_virt_addr is %08lx\n", - kernel_virt_addr); - dbg("data_size is %lu\n", data_size); - while (1); + dbg("SEP Driver:--------> sep_lock_kernel_pages start\n"); + + error = 0; + + /* set start and end pages and num pages */ + end_page = (kernel_virt_addr + data_size - 1) >> PAGE_SHIFT; + start_page = kernel_virt_addr >> PAGE_SHIFT; + num_pages = end_page - start_page + 1; + + edbg("SEP Driver: kernel_virt_addr is %08lx\n", kernel_virt_addr); + edbg("SEP Driver: data_size is %lu\n", data_size); + edbg("SEP Driver: start_page is %lx\n", start_page); + edbg("SEP Driver: end_page is %lx\n", end_page); + edbg("SEP Driver: num_pages is %lu\n", num_pages); + + lli_array = kmalloc(sizeof(struct sep_lli_entry_t) * num_pages, GFP_ATOMIC); + if (!lli_array) { + edbg("SEP Driver: kmalloc for lli_array failed\n"); + + error = -ENOMEM; + goto end_function; } - edbg( - "lli_array[%lu].physical_address is %08lx, \ - lli_array[%lu].block_size is %lu\n", - count, lli_array[count].physical_address, - count, - lli_array[count].block_size); - } + /* set the start address of the first page - app data may start not at + the beginning of the page */ + lli_array[0].physical_address = (unsigned long) virt_to_phys((unsigned long *) kernel_virt_addr); - /* set output params */ - *lli_array_ptr = lli_array; - *num_pages_ptr = num_pages; - *page_array_ptr = 0; + /* check that not all the data is in the first page only */ + if ((PAGE_SIZE - (kernel_virt_addr & (~PAGE_MASK))) >= data_size) + lli_array[0].block_size = data_size; + else + lli_array[0].block_size = PAGE_SIZE - (kernel_virt_addr & (~PAGE_MASK)); + /* debug print */ + dbg("lli_array[0].physical_address is %08lx, lli_array[0].block_size is %lu\n", lli_array[0].physical_address, lli_array[0].block_size); + + /* advance the address to the start of the next page */ + next_kernel_address = (kernel_virt_addr & PAGE_MASK) + PAGE_SIZE; + + /* go from the second page to the prev before last */ + for (count = 1; count < (num_pages - 1); count++) { + lli_array[count].physical_address = (unsigned long) virt_to_phys((unsigned long *) next_kernel_address); + lli_array[count].block_size = PAGE_SIZE; + + edbg("lli_array[%lu].physical_address is %08lx, \ + lli_array[%lu].block_size is %lu\n", count, lli_array[count].physical_address, count, lli_array[count].block_size); + + next_kernel_address += PAGE_SIZE; + } -end_function: + /* if more then 1 pages locked - then update for the last page size needed */ + if (num_pages > 1) { + /* update the address of the last page */ + lli_array[count].physical_address = (unsigned long) virt_to_phys((unsigned long *) next_kernel_address); - dbg("SEP Driver:<-------- sep_lock_kernel_pages end\n"); + /* set the size of the last page */ + lli_array[count].block_size = (kernel_virt_addr + data_size) & (~PAGE_MASK); - return 0; + if (lli_array[count].block_size == 0) { + dbg("app_virt_addr is %08lx\n", kernel_virt_addr); + dbg("data_size is %lu\n", data_size); + while (1); + } + + edbg("lli_array[%lu].physical_address is %08lx, \ + lli_array[%lu].block_size is %lu\n", count, lli_array[count].physical_address, count, lli_array[count].block_size); + } + + /* set output params */ + *lli_array_ptr = lli_array; + *num_pages_ptr = num_pages; + *page_array_ptr = 0; + + + end_function: + + dbg("SEP Driver:<-------- sep_lock_kernel_pages end\n"); + + return 0; } /* This function releases all the application virtual buffer physical pages, that were previously locked */ -int sep_free_dma_pages(struct page **page_array_ptr, - unsigned long num_pages, - unsigned long dirtyFlag) +int sep_free_dma_pages(struct page **page_array_ptr, unsigned long num_pages, unsigned long dirtyFlag) { - /* count */ - unsigned long count; + /* count */ + unsigned long count; /*------------------- CODE ---------------------*/ - if (dirtyFlag) { - for (count = 0; count < num_pages; count++) { - /* the out array was written, therefore the data was changed */ - if (!PageReserved(page_array_ptr[count])) - SetPageDirty(page_array_ptr[count]); - page_cache_release(page_array_ptr[count]); + if (dirtyFlag) { + for (count = 0; count < num_pages; count++) { + /* the out array was written, therefore the data was changed */ + if (!PageReserved(page_array_ptr[count])) + SetPageDirty(page_array_ptr[count]); + page_cache_release(page_array_ptr[count]); + } + } else { + /* free in pages - the data was only read, therefore no update was done + on those pages */ + for (count = 0; count < num_pages; count++) + page_cache_release(page_array_ptr[count]); } - } else { - /* free in pages - the data was only read, therefore no update was done - on those pages */ - for (count = 0; count < num_pages; count++) - page_cache_release(page_array_ptr[count]); - } - if (page_array_ptr) - /* free the array */ - kfree(page_array_ptr); + if (page_array_ptr) + /* free the array */ + kfree(page_array_ptr); - return 0; + return 0; } /* @@ -2162,28 +1843,27 @@ int sep_free_dma_pages(struct page **page_array_ptr, static void sep_send_command_handler() { - unsigned long count; + unsigned long count; - dbg("SEP Driver:--------> sep_send_command_handler start\n"); + dbg("SEP Driver:--------> sep_send_command_handler start\n"); - sep_set_time(0, 0); + sep_set_time(0, 0); - /* flash cache */ - flush_cache_all(); + /* flash cache */ + flush_cache_all(); - for (count = 0; count < 12 * 4; count += 4) - edbg("Word %lu of the message is %lu\n", count, - *((unsigned long *)(sep_dev->shared_area_addr + count))); + for (count = 0; count < 12 * 4; count += 4) + edbg("Word %lu of the message is %lu\n", count, *((unsigned long *) (sep_dev->shared_area_addr + count))); - /* update counter */ - sep_dev->host_to_sep_send_counter++; + /* update counter */ + sep_dev->host_to_sep_send_counter++; - /* send interrupt to SEP */ - sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2); + /* send interrupt to SEP */ + sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2); - dbg("SEP Driver:<-------- sep_send_command_handler end\n"); + dbg("SEP Driver:<-------- sep_send_command_handler end\n"); - return; + return; } /* @@ -2192,33 +1872,31 @@ static void sep_send_command_handler() */ static void sep_send_reply_command_handler() { - unsigned long count; + unsigned long count; - dbg("SEP Driver:--------> sep_send_reply_command_handler start\n"); + dbg("SEP Driver:--------> sep_send_reply_command_handler start\n"); - /* flash cache */ - flush_cache_all(); + /* flash cache */ + flush_cache_all(); - for (count = 0; count < 12 * 4; count += 4) - edbg("Word %lu of the message is %lu\n", count, - *((unsigned long *)(sep_dev->shared_area_addr + count))); + for (count = 0; count < 12 * 4; count += 4) + edbg("Word %lu of the message is %lu\n", count, *((unsigned long *) (sep_dev->shared_area_addr + count))); - /* update counter */ - sep_dev->host_to_sep_send_counter++; + /* update counter */ + sep_dev->host_to_sep_send_counter++; - /* send the interrupt to SEP */ - sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR2_REG_ADDR, - sep_dev->host_to_sep_send_counter); + /* send the interrupt to SEP */ + sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR2_REG_ADDR, sep_dev->host_to_sep_send_counter); - /* update both counters */ - sep_dev->host_to_sep_send_counter++; + /* update both counters */ + sep_dev->host_to_sep_send_counter++; - sep_dev->sep_to_host_reply_counter++; + sep_dev->sep_to_host_reply_counter++; - dbg("SEP Driver:<-------- sep_send_reply_command_handler end\n"); + dbg("SEP Driver:<-------- sep_send_reply_command_handler end\n"); - return; + return; } @@ -2232,55 +1910,46 @@ static void sep_send_reply_command_handler() */ static int sep_allocate_data_pool_memory_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* command paramaters */ - struct sep_driver_alloc_t command_args; + /* command paramaters */ + struct sep_driver_alloc_t command_args; /*------------------------- CODE ----------------------------*/ - dbg("SEP Driver:--------> sep_allocate_data_pool_memory_handler start\n"); + dbg("SEP Driver:--------> sep_allocate_data_pool_memory_handler start\n"); - error = copy_from_user(&command_args, - (void *)arg, - sizeof(struct sep_driver_alloc_t)); - if (error) - goto end_function; + error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_alloc_t)); + if (error) + goto end_function; - /* allocate memory */ - if ( - (sep_dev->data_pool_bytes_allocated + command_args.num_bytes) > - SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) { - error = -ENOTTY; - goto end_function; - } - - /* set the virtual and physical address */ - command_args.offset = SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + - sep_dev->data_pool_bytes_allocated; - command_args.phys_address = sep_dev->phys_shared_area_addr + - SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + - sep_dev->data_pool_bytes_allocated; - - /* write the memory back to the user space */ - error = copy_to_user((void *)arg, - (void *)&command_args, - sizeof(struct sep_driver_alloc_t)); - if (error) - goto end_function; + /* allocate memory */ + if ((sep_dev->data_pool_bytes_allocated + command_args.num_bytes) > SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) { + error = -ENOTTY; + goto end_function; + } + + /* set the virtual and physical address */ + command_args.offset = SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + sep_dev->data_pool_bytes_allocated; + command_args.phys_address = sep_dev->phys_shared_area_addr + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + sep_dev->data_pool_bytes_allocated; - /* set the allocation */ - sep_dev->data_pool_bytes_allocated += command_args.num_bytes; + /* write the memory back to the user space */ + error = copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_alloc_t)); + if (error) + goto end_function; -end_function: + /* set the allocation */ + sep_dev->data_pool_bytes_allocated += command_args.num_bytes; - dbg("SEP Driver:<-------- sep_allocate_data_pool_memory_handler end\n"); + end_function: - return error; + dbg("SEP Driver:<-------- sep_allocate_data_pool_memory_handler end\n"); + + return error; } /* @@ -2288,67 +1957,60 @@ end_function: */ static int sep_write_into_data_pool_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* virtual address */ - unsigned long virt_address; + /* virtual address */ + unsigned long virt_address; - /* application in address */ - unsigned long app_in_address; + /* application in address */ + unsigned long app_in_address; - /* number of bytes */ - unsigned long num_bytes; + /* number of bytes */ + unsigned long num_bytes; - /* address of the data pool */ - unsigned long data_pool_area_addr; + /* address of the data pool */ + unsigned long data_pool_area_addr; /*-------------------------- CODE -----------------------------*/ - dbg("SEP Driver:--------> sep_write_into_data_pool_handler start\n"); + dbg("SEP Driver:--------> sep_write_into_data_pool_handler start\n"); - /* get the application address */ - error = get_user(app_in_address, - &(((struct sep_driver_write_t *)arg)->app_address)); - if (error) - goto end_function; + /* get the application address */ + error = get_user(app_in_address, &(((struct sep_driver_write_t *) arg)->app_address)); + if (error) + goto end_function; - /* get the virtual kernel address address */ - error = get_user(virt_address, - &(((struct sep_driver_write_t *)arg)->datapool_address)); - if (error) - goto end_function; + /* get the virtual kernel address address */ + error = get_user(virt_address, &(((struct sep_driver_write_t *) arg)->datapool_address)); + if (error) + goto end_function; - /* get the number of bytes */ - error = get_user(num_bytes, &(((struct sep_driver_write_t *)arg)->num_bytes)); - if (error) - goto end_function; + /* get the number of bytes */ + error = get_user(num_bytes, &(((struct sep_driver_write_t *) arg)->num_bytes)); + if (error) + goto end_function; - /* calculate the start of the data pool */ - data_pool_area_addr = sep_dev->shared_area_addr + - SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES; + /* calculate the start of the data pool */ + data_pool_area_addr = sep_dev->shared_area_addr + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES; - /* check that the range of the virtual kernel address is correct */ - if ((virt_address < data_pool_area_addr) || - (virt_address > (data_pool_area_addr + - SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES))) { - error = -ENOTTY; - goto end_function; - } + /* check that the range of the virtual kernel address is correct */ + if ((virt_address < data_pool_area_addr) || (virt_address > (data_pool_area_addr + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES))) { + error = -ENOTTY; + goto end_function; + } - /* copy the application data */ - error = copy_from_user((void *)virt_address, - (void *)app_in_address, - num_bytes); + /* copy the application data */ + error = copy_from_user((void *) virt_address, (void *) app_in_address, num_bytes); -end_function: + end_function: - dbg("SEP Driver:<-------- sep_write_into_data_pool_handler end\n"); + dbg("SEP Driver:<-------- sep_write_into_data_pool_handler end\n"); - return error; + return error; } /* @@ -2356,65 +2018,59 @@ end_function: */ static int sep_read_from_data_pool_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* virtual address of dest application buffer */ - unsigned long app_out_address; + /* virtual address of dest application buffer */ + unsigned long app_out_address; - /* virtual address of the data pool */ - unsigned long virt_address; + /* virtual address of the data pool */ + unsigned long virt_address; - /* number bytes */ - unsigned long num_bytes; + /* number bytes */ + unsigned long num_bytes; - /* address of the data pool */ - unsigned long data_pool_area_addr; + /* address of the data pool */ + unsigned long data_pool_area_addr; /*------------------------ CODE -----------------------------*/ - dbg("SEP Driver:--------> sep_read_from_data_pool_handler start\n"); + dbg("SEP Driver:--------> sep_read_from_data_pool_handler start\n"); - /* get the application address */ - error = get_user(app_out_address, - &(((struct sep_driver_write_t *)arg)->app_address)); - if (error) - goto end_function; + /* get the application address */ + error = get_user(app_out_address, &(((struct sep_driver_write_t *) arg)->app_address)); + if (error) + goto end_function; - /* get the virtual kernel address address */ - error = get_user(virt_address, - &(((struct sep_driver_write_t *)arg)->datapool_address)); - if (error) - goto end_function; + /* get the virtual kernel address address */ + error = get_user(virt_address, &(((struct sep_driver_write_t *) arg)->datapool_address)); + if (error) + goto end_function; - /* get the number of bytes */ - error = get_user(num_bytes, &(((struct sep_driver_write_t *)arg)->num_bytes)); - if (error) - goto end_function; + /* get the number of bytes */ + error = get_user(num_bytes, &(((struct sep_driver_write_t *) arg)->num_bytes)); + if (error) + goto end_function; - /* calculate the start of the data pool */ - data_pool_area_addr = sep_dev->shared_area_addr + - SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES; + /* calculate the start of the data pool */ + data_pool_area_addr = sep_dev->shared_area_addr + SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES; - /* check that the range of the virtual kernel address is correct */ - if ((virt_address < data_pool_area_addr) || - (virt_address > (data_pool_area_addr + - SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES))) { - error = -ENOTTY; - goto end_function; - } + /* check that the range of the virtual kernel address is correct */ + if ((virt_address < data_pool_area_addr) || (virt_address > (data_pool_area_addr + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES))) { + error = -ENOTTY; + goto end_function; + } - /* copy the application data */ - error = copy_to_user((void *)app_out_address, (void *)virt_address, - num_bytes); + /* copy the application data */ + error = copy_to_user((void *) app_out_address, (void *) virt_address, num_bytes); -end_function: + end_function: - dbg("SEP Driver:<-------- sep_read_from_data_pool_handler end\n"); + dbg("SEP Driver:<-------- sep_read_from_data_pool_handler end\n"); - return error; + return error; } @@ -2424,74 +2080,53 @@ end_function: */ static int sep_create_sync_dma_tables_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* command arguments */ - struct sep_driver_build_sync_table_t command_args; + /* command arguments */ + struct sep_driver_build_sync_table_t command_args; /*------------------------ CODE --------------------------*/ - dbg("SEP Driver:--------> sep_create_sync_dma_tables_handler start\n"); + dbg("SEP Driver:--------> sep_create_sync_dma_tables_handler start\n"); - error = copy_from_user(&command_args, - (void *)arg, - sizeof(struct sep_driver_build_sync_table_t)); - if (error) - goto end_function; + error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_build_sync_table_t)); + if (error) + goto end_function; - edbg( - "app_in_address is %08lx\n", - command_args.app_in_address); - edbg( - "app_out_address is %08lx\n", - command_args.app_out_address); - edbg( - "data_size is %lu\n", - command_args.data_in_size); - edbg( - "block_size is %lu\n", - command_args.block_size); - - - /* check if we need to build only input table or input/output */ - if (command_args.app_out_address) - /* prepare input and output tables */ - error = sep_prepare_input_output_dma_table(command_args.app_in_address, - command_args.app_out_address, - command_args.data_in_size, - command_args.block_size, - &command_args.in_table_address, - &command_args.out_table_address, - &command_args.in_table_num_entries, - &command_args.out_table_num_entries, - &command_args.table_data_size, - command_args.isKernelVirtualAddress); - else - /* prepare input tables */ - error = sep_prepare_input_dma_table(command_args.app_in_address, - command_args.data_in_size, - command_args.block_size, - &command_args.in_table_address, - &command_args.in_table_num_entries, - &command_args.table_data_size, - command_args.isKernelVirtualAddress); - - if (error) - goto end_function; + edbg("app_in_address is %08lx\n", command_args.app_in_address); + edbg("app_out_address is %08lx\n", command_args.app_out_address); + edbg("data_size is %lu\n", command_args.data_in_size); + edbg("block_size is %lu\n", command_args.block_size); + + + /* check if we need to build only input table or input/output */ + if (command_args.app_out_address) + /* prepare input and output tables */ + error = sep_prepare_input_output_dma_table(command_args.app_in_address, + command_args.app_out_address, + command_args.data_in_size, + command_args.block_size, + &command_args.in_table_address, + &command_args.out_table_address, &command_args.in_table_num_entries, &command_args.out_table_num_entries, &command_args.table_data_size, command_args.isKernelVirtualAddress); + else + /* prepare input tables */ + error = sep_prepare_input_dma_table(command_args.app_in_address, + command_args.data_in_size, command_args.block_size, &command_args.in_table_address, &command_args.in_table_num_entries, &command_args.table_data_size, command_args.isKernelVirtualAddress); - /* copy to user */ - error = copy_to_user((void *)arg, - (void *)&command_args, - sizeof(struct sep_driver_build_sync_table_t)); + if (error) + goto end_function; -end_function: + /* copy to user */ + error = copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_build_sync_table_t)); - dbg("SEP Driver:<-------- sep_create_sync_dma_tables_handler end\n"); + end_function: - return error; + dbg("SEP Driver:<-------- sep_create_sync_dma_tables_handler end\n"); + + return error; } /* @@ -2503,29 +2138,25 @@ int sep_free_dma_table_data_handler() CODE -----------------------------*/ - dbg("SEP Driver:--------> sep_free_dma_table_data_handler start\n"); + dbg("SEP Driver:--------> sep_free_dma_table_data_handler start\n"); - /* free input pages array */ - sep_free_dma_pages(sep_dev->in_page_array, - sep_dev->in_num_pages, - 0); + /* free input pages array */ + sep_free_dma_pages(sep_dev->in_page_array, sep_dev->in_num_pages, 0); - /* free output pages array if needed */ - if (sep_dev->out_page_array) - sep_free_dma_pages(sep_dev->out_page_array, - sep_dev->out_num_pages, - 1); + /* free output pages array if needed */ + if (sep_dev->out_page_array) + sep_free_dma_pages(sep_dev->out_page_array, sep_dev->out_num_pages, 1); - /* reset all the values */ - sep_dev->in_page_array = 0; - sep_dev->out_page_array = 0; - sep_dev->in_num_pages = 0; - sep_dev->out_num_pages = 0; + /* reset all the values */ + sep_dev->in_page_array = 0; + sep_dev->out_page_array = 0; + sep_dev->in_num_pages = 0; + sep_dev->out_num_pages = 0; - dbg("SEP Driver:<-------- sep_free_dma_table_data_handler end\n"); + dbg("SEP Driver:<-------- sep_free_dma_table_data_handler end\n"); - return 0; + return 0; } /* @@ -2533,96 +2164,84 @@ int sep_free_dma_table_data_handler() */ static int sep_create_flow_dma_tables_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* command arguments */ - struct sep_driver_build_flow_table_t command_args; + /* command arguments */ + struct sep_driver_build_flow_table_t command_args; - /* first table - output */ - struct sep_lli_entry_t first_table_data; + /* first table - output */ + struct sep_lli_entry_t first_table_data; - /* dma table data */ - struct sep_lli_entry_t last_table_data; + /* dma table data */ + struct sep_lli_entry_t last_table_data; - /* pointer to the info entry of the previuos DMA table */ - struct sep_lli_entry_t *prev_info_entry_ptr; + /* pointer to the info entry of the previuos DMA table */ + struct sep_lli_entry_t *prev_info_entry_ptr; - /* pointer to the flow data strucutre */ - struct sep_flow_context_t *flow_context_ptr; + /* pointer to the flow data strucutre */ + struct sep_flow_context_t *flow_context_ptr; /*------------------------ CODE --------------------------*/ - dbg("SEP Driver:--------> sep_create_flow_dma_tables_handler start\n"); + dbg("SEP Driver:--------> sep_create_flow_dma_tables_handler start\n"); - /* init variables */ - prev_info_entry_ptr = 0; - first_table_data.physical_address = 0xffffffff; + /* init variables */ + prev_info_entry_ptr = 0; + first_table_data.physical_address = 0xffffffff; - /* find the free structure for flow data */ - error = sep_find_flow_context(SEP_FREE_FLOW_ID, &flow_context_ptr); - if (error) - goto end_function; + /* find the free structure for flow data */ + error = sep_find_flow_context(SEP_FREE_FLOW_ID, &flow_context_ptr); + if (error) + goto end_function; - error = copy_from_user(&command_args, - (void *)arg, - sizeof(struct sep_driver_build_flow_table_t)); - if (error) - goto end_function; + error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_build_flow_table_t)); + if (error) + goto end_function; - /* create flow tables */ - error = sep_prepare_flow_dma_tables(command_args.num_virtual_buffers, - command_args.virt_buff_data_addr, - flow_context_ptr, - &first_table_data, - &last_table_data, - command_args.isKernelVirtualAddress); - if (error) - goto end_function_with_error; + /* create flow tables */ + error = sep_prepare_flow_dma_tables(command_args.num_virtual_buffers, command_args.virt_buff_data_addr, flow_context_ptr, &first_table_data, &last_table_data, command_args.isKernelVirtualAddress); + if (error) + goto end_function_with_error; - /* check if flow is static */ - if (!command_args.flow_type) - /* point the info entry of the last to the info entry of the first */ - last_table_data = first_table_data; + /* check if flow is static */ + if (!command_args.flow_type) + /* point the info entry of the last to the info entry of the first */ + last_table_data = first_table_data; - /* set output params */ - command_args.first_table_addr = first_table_data.physical_address; - command_args.first_table_num_entries = - ((first_table_data.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & - SEP_NUM_ENTRIES_MASK); - command_args.first_table_data_size = - (first_table_data.block_size & SEP_TABLE_DATA_SIZE_MASK); + /* set output params */ + command_args.first_table_addr = first_table_data.physical_address; + command_args.first_table_num_entries = ((first_table_data.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK); + command_args.first_table_data_size = (first_table_data.block_size & SEP_TABLE_DATA_SIZE_MASK); - /* send the parameters to user application */ - error = copy_to_user((void *)arg, - &command_args, - sizeof(struct sep_driver_build_flow_table_t)); - if (error) - goto end_function_with_error; + /* send the parameters to user application */ + error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_build_flow_table_t)); + if (error) + goto end_function_with_error; - /* all the flow created - update the flow entry with temp id */ - flow_context_ptr->flow_id = SEP_TEMP_FLOW_ID; + /* all the flow created - update the flow entry with temp id */ + flow_context_ptr->flow_id = SEP_TEMP_FLOW_ID; - /* set the processing tables data in the context */ - if (command_args.input_output_flag == SEP_DRIVER_IN_FLAG) - flow_context_ptr->input_tables_in_process = first_table_data; - else - flow_context_ptr->output_tables_in_process = first_table_data; + /* set the processing tables data in the context */ + if (command_args.input_output_flag == SEP_DRIVER_IN_FLAG) + flow_context_ptr->input_tables_in_process = first_table_data; + else + flow_context_ptr->output_tables_in_process = first_table_data; - goto end_function; + goto end_function; -end_function_with_error: + end_function_with_error: - /* free the allocated tables */ - sep_deallocated_flow_tables(&first_table_data); + /* free the allocated tables */ + sep_deallocated_flow_tables(&first_table_data); -end_function: + end_function: - dbg("SEP Driver:<-------- sep_create_flow_dma_tables_handler end\n"); + dbg("SEP Driver:<-------- sep_create_flow_dma_tables_handler end\n"); - return error; + return error; } @@ -2631,136 +2250,120 @@ end_function: */ static int sep_add_flow_tables_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* number of entries */ - unsigned long num_entries; + /* number of entries */ + unsigned long num_entries; - /* command arguments */ - struct sep_driver_add_flow_table_t command_args; + /* command arguments */ + struct sep_driver_add_flow_table_t command_args; - /* pointer to the flow data strucutre */ - struct sep_flow_context_t *flow_context_ptr; + /* pointer to the flow data strucutre */ + struct sep_flow_context_t *flow_context_ptr; - /* first dma table data */ - struct sep_lli_entry_t first_table_data; + /* first dma table data */ + struct sep_lli_entry_t first_table_data; - /* last dma table data */ - struct sep_lli_entry_t last_table_data; + /* last dma table data */ + struct sep_lli_entry_t last_table_data; - /* pointer to the info entry of the current DMA table */ - struct sep_lli_entry_t *info_entry_ptr; + /* pointer to the info entry of the current DMA table */ + struct sep_lli_entry_t *info_entry_ptr; /*-------------------------- CODE ----------------------------*/ - dbg("SEP Driver:--------> sep_add_flow_tables_handler start\n"); + dbg("SEP Driver:--------> sep_add_flow_tables_handler start\n"); - /* get input parameters */ - error = copy_from_user(&command_args, - (void *)arg, - sizeof(struct sep_driver_add_flow_table_t)); - if (error) - goto end_function; - - /* find the flow structure for the flow id */ - error = sep_find_flow_context(command_args.flow_id, &flow_context_ptr); - if (error) - goto end_function; + /* get input parameters */ + error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_add_flow_table_t)); + if (error) + goto end_function; - /* prepare the flow dma tables */ - error = sep_prepare_flow_dma_tables(command_args.num_virtual_buffers, - command_args.virt_buff_data_addr, - flow_context_ptr, - &first_table_data, - &last_table_data, - command_args.isKernelVirtualAddress); - if (error) - goto end_function_with_error; - - /* now check if there is already an existing add table for this flow */ - if (command_args.inputOutputFlag == SEP_DRIVER_IN_FLAG) { - /* this buffer was for input buffers */ - if (flow_context_ptr->input_tables_flag) { - /* add table already exists - add the new tables to the end - of the previous */ - num_entries = (flow_context_ptr->last_input_table.block_size >> - SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK; - - info_entry_ptr = - (struct sep_lli_entry_t *) - (flow_context_ptr->last_input_table.physical_address + - (sizeof(struct sep_lli_entry_t) * (num_entries - 1))); - - /* connect to list of tables */ - *info_entry_ptr = first_table_data; - - /* set the first table data */ - first_table_data = flow_context_ptr->first_input_table; - } else { - /* set the input flag */ - flow_context_ptr->input_tables_flag = 1; + /* find the flow structure for the flow id */ + error = sep_find_flow_context(command_args.flow_id, &flow_context_ptr); + if (error) + goto end_function; - /* set the first table data */ - flow_context_ptr->first_input_table = first_table_data; - } - /* set the last table data */ - flow_context_ptr->last_input_table = last_table_data; - } else /* this is output tables */ { - /* this buffer was for input buffers */ - if (flow_context_ptr->output_tables_flag) { - /* add table already exists - add the new tables to - the end of the previous */ - num_entries = (flow_context_ptr->last_output_table.block_size >> - SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK; - - info_entry_ptr = - (struct sep_lli_entry_t *) - (flow_context_ptr->last_output_table.physical_address + - (sizeof(struct sep_lli_entry_t) * (num_entries - 1))); - - /* connect to list of tables */ - *info_entry_ptr = first_table_data; - - /* set the first table data */ - first_table_data = flow_context_ptr->first_output_table; - } else { - /* set the input flag */ - flow_context_ptr->output_tables_flag = 1; + /* prepare the flow dma tables */ + error = sep_prepare_flow_dma_tables(command_args.num_virtual_buffers, command_args.virt_buff_data_addr, flow_context_ptr, &first_table_data, &last_table_data, command_args.isKernelVirtualAddress); + if (error) + goto end_function_with_error; - /* set the first table data */ - flow_context_ptr->first_output_table = first_table_data; + /* now check if there is already an existing add table for this flow */ + if (command_args.inputOutputFlag == SEP_DRIVER_IN_FLAG) { + /* this buffer was for input buffers */ + if (flow_context_ptr->input_tables_flag) { + /* add table already exists - add the new tables to the end + of the previous */ + num_entries = (flow_context_ptr->last_input_table.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK; + + info_entry_ptr = (struct sep_lli_entry_t *) + (flow_context_ptr->last_input_table.physical_address + (sizeof(struct sep_lli_entry_t) * (num_entries - 1))); + + /* connect to list of tables */ + *info_entry_ptr = first_table_data; + + /* set the first table data */ + first_table_data = flow_context_ptr->first_input_table; + } else { + /* set the input flag */ + flow_context_ptr->input_tables_flag = 1; + + /* set the first table data */ + flow_context_ptr->first_input_table = first_table_data; + } + /* set the last table data */ + flow_context_ptr->last_input_table = last_table_data; + } else { /* this is output tables */ + + /* this buffer was for input buffers */ + if (flow_context_ptr->output_tables_flag) { + /* add table already exists - add the new tables to + the end of the previous */ + num_entries = (flow_context_ptr->last_output_table.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK; + + info_entry_ptr = (struct sep_lli_entry_t *) + (flow_context_ptr->last_output_table.physical_address + (sizeof(struct sep_lli_entry_t) * (num_entries - 1))); + + /* connect to list of tables */ + *info_entry_ptr = first_table_data; + + /* set the first table data */ + first_table_data = flow_context_ptr->first_output_table; + } else { + /* set the input flag */ + flow_context_ptr->output_tables_flag = 1; + + /* set the first table data */ + flow_context_ptr->first_output_table = first_table_data; + } + /* set the last table data */ + flow_context_ptr->last_output_table = last_table_data; } - /* set the last table data */ - flow_context_ptr->last_output_table = last_table_data; - } - /* set output params */ - command_args.first_table_addr = first_table_data.physical_address; - command_args.first_table_num_entries = ((first_table_data.block_size >> - SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK); - command_args.first_table_data_size = - (first_table_data.block_size & SEP_TABLE_DATA_SIZE_MASK); + /* set output params */ + command_args.first_table_addr = first_table_data.physical_address; + command_args.first_table_num_entries = ((first_table_data.block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK); + command_args.first_table_data_size = (first_table_data.block_size & SEP_TABLE_DATA_SIZE_MASK); - /* send the parameters to user application */ - error = copy_to_user((void *)arg, - &command_args, - sizeof(struct sep_driver_add_flow_table_t)); - if (error) - goto end_function_with_error; + /* send the parameters to user application */ + error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_add_flow_table_t)); + if (error) + goto end_function_with_error; -end_function_with_error: + end_function_with_error: - /* free the allocated tables */ - sep_deallocated_flow_tables(&first_table_data); + /* free the allocated tables */ + sep_deallocated_flow_tables(&first_table_data); -end_function: + end_function: - dbg("SEP Driver:<-------- sep_add_flow_tables_handler end\n"); + dbg("SEP Driver:<-------- sep_add_flow_tables_handler end\n"); - return error; + return error; } /* @@ -2768,52 +2371,47 @@ end_function: */ static int sep_add_flow_tables_message_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* arguments */ - struct sep_driver_add_message_t command_args; + /* arguments */ + struct sep_driver_add_message_t command_args; - /* flow context */ - struct sep_flow_context_t *flow_context_ptr; + /* flow context */ + struct sep_flow_context_t *flow_context_ptr; /*---------------------------- CODE ------------------------------*/ - dbg("SEP Driver:--------> sep_add_flow_tables_message_handler start\n"); + dbg("SEP Driver:--------> sep_add_flow_tables_message_handler start\n"); - error = copy_from_user(&command_args, - (void *)arg, - sizeof(struct sep_driver_add_message_t)); - if (error) - goto end_function; + error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_add_message_t)); + if (error) + goto end_function; - /* check input */ - if (command_args.message_size_in_bytes > - SEP_MAX_ADD_MESSAGE_LENGTH_IN_BYTES) { - error = -ENOMEM; - goto end_function; - } + /* check input */ + if (command_args.message_size_in_bytes > SEP_MAX_ADD_MESSAGE_LENGTH_IN_BYTES) { + error = -ENOMEM; + goto end_function; + } - /* find the flow context */ - error = sep_find_flow_context(command_args.flow_id, &flow_context_ptr); - if (error) - goto end_function; + /* find the flow context */ + error = sep_find_flow_context(command_args.flow_id, &flow_context_ptr); + if (error) + goto end_function; - /* copy the message into context */ - flow_context_ptr->message_size_in_bytes = command_args.message_size_in_bytes; + /* copy the message into context */ + flow_context_ptr->message_size_in_bytes = command_args.message_size_in_bytes; - error = copy_from_user(flow_context_ptr->message, - (void *)command_args.message_address, - command_args.message_size_in_bytes); + error = copy_from_user(flow_context_ptr->message, (void *) command_args.message_address, command_args.message_size_in_bytes); -end_function: + end_function: - dbg("SEP Driver:<-------- sep_add_flow_tables_message_handler end\n"); + dbg("SEP Driver:<-------- sep_add_flow_tables_message_handler end\n"); - return error; + return error; } @@ -2822,40 +2420,34 @@ end_function: */ static int sep_get_static_pool_addr_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* command arguments */ - struct sep_driver_static_pool_addr_t command_args; + /* command arguments */ + struct sep_driver_static_pool_addr_t command_args; /*----------------------------- CODE ------------------------------*/ - dbg("SEP Driver:--------> sep_get_static_pool_addr_handler start\n"); + dbg("SEP Driver:--------> sep_get_static_pool_addr_handler start\n"); - /*prepare the output parameters in the struct */ - command_args.physical_static_address = sep_dev->phys_shared_area_addr + - SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES; - command_args.virtual_static_address = sep_dev->shared_area_addr + - SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES; + /*prepare the output parameters in the struct */ + command_args.physical_static_address = sep_dev->phys_shared_area_addr + SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES; + command_args.virtual_static_address = sep_dev->shared_area_addr + SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES; - edbg("SEP Driver:physical_static_address is %08lx, virtual_static_address %08lx\n", - command_args.physical_static_address, - command_args.virtual_static_address); + edbg("SEP Driver:physical_static_address is %08lx, virtual_static_address %08lx\n", command_args.physical_static_address, command_args.virtual_static_address); - /* send the parameters to user application */ - error = copy_to_user((void *)arg, - &command_args, - sizeof(struct sep_driver_static_pool_addr_t)); - if (error) - goto end_function; + /* send the parameters to user application */ + error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_static_pool_addr_t)); + if (error) + goto end_function; -end_function: + end_function: - dbg("SEP Driver:<-------- sep_get_static_pool_addr_handler end\n"); + dbg("SEP Driver:<-------- sep_get_static_pool_addr_handler end\n"); - return error; + return error; } /* @@ -2864,49 +2456,42 @@ end_function: */ static int sep_get_physical_mapped_offset_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* command arguments */ - struct sep_driver_get_mapped_offset_t command_args; + /* command arguments */ + struct sep_driver_get_mapped_offset_t command_args; /*----------------------------- CODE ------------------------------*/ - dbg("SEP Driver:--------> sep_get_physical_mapped_offset_handler start\n"); + dbg("SEP Driver:--------> sep_get_physical_mapped_offset_handler start\n"); - error = copy_from_user(&command_args, - (void *)arg, - sizeof(struct sep_driver_get_mapped_offset_t)); - if (error) - goto end_function; + error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_get_mapped_offset_t)); + if (error) + goto end_function; - if (command_args.physical_address < sep_dev->phys_shared_area_addr) { - error = -ENOTTY; - goto end_function; - } + if (command_args.physical_address < sep_dev->phys_shared_area_addr) { + error = -ENOTTY; + goto end_function; + } - /*prepare the output parameters in the struct */ - command_args.offset = command_args.physical_address - - sep_dev->phys_shared_area_addr; + /*prepare the output parameters in the struct */ + command_args.offset = command_args.physical_address - sep_dev->phys_shared_area_addr; - edbg("SEP Driver:physical_address is %08lx, offset is %lu\n", - command_args.physical_address, - command_args.offset); + edbg("SEP Driver:physical_address is %08lx, offset is %lu\n", command_args.physical_address, command_args.offset); - /* send the parameters to user application */ - error = copy_to_user((void *)arg, - &command_args, - sizeof(struct sep_driver_get_mapped_offset_t)); - if (error) - goto end_function; + /* send the parameters to user application */ + error = copy_to_user((void *) arg, &command_args, sizeof(struct sep_driver_get_mapped_offset_t)); + if (error) + goto end_function; -end_function: + end_function: - dbg("SEP Driver:<-------- sep_get_physical_mapped_offset_handler end\n"); + dbg("SEP Driver:<-------- sep_get_physical_mapped_offset_handler end\n"); - return error; + return error; } @@ -2915,37 +2500,37 @@ end_function: */ static int sep_start_handler(void) { - /* reg val */ - unsigned long reg_val; + /* reg val */ + unsigned long reg_val; - /* error */ - unsigned long error; + /* error */ + unsigned long error; /*----------------------------- CODE ------------------------------*/ - dbg("SEP Driver:--------> sep_start_handler start\n"); + dbg("SEP Driver:--------> sep_start_handler start\n"); - error = 0; + error = 0; - /* wait in polling for message from SEP */ - do { - reg_val = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR); - } while (!reg_val); + /* wait in polling for message from SEP */ + do { + reg_val = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR); + } while (!reg_val); - /* check the value */ - if (reg_val == 0x1) { - /* fatal error - read erro status from GPRO */ - error = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR); - goto end_function; - } + /* check the value */ + if (reg_val == 0x1) { + /* fatal error - read erro status from GPRO */ + error = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR); + goto end_function; + } -end_function: + end_function: - dbg("SEP Driver:<-------- sep_start_handler end\n"); + dbg("SEP Driver:<-------- sep_start_handler end\n"); - return error; + return error; } /* @@ -2953,101 +2538,90 @@ end_function: */ static int sep_init_handler(unsigned long arg) { - /* word from message */ - unsigned long message_word; + /* word from message */ + unsigned long message_word; - /* message ptr */ - unsigned long *message_ptr; + /* message ptr */ + unsigned long *message_ptr; - /* command arguments */ - struct sep_driver_init_t command_args; + /* command arguments */ + struct sep_driver_init_t command_args; - /* counter */ - unsigned long counter; + /* counter */ + unsigned long counter; - /* error */ - unsigned long error; + /* error */ + unsigned long error; - /* reg val */ - unsigned long reg_val; + /* reg val */ + unsigned long reg_val; /*------------------- CODE ---------------------*/ - dbg("SEP Driver:--------> sep_init_handler start\n"); + dbg("SEP Driver:--------> sep_init_handler start\n"); - error = 0; + error = 0; - error = copy_from_user(&command_args, (void *)arg, - sizeof(struct sep_driver_init_t)); + error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_init_t)); - dbg("SEP Driver:--------> sep_init_handler - finished copy_from_user \n"); + dbg("SEP Driver:--------> sep_init_handler - finished copy_from_user \n"); - if (error) - goto end_function; + if (error) + goto end_function; - /* PATCH - configure the DMA to single -burst instead of multi-burst */ - /*sep_configure_dma_burst();*/ + /* PATCH - configure the DMA to single -burst instead of multi-burst */ + /*sep_configure_dma_burst(); */ - dbg("SEP Driver:--------> sep_init_handler - finished sep_configure_dma_burst \n"); + dbg("SEP Driver:--------> sep_init_handler - finished sep_configure_dma_burst \n"); - message_ptr = (unsigned long *)command_args.message_addr; + message_ptr = (unsigned long *) command_args.message_addr; - /* set the base address of the SRAM */ - sep_write_reg(sep_dev, HW_SRAM_ADDR_REG_ADDR, HW_CC_SRAM_BASE_ADDRESS); + /* set the base address of the SRAM */ + sep_write_reg(sep_dev, HW_SRAM_ADDR_REG_ADDR, HW_CC_SRAM_BASE_ADDRESS); - for (counter = 0 ; - counter < command_args.message_size_in_words; - counter++, message_ptr++) { - get_user(message_word, message_ptr); + for (counter = 0; counter < command_args.message_size_in_words; counter++, message_ptr++) { + get_user(message_word, message_ptr); - /* write data to SRAM */ - sep_write_reg(sep_dev, HW_SRAM_DATA_REG_ADDR, - message_word); + /* write data to SRAM */ + sep_write_reg(sep_dev, HW_SRAM_DATA_REG_ADDR, message_word); - edbg( - "SEP Driver:message_word is %lu\n", - message_word); + edbg("SEP Driver:message_word is %lu\n", message_word); /* wait for write complete */ - sep_wait_sram_write(sep_dev); - } + sep_wait_sram_write(sep_dev); + } - dbg("SEP Driver:--------> sep_init_handler - finished getting messages from user space\n"); + dbg("SEP Driver:--------> sep_init_handler - finished getting messages from user space\n"); - /* signal SEP */ - sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, - 0x1); + /* signal SEP */ + sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x1); - do { - reg_val = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR); - } while (!(reg_val & 0xFFFFFFFD)); + do { + reg_val = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR); + } while (!(reg_val & 0xFFFFFFFD)); - dbg("SEP Driver:--------> sep_init_handler - finished waiting for reg_val & 0xFFFFFFFD \n"); + dbg("SEP Driver:--------> sep_init_handler - finished waiting for reg_val & 0xFFFFFFFD \n"); - /* check the value */ - if (reg_val == 0x1) { - edbg( - "SEP Driver:init failed\n"); + /* check the value */ + if (reg_val == 0x1) { + edbg("SEP Driver:init failed\n"); - error = sep_read_reg(sep_dev, 0x8060); - edbg( - "SEP Driver:sw monitor is %lu\n", - error); + error = sep_read_reg(sep_dev, 0x8060); + edbg("SEP Driver:sw monitor is %lu\n", error); - /* fatal error - read erro status from GPRO */ - error = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR); - edbg( - "SEP Driver:error is %lu\n", error); - goto end_function; - } + /* fatal error - read erro status from GPRO */ + error = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR0_REG_ADDR); + edbg("SEP Driver:error is %lu\n", error); + goto end_function; + } -end_function: + end_function: - dbg("SEP Driver:<-------- sep_init_handler end\n"); + dbg("SEP Driver:<-------- sep_init_handler end\n"); - return error; + return error; } @@ -3056,80 +2630,63 @@ end_function: */ static int sep_realloc_cache_resident_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* physical cache addr */ - unsigned long phys_cache_address; + /* physical cache addr */ + unsigned long phys_cache_address; - /* physical resident addr */ - unsigned long phys_resident_address; + /* physical resident addr */ + unsigned long phys_resident_address; - /* command arguments */ - struct sep_driver_realloc_cache_resident_t command_args; + /* command arguments */ + struct sep_driver_realloc_cache_resident_t command_args; /*------------------ CODE ---------------------*/ - /* copy the data */ - error = copy_from_user(&command_args, - (void *)arg, - sizeof(struct sep_driver_realloc_cache_resident_t)); - if (error) - goto end_function; + /* copy the data */ + error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_realloc_cache_resident_t)); + if (error) + goto end_function; - /* copy cache and resident to the their intended locations */ - error = sep_copy_cache_resident_to_area(command_args.cache_addr, - command_args.cache_size_in_bytes, - command_args.resident_addr, - command_args.resident_size_in_bytes, - &phys_cache_address, - &phys_resident_address); - if (error) - goto end_function; + /* copy cache and resident to the their intended locations */ + error = sep_copy_cache_resident_to_area(command_args.cache_addr, command_args.cache_size_in_bytes, command_args.resident_addr, command_args.resident_size_in_bytes, &phys_cache_address, &phys_resident_address); + if (error) + goto end_function; - /* lock the area (if needed) */ - sep_lock_cache_resident_area(); + /* lock the area (if needed) */ + sep_lock_cache_resident_area(); - command_args.new_base_addr = sep_dev->phys_shared_area_addr; + command_args.new_base_addr = sep_dev->phys_shared_area_addr; - /* find the new base address according to the lowest address between - cache, resident and shared area */ - if (phys_resident_address < command_args.new_base_addr) - command_args.new_base_addr = phys_resident_address; - if (phys_cache_address < command_args.new_base_addr) - command_args.new_base_addr = phys_cache_address; + /* find the new base address according to the lowest address between + cache, resident and shared area */ + if (phys_resident_address < command_args.new_base_addr) + command_args.new_base_addr = phys_resident_address; + if (phys_cache_address < command_args.new_base_addr) + command_args.new_base_addr = phys_cache_address; - /* set the return parameters */ - command_args.new_cache_addr = phys_cache_address; - command_args.new_resident_addr = phys_resident_address; + /* set the return parameters */ + command_args.new_cache_addr = phys_cache_address; + command_args.new_resident_addr = phys_resident_address; - /* set the new shared area */ - command_args.new_shared_area_addr = sep_dev->phys_shared_area_addr; + /* set the new shared area */ + command_args.new_shared_area_addr = sep_dev->phys_shared_area_addr; - edbg( - "SEP Driver:command_args.new_shared_area_addr is %08lx\n", - command_args.new_shared_area_addr); - edbg( - "SEP Driver:command_args.new_base_addr is %08lx\n", - command_args.new_base_addr); - edbg( - "SEP Driver:command_args.new_resident_addr is %08lx\n", - command_args.new_resident_addr); - edbg( - "SEP Driver:command_args.new_cache_addr is %08lx\n", - command_args.new_cache_addr); + edbg("SEP Driver:command_args.new_shared_area_addr is %08lx\n", command_args.new_shared_area_addr); + edbg("SEP Driver:command_args.new_base_addr is %08lx\n", command_args.new_base_addr); + edbg("SEP Driver:command_args.new_resident_addr is %08lx\n", command_args.new_resident_addr); + edbg("SEP Driver:command_args.new_cache_addr is %08lx\n", command_args.new_cache_addr); - /* return to user */ - error = copy_to_user((void *)arg, - (void *)&command_args, - sizeof(struct sep_driver_realloc_cache_resident_t)); + /* return to user */ + error = copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_realloc_cache_resident_t)); -end_function: + end_function: - return error; + return error; } /* @@ -3137,25 +2694,22 @@ end_function: */ static int sep_get_time_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* command arguments */ - struct sep_driver_get_time_t command_args; + /* command arguments */ + struct sep_driver_get_time_t command_args; /*------------------------ CODE --------------------------*/ - error = sep_set_time(&command_args.time_physical_address, - &command_args.time_value); + error = sep_set_time(&command_args.time_physical_address, &command_args.time_value); - /* return to user */ - error = copy_to_user((void *)arg, - (void *)&command_args, - sizeof(struct sep_driver_get_time_t)); + /* return to user */ + error = copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_get_time_t)); - return error; + return error; } @@ -3164,32 +2718,31 @@ static int sep_get_time_handler(unsigned long arg) */ static int sep_set_api_mode_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* flag */ - unsigned long mode_flag; + /* flag */ + unsigned long mode_flag; /*---------------------------- CODE -----------------------------*/ - dbg("SEP Driver:--------> sep_set_api_mode_handler start\n"); + dbg("SEP Driver:--------> sep_set_api_mode_handler start\n"); - error = get_user( - mode_flag, &(((struct sep_driver_set_api_mode_t *)arg)->mode)); - if (error) - goto end_function; + error = get_user(mode_flag, &(((struct sep_driver_set_api_mode_t *) arg)->mode)); + if (error) + goto end_function; - /* set the global flag */ - sep_dev->block_mode_flag = mode_flag; + /* set the global flag */ + sep_dev->block_mode_flag = mode_flag; -end_function: + end_function: - dbg("SEP Driver:<-------- sep_set_api_mode_handler end\n"); + dbg("SEP Driver:<-------- sep_set_api_mode_handler end\n"); - return error; + return error; } /* @@ -3201,57 +2754,55 @@ static int sep_end_transaction_handler(unsigned long arg) CODE -----------------------------*/ - dbg("SEP Driver:--------> sep_end_transaction_handler start\n"); + dbg("SEP Driver:--------> sep_end_transaction_handler start\n"); -#if 0/*!SEP_DRIVER_POLLING_MODE*/ - /* close IMR */ - sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, 0x7FFF); +#if 0 /*!SEP_DRIVER_POLLING_MODE */ + /* close IMR */ + sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, 0x7FFF); - /* release IRQ line */ - free_irq(SEP_DIRVER_IRQ_NUM, &sep_dev->reg_base_address); + /* release IRQ line */ + free_irq(SEP_DIRVER_IRQ_NUM, &sep_dev->reg_base_address); - /* lock the sep mutex */ - mutex_unlock(&sep_mutex); + /* lock the sep mutex */ + mutex_unlock(&sep_mutex); #endif - dbg("SEP Driver:<-------- sep_end_transaction_handler end\n"); + dbg("SEP Driver:<-------- sep_end_transaction_handler end\n"); - return 0; + return 0; } /* handler for flow done interrupt */ -static void sep_flow_done_handler(struct work_struct *work) +static void sep_flow_done_handler(struct work_struct *work) { - /* flow context_ptr */ - struct sep_flow_context_t *flow_data_ptr; + /* flow context_ptr */ + struct sep_flow_context_t *flow_data_ptr; /*------------------------- CODE ---------------------------*/ - /* obtain the mutex */ - mutex_lock(&sep_mutex); + /* obtain the mutex */ + mutex_lock(&sep_mutex); - /* get the pointer to context */ - flow_data_ptr = (struct sep_flow_context_t *)work; + /* get the pointer to context */ + flow_data_ptr = (struct sep_flow_context_t *) work; - /* free all the current input tables in sep */ - sep_deallocated_flow_tables(&flow_data_ptr->input_tables_in_process); + /* free all the current input tables in sep */ + sep_deallocated_flow_tables(&flow_data_ptr->input_tables_in_process); - /* free all the current tables output tables in SEP (if needed) */ - if (flow_data_ptr->output_tables_in_process.physical_address != 0xffffffff) - sep_deallocated_flow_tables(&flow_data_ptr->output_tables_in_process); + /* free all the current tables output tables in SEP (if needed) */ + if (flow_data_ptr->output_tables_in_process.physical_address != 0xffffffff) + sep_deallocated_flow_tables(&flow_data_ptr->output_tables_in_process); - /* check if we have additional tables to be sent to SEP only input - flag may be checked */ - if (flow_data_ptr->input_tables_flag) { - /* copy the message to the shared RAM and signal SEP */ - memcpy((void *)flow_data_ptr->message, - (void *)sep_dev->shared_area_addr, - flow_data_ptr->message_size_in_bytes); + /* check if we have additional tables to be sent to SEP only input + flag may be checked */ + if (flow_data_ptr->input_tables_flag) { + /* copy the message to the shared RAM and signal SEP */ + memcpy((void *) flow_data_ptr->message, (void *) sep_dev->shared_area_addr, flow_data_ptr->message_size_in_bytes); - sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR2_REG_ADDR, 0x2); - } - mutex_unlock(&sep_mutex); + sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR2_REG_ADDR, 0x2); + } + mutex_unlock(&sep_mutex); } @@ -3260,96 +2811,85 @@ static void sep_flow_done_handler(struct work_struct *work) the first and last tables of the list */ static int sep_prepare_flow_dma_tables(unsigned long num_virtual_buffers, - unsigned long first_buff_addr, - struct sep_flow_context_t *flow_data_ptr, - struct sep_lli_entry_t *first_table_data_ptr, - struct sep_lli_entry_t *last_table_data_ptr, - bool isKernelVirtualAddress) + unsigned long first_buff_addr, struct sep_flow_context_t *flow_data_ptr, struct sep_lli_entry_t *first_table_data_ptr, struct sep_lli_entry_t *last_table_data_ptr, bool isKernelVirtualAddress) { - /* error */ - int error; + /* error */ + int error; - /* virtaul address of one buffer */ - unsigned long virt_buff_addr; + /* virtaul address of one buffer */ + unsigned long virt_buff_addr; - /* virtual size of one buffer */ - unsigned long virt_buff_size; + /* virtual size of one buffer */ + unsigned long virt_buff_size; - /* table data for each created table */ - struct sep_lli_entry_t table_data; + /* table data for each created table */ + struct sep_lli_entry_t table_data; - /* info entry */ - struct sep_lli_entry_t *info_entry_ptr; + /* info entry */ + struct sep_lli_entry_t *info_entry_ptr; - /* prevouis info entry */ - struct sep_lli_entry_t *prev_info_entry_ptr; + /* prevouis info entry */ + struct sep_lli_entry_t *prev_info_entry_ptr; - /* counter */ - unsigned long i; + /* counter */ + unsigned long i; /*------------------------------- CODE ----------------------------------*/ - /* init vars */ - error = 0; - prev_info_entry_ptr = 0; - - /* init the first table to default */ - table_data.physical_address = 0xffffffff; - first_table_data_ptr->physical_address = 0xffffffff; - table_data.block_size = 0; - - for (i = 0; i < num_virtual_buffers; i++) { - /* get the virtual buffer address */ - error = get_user(virt_buff_addr, &first_buff_addr); - if (error) - goto end_function; - - /* get the virtual buffer size */ - first_buff_addr++; - error = get_user(virt_buff_size, &first_buff_addr); - if (error) - goto end_function; - - /* advance the address to point to the next pair of address|size */ - first_buff_addr++; - - /* now prepare the one flow LLI table from the data */ - error = sep_prepare_one_flow_dma_table(virt_buff_addr, - virt_buff_size, - &table_data, - &info_entry_ptr, - flow_data_ptr, - isKernelVirtualAddress); - if (error) - goto end_function; - - if (i == 0) { - /* if this is the first table - save it to return to the user - application */ - *first_table_data_ptr = table_data; - - /* set the pointer to info entry */ - prev_info_entry_ptr = info_entry_ptr; - } else { - /* not first table - the previous table info entry should - be updated */ - prev_info_entry_ptr->block_size = - (0x1 << SEP_INT_FLAG_OFFSET_IN_BITS) | - (table_data.block_size); - - /* set the pointer to info entry */ - prev_info_entry_ptr = info_entry_ptr; + /* init vars */ + error = 0; + prev_info_entry_ptr = 0; + + /* init the first table to default */ + table_data.physical_address = 0xffffffff; + first_table_data_ptr->physical_address = 0xffffffff; + table_data.block_size = 0; + + for (i = 0; i < num_virtual_buffers; i++) { + /* get the virtual buffer address */ + error = get_user(virt_buff_addr, &first_buff_addr); + if (error) + goto end_function; + + /* get the virtual buffer size */ + first_buff_addr++; + error = get_user(virt_buff_size, &first_buff_addr); + if (error) + goto end_function; + + /* advance the address to point to the next pair of address|size */ + first_buff_addr++; + + /* now prepare the one flow LLI table from the data */ + error = sep_prepare_one_flow_dma_table(virt_buff_addr, virt_buff_size, &table_data, &info_entry_ptr, flow_data_ptr, isKernelVirtualAddress); + if (error) + goto end_function; + + if (i == 0) { + /* if this is the first table - save it to return to the user + application */ + *first_table_data_ptr = table_data; + + /* set the pointer to info entry */ + prev_info_entry_ptr = info_entry_ptr; + } else { + /* not first table - the previous table info entry should + be updated */ + prev_info_entry_ptr->block_size = (0x1 << SEP_INT_FLAG_OFFSET_IN_BITS) | (table_data.block_size); + + /* set the pointer to info entry */ + prev_info_entry_ptr = info_entry_ptr; + } } - } - /* set the last table data */ - *last_table_data_ptr = table_data; + /* set the last table data */ + *last_table_data_ptr = table_data; -end_function: + end_function: - return error; + return error; } @@ -3357,116 +2897,96 @@ end_function: This function creates one DMA table for flow and returns its data, and pointer to its info entry */ -static int sep_prepare_one_flow_dma_table( - unsigned long virt_buff_addr, - unsigned long virt_buff_size, - struct sep_lli_entry_t *table_data, - struct sep_lli_entry_t **info_entry_ptr, - struct sep_flow_context_t *flow_data_ptr, - bool isKernelVirtualAddress) +static int sep_prepare_one_flow_dma_table(unsigned long virt_buff_addr, unsigned long virt_buff_size, struct sep_lli_entry_t *table_data, struct sep_lli_entry_t **info_entry_ptr, struct sep_flow_context_t *flow_data_ptr, bool isKernelVirtualAddress) { - /* error */ - int error; + /* error */ + int error; - /* the range in pages */ - unsigned long lli_array_size; + /* the range in pages */ + unsigned long lli_array_size; - /* array of pointers ot page */ - struct sep_lli_entry_t *lli_array; + /* array of pointers ot page */ + struct sep_lli_entry_t *lli_array; - /* pointer to the entry in the dma table */ - struct sep_lli_entry_t *flow_dma_table_entry_ptr; + /* pointer to the entry in the dma table */ + struct sep_lli_entry_t *flow_dma_table_entry_ptr; - /* address of the dma table */ - unsigned long *start_dma_table_ptr; + /* address of the dma table */ + unsigned long *start_dma_table_ptr; - /* total table data counter */ - unsigned long dma_table_data_count; + /* total table data counter */ + unsigned long dma_table_data_count; - /* pointer that will keep the pointer t the pages of the virtual buffer */ - struct page **page_array_ptr; + /* pointer that will keep the pointer t the pages of the virtual buffer */ + struct page **page_array_ptr; - /* counter */ - unsigned long entry_count; + /* counter */ + unsigned long entry_count; /*------------------------------- CODE ----------------------------------*/ - /* find the space for the new table */ - error = sep_find_free_flow_dma_table_space(&start_dma_table_ptr); - if (error) - goto end_function; + /* find the space for the new table */ + error = sep_find_free_flow_dma_table_space(&start_dma_table_ptr); + if (error) + goto end_function; - /* check if the pages are in Kernel Virtual Address layout */ - if (isKernelVirtualAddress == true) - /* lock kernel buffer in the memory */ - error = sep_lock_kernel_pages(virt_buff_addr, - virt_buff_size, - &lli_array_size, - &lli_array, - &page_array_ptr); - else - /* lock user buffer in the memory */ - error = sep_lock_user_pages(virt_buff_addr, - virt_buff_size, - &lli_array_size, - &lli_array, - &page_array_ptr); - - if (error) - goto end_function; + /* check if the pages are in Kernel Virtual Address layout */ + if (isKernelVirtualAddress == true) + /* lock kernel buffer in the memory */ + error = sep_lock_kernel_pages(virt_buff_addr, virt_buff_size, &lli_array_size, &lli_array, &page_array_ptr); + else + /* lock user buffer in the memory */ + error = sep_lock_user_pages(virt_buff_addr, virt_buff_size, &lli_array_size, &lli_array, &page_array_ptr); + + if (error) + goto end_function; - /* set the pointer to page array at the beginning of table - this table is - now considered taken */ - *start_dma_table_ptr = lli_array_size; + /* set the pointer to page array at the beginning of table - this table is + now considered taken */ + *start_dma_table_ptr = lli_array_size; - /* point to the place of the pages pointers of the table */ - start_dma_table_ptr++; + /* point to the place of the pages pointers of the table */ + start_dma_table_ptr++; - /* set the pages pointer */ - *start_dma_table_ptr = (unsigned long)page_array_ptr; + /* set the pages pointer */ + *start_dma_table_ptr = (unsigned long) page_array_ptr; - /* set the pointer to the first entry */ - flow_dma_table_entry_ptr = (struct sep_lli_entry_t *)(++start_dma_table_ptr); + /* set the pointer to the first entry */ + flow_dma_table_entry_ptr = (struct sep_lli_entry_t *) (++start_dma_table_ptr); - /* now create the entries for table */ - for (dma_table_data_count = entry_count = 0; - entry_count < lli_array_size; - entry_count++) { - flow_dma_table_entry_ptr->physical_address = - lli_array[entry_count].physical_address; + /* now create the entries for table */ + for (dma_table_data_count = entry_count = 0; entry_count < lli_array_size; entry_count++) { + flow_dma_table_entry_ptr->physical_address = lli_array[entry_count].physical_address; - flow_dma_table_entry_ptr->block_size = - lli_array[entry_count].block_size; + flow_dma_table_entry_ptr->block_size = lli_array[entry_count].block_size; - /* set the total data of a table */ - dma_table_data_count += lli_array[entry_count].block_size; + /* set the total data of a table */ + dma_table_data_count += lli_array[entry_count].block_size; - flow_dma_table_entry_ptr++; - } + flow_dma_table_entry_ptr++; + } - /* set the physical address */ - table_data->physical_address = virt_to_phys(start_dma_table_ptr); + /* set the physical address */ + table_data->physical_address = virt_to_phys(start_dma_table_ptr); - /* set the num_entries and total data size */ - table_data->block_size = ((lli_array_size + 1) << - SEP_NUM_ENTRIES_OFFSET_IN_BITS) | - (dma_table_data_count); + /* set the num_entries and total data size */ + table_data->block_size = ((lli_array_size + 1) << SEP_NUM_ENTRIES_OFFSET_IN_BITS) | (dma_table_data_count); - /* set the info entry */ - flow_dma_table_entry_ptr->physical_address = 0xffffffff; - flow_dma_table_entry_ptr->block_size = 0; + /* set the info entry */ + flow_dma_table_entry_ptr->physical_address = 0xffffffff; + flow_dma_table_entry_ptr->block_size = 0; - /* set the pointer to info entry */ - *info_entry_ptr = flow_dma_table_entry_ptr; + /* set the pointer to info entry */ + *info_entry_ptr = flow_dma_table_entry_ptr; - /* the array of the lli entries */ - kfree(lli_array); + /* the array of the lli entries */ + kfree(lli_array); -end_function: + end_function: - return error; + return error; } @@ -3474,96 +2994,88 @@ end_function: This function returns pointer to the flow data structure that conatins the given id */ -static int sep_find_flow_context( - unsigned long flow_id, - struct sep_flow_context_t **flow_data_ptr) +static int sep_find_flow_context(unsigned long flow_id, struct sep_flow_context_t **flow_data_ptr) { - /* count */ - unsigned long count; + /* count */ + unsigned long count; - /* error */ - int error; + /* error */ + int error; /*----------------------- CODE ---------------------------*/ - error = 0; - - /* - always search for flow with id default first - in case we - already started working on the flow there can be no situation - when 2 flows are with default flag - */ - for (count = 0; count < SEP_DRIVER_NUM_FLOWS; count++) { - if (sep_dev->flows_data_array[count].flow_id == flow_id) { - *flow_data_ptr = &sep_dev->flows_data_array[count]; - break; + error = 0; + + /* + always search for flow with id default first - in case we + already started working on the flow there can be no situation + when 2 flows are with default flag + */ + for (count = 0; count < SEP_DRIVER_NUM_FLOWS; count++) { + if (sep_dev->flows_data_array[count].flow_id == flow_id) { + *flow_data_ptr = &sep_dev->flows_data_array[count]; + break; + } } - } - if (count == SEP_DRIVER_NUM_FLOWS) - /* no flow found */ - error = -ENOMEM; + if (count == SEP_DRIVER_NUM_FLOWS) + /* no flow found */ + error = -ENOMEM; - return error; + return error; } /* this function find a space for the new flow dma table */ -static int sep_find_free_flow_dma_table_space( - unsigned long **table_address_ptr) +static int sep_find_free_flow_dma_table_space(unsigned long **table_address_ptr) { - /* error */ - int error; + /* error */ + int error; - /* pointer to the id field of the flow dma table */ - unsigned long *start_table_ptr; + /* pointer to the id field of the flow dma table */ + unsigned long *start_table_ptr; - /* start address of the flow dma area */ - unsigned long flow_dma_area_start_addr; + /* start address of the flow dma area */ + unsigned long flow_dma_area_start_addr; - /* end address of the flow dma area */ - unsigned long flow_dma_area_end_addr; + /* end address of the flow dma area */ + unsigned long flow_dma_area_end_addr; - /* maximum table size in words */ - unsigned long table_size_in_words; + /* maximum table size in words */ + unsigned long table_size_in_words; /*--------------------- CODE -----------------------*/ - error = 0; + error = 0; - /* find the start address of the flow DMA table area */ - flow_dma_area_start_addr = sep_dev->shared_area_addr + - SEP_DRIVER_FLOW_DMA_TABLES_AREA_OFFSET_IN_BYTES; + /* find the start address of the flow DMA table area */ + flow_dma_area_start_addr = sep_dev->shared_area_addr + SEP_DRIVER_FLOW_DMA_TABLES_AREA_OFFSET_IN_BYTES; - /* set end address of the flow table area */ - flow_dma_area_end_addr = flow_dma_area_start_addr + - SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES; + /* set end address of the flow table area */ + flow_dma_area_end_addr = flow_dma_area_start_addr + SEP_DRIVER_FLOW_DMA_TABLES_AREA_SIZE_IN_BYTES; - /* set table size in words */ - table_size_in_words = SEP_DRIVER_MAX_FLOW_NUM_ENTRIES_IN_TABLE * - (sizeof(struct sep_lli_entry_t) / sizeof(long)) + 2; + /* set table size in words */ + table_size_in_words = SEP_DRIVER_MAX_FLOW_NUM_ENTRIES_IN_TABLE * (sizeof(struct sep_lli_entry_t) / sizeof(long)) + 2; - /* set the pointer to the start address of DMA area */ - start_table_ptr = (unsigned long *)flow_dma_area_start_addr; + /* set the pointer to the start address of DMA area */ + start_table_ptr = (unsigned long *) flow_dma_area_start_addr; - /* find the space for the next table */ - while (((*start_table_ptr & 0x7FFFFFFF) != 0) && - ((unsigned long)start_table_ptr < - flow_dma_area_end_addr)) - start_table_ptr += table_size_in_words; + /* find the space for the next table */ + while (((*start_table_ptr & 0x7FFFFFFF) != 0) && ((unsigned long) start_table_ptr < flow_dma_area_end_addr)) + start_table_ptr += table_size_in_words; - /* check if we reached the end of floa tables area */ - if ((unsigned long)start_table_ptr >= flow_dma_area_end_addr) - error = -1; - else - *table_address_ptr = start_table_ptr; + /* check if we reached the end of floa tables area */ + if ((unsigned long) start_table_ptr >= flow_dma_area_end_addr) + error = -1; + else + *table_address_ptr = start_table_ptr; - return error; + return error; } /* @@ -3572,52 +3084,50 @@ static int sep_find_free_flow_dma_table_space( */ static void sep_deallocated_flow_tables(struct sep_lli_entry_t *first_table_ptr) { - /* id poiner */ - unsigned long *table_ptr; + /* id poiner */ + unsigned long *table_ptr; - /* end address of the flow dma area */ - unsigned long num_entries; + /* end address of the flow dma area */ + unsigned long num_entries; - unsigned long num_pages; + unsigned long num_pages; - /* pages ptr */ - struct page **pages_ptr; + /* pages ptr */ + struct page **pages_ptr; - /* maximum table size in words */ - struct sep_lli_entry_t *info_entry_ptr; + /* maximum table size in words */ + struct sep_lli_entry_t *info_entry_ptr; /*------------------------------- CODE ---------------------------------*/ - /* set the pointer to the first table */ - table_ptr = (unsigned long *)first_table_ptr->physical_address; + /* set the pointer to the first table */ + table_ptr = (unsigned long *) first_table_ptr->physical_address; - /* set the num of entries */ - num_entries = (first_table_ptr->block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) - & SEP_NUM_ENTRIES_MASK; + /* set the num of entries */ + num_entries = (first_table_ptr->block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) + & SEP_NUM_ENTRIES_MASK; - /* go over all the connected tables */ - while (*table_ptr != 0xffffffff) { - /* get number of pages */ - num_pages = *(table_ptr - 2); + /* go over all the connected tables */ + while (*table_ptr != 0xffffffff) { + /* get number of pages */ + num_pages = *(table_ptr - 2); - /* get the pointer to the pages */ - pages_ptr = (struct page **)(*(table_ptr - 1)); + /* get the pointer to the pages */ + pages_ptr = (struct page **) (*(table_ptr - 1)); - /* free the pages */ - sep_free_dma_pages(pages_ptr, num_pages, 1); + /* free the pages */ + sep_free_dma_pages(pages_ptr, num_pages, 1); - /* goto to the info entry */ - info_entry_ptr = ((struct sep_lli_entry_t *)table_ptr) + - (num_entries - 1); + /* goto to the info entry */ + info_entry_ptr = ((struct sep_lli_entry_t *) table_ptr) + (num_entries - 1); - table_ptr = (unsigned long *)info_entry_ptr->physical_address; - num_entries = (info_entry_ptr->block_size >> - SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK; - } + table_ptr = (unsigned long *) info_entry_ptr->physical_address; + num_entries = (info_entry_ptr->block_size >> SEP_NUM_ENTRIES_OFFSET_IN_BITS) & SEP_NUM_ENTRIES_MASK; + } - return; + return; } /* @@ -3625,93 +3135,84 @@ static void sep_deallocated_flow_tables(struct sep_lli_entry_t *first_table_ptr) */ static int sep_set_flow_id_handler(unsigned long arg) { - /* error */ - int error; + /* error */ + int error; - /* flow _id */ - unsigned long flow_id; + /* flow _id */ + unsigned long flow_id; - /* pointer to flow data structre */ - struct sep_flow_context_t *flow_data_ptr; + /* pointer to flow data structre */ + struct sep_flow_context_t *flow_data_ptr; /*---------------------- CODE -----------------------*/ - dbg("------------>SEP Driver: sep_set_flow_id_handler start\n"); + dbg("------------>SEP Driver: sep_set_flow_id_handler start\n"); - error = get_user(flow_id, - &(((struct sep_driver_set_flow_id_t *)arg)->flow_id)); - if (error) - goto end_function; + error = get_user(flow_id, &(((struct sep_driver_set_flow_id_t *) arg)->flow_id)); + if (error) + goto end_function; - /* find the flow data structure that was just used for creating new flow - - its id should be default */ - error = sep_find_flow_context(SEP_TEMP_FLOW_ID, &flow_data_ptr); - if (error) - goto end_function; + /* find the flow data structure that was just used for creating new flow + - its id should be default */ + error = sep_find_flow_context(SEP_TEMP_FLOW_ID, &flow_data_ptr); + if (error) + goto end_function; - /* set flow id */ - flow_data_ptr->flow_id = flow_id; + /* set flow id */ + flow_data_ptr->flow_id = flow_id; -end_function: + end_function: - dbg("SEP Driver:<-------- sep_set_flow_id_handler end\n"); + dbg("SEP Driver:<-------- sep_set_flow_id_handler end\n"); - return error; + return error; } /* calculates time and sets it at the predefined address */ -static int sep_set_time(unsigned long *address_ptr, - unsigned long *time_in_sec_ptr) +static int sep_set_time(unsigned long *address_ptr, unsigned long *time_in_sec_ptr) { - /* time struct */ - struct timeval time; + /* time struct */ + struct timeval time; - /* address of time in the kernel */ - unsigned long time_addr; + /* address of time in the kernel */ + unsigned long time_addr; /*------------------------ CODE --------------------------*/ - dbg("SEP Driver:--------> sep_set_time start\n"); + dbg("SEP Driver:--------> sep_set_time start\n"); - do_gettimeofday(&time); + do_gettimeofday(&time); - /* set value in the SYSTEM MEMORY offset */ - time_addr = sep_dev->message_shared_area_addr + - SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES; + /* set value in the SYSTEM MEMORY offset */ + time_addr = sep_dev->message_shared_area_addr + SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES; - *(unsigned long *)time_addr = SEP_TIME_VAL_TOKEN; - *(unsigned long *)(time_addr + 4) = time.tv_sec; + *(unsigned long *) time_addr = SEP_TIME_VAL_TOKEN; + *(unsigned long *) (time_addr + 4) = time.tv_sec; - edbg( - "SEP Driver:time.tv_sec is %lu\n", - time.tv_sec); - edbg( - "SEP Driver:time_addr is %lu\n", - time_addr); - edbg( - "SEP Driver:g_message_shared_area_addr is %lu\n", - sep_dev->message_shared_area_addr); + edbg("SEP Driver:time.tv_sec is %lu\n", time.tv_sec); + edbg("SEP Driver:time_addr is %lu\n", time_addr); + edbg("SEP Driver:g_message_shared_area_addr is %lu\n", sep_dev->message_shared_area_addr); - /* set the output parameters if needed */ - if (address_ptr) - *address_ptr = sep_shared_area_virt_to_phys(time_addr); + /* set the output parameters if needed */ + if (address_ptr) + *address_ptr = sep_shared_area_virt_to_phys(time_addr); - if (time_in_sec_ptr) - *time_in_sec_ptr = time.tv_sec; + if (time_in_sec_ptr) + *time_in_sec_ptr = time.tv_sec; - dbg("SEP Driver:<-------- sep_set_time end\n"); + dbg("SEP Driver:<-------- sep_set_time end\n"); - return 0; + return 0; } static void sep_wait_busy(struct sep_device *dev) @@ -3731,25 +3232,25 @@ static void sep_configure_dma_burst(void) #define HW_AHB_RD_WR_BURSTS_REG_ADDR 0x0E10UL - dbg("SEP Driver:<-------- sep_configure_dma_burst start \n"); + dbg("SEP Driver:<-------- sep_configure_dma_burst start \n"); - /* request access to registers from SEP */ - sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2); + /* request access to registers from SEP */ + sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2); - dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (write reg) \n"); + dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (write reg) \n"); - sep_wait_busy(sep_dev); + sep_wait_busy(sep_dev); - dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (while(revVal) wait loop) \n"); + dbg("SEP Driver:<-------- sep_configure_dma_burst finished request access to registers from SEP (while(revVal) wait loop) \n"); - /* set the DMA burst register to single burst*/ - sep_write_reg(sep_dev, HW_AHB_RD_WR_BURSTS_REG_ADDR, 0x0UL); + /* set the DMA burst register to single burst */ + sep_write_reg(sep_dev, HW_AHB_RD_WR_BURSTS_REG_ADDR, 0x0UL); - /* release the sep busy */ - sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x0UL); - sep_wait_busy(sep_dev); + /* release the sep busy */ + sep_write_reg(sep_dev, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x0UL); + sep_wait_busy(sep_dev); - dbg("SEP Driver:<-------- sep_configure_dma_burst done \n"); + dbg("SEP Driver:<-------- sep_configure_dma_burst done \n"); }