From alan@lxorguk.ukuu.org.uk Fri Aug 7 16:54:05 2009 From: Alan Cox Date: Thu, 06 Aug 2009 20:46:08 +0100 Subject: Staging: sep: first pass after indent To: greg@kroah.com, mark.a.allyn@intel.com Message-ID: <20090806194602.18419.87594.stgit@localhost.localdomain> From: Alan Cox Again all formatting Signed-off-by: Alan Cox Signed-off-by: Greg Kroah-Hartman --- drivers/staging/sep/sep_ext_with_pci_driver.c | 32 - drivers/staging/sep/sep_main_mod.c | 738 ++------------------------ 2 files changed, 66 insertions(+), 704 deletions(-) --- a/drivers/staging/sep/sep_ext_with_pci_driver.c +++ b/drivers/staging/sep/sep_ext_with_pci_driver.c @@ -116,8 +116,6 @@ static struct pci_device_id sep_pci_id_t MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl); - - /* field for registering driver to PCI device */ static struct pci_driver sep_pci_driver = { .name = "sep_sec_driver", @@ -125,7 +123,6 @@ static struct pci_driver sep_pci_driver .probe = sep_probe }; - /* This functions locks the area of the resisnd and cache sep code */ @@ -134,7 +131,6 @@ void sep_lock_cache_resident_area(void) return; } - /* This functions copies the cache and resident from their source location into destination memory, which is external to Linux VM and is given as @@ -142,12 +138,8 @@ void sep_lock_cache_resident_area(void) */ 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; - - /* cahce address in user space */ unsigned long cache_addr; - const struct firmware *fw; char *cache_name = "cache.image.bin"; @@ -222,9 +214,7 @@ int sep_copy_cache_resident_to_area(unsi /* physical addresses */ *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; } @@ -246,15 +236,12 @@ int sep_map_and_alloc_shared_area(unsign edbg("sep_driver:shared memory kmalloc failed\n"); return -1; } - /* FIXME */ sep_dev->shared_physical_address = __pa(sep_dev->shared_virtual_address); - // shared_physical_address = 0xda00000; - + /* shared_physical_address = 0xda00000; */ *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); @@ -273,7 +260,6 @@ int sep_map_and_alloc_shared_area(unsign 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); - return; } /* @@ -307,15 +293,9 @@ unsigned long sep_shared_area_phys_to_vi */ static int __devinit sep_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { - /* error */ - int error; - - /*------------------------ - CODE - ---------------------------*/ + int error = 0; edbg("Sep pci probe starting\n"); - error = 0; /* enable the device */ error = pci_enable_device(pdev); @@ -372,10 +352,8 @@ static int __devinit sep_probe(struct pc 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_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"); @@ -405,9 +383,7 @@ static int __devinit sep_probe(struct pc sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13))); #endif /* SEP_DRIVER_POLLING_MODE */ - - end_function: - +end_function: return error; } --- a/drivers/staging/sep/sep_main_mod.c +++ b/drivers/staging/sep/sep_main_mod.c @@ -301,7 +301,6 @@ static int sep_lock_user_pages(unsigned int sep_lock() { mutex_lock(&sep_mutex); - return 0; } @@ -361,13 +360,8 @@ void sep_driver_poll() ------------------------------------------------------------------------*/ static int sep_open(struct inode *inode_ptr, struct file *file_ptr) { - /* return value */ int error; - /*----------------- - CODE - ---------------------*/ - dbg("SEP Driver:--------> open start\n"); error = 0; @@ -389,10 +383,8 @@ static int sep_open(struct inode *inode_ /* release data pool allocations */ sep_dev->data_pool_bytes_allocated = 0; - end_function: - +end_function: dbg("SEP Driver:<-------- open end\n"); - return error; } @@ -404,10 +396,6 @@ static int sep_open(struct inode *inode_ -------------------------------------------------------------*/ static int sep_release(struct inode *inode_ptr, struct file *file_ptr) { - /*----------------- - CODE - ---------------------*/ - dbg("----------->SEP Driver: sep_release start\n"); #if 0 /*!SEP_DRIVER_POLLING_MODE */ @@ -435,13 +423,8 @@ static int sep_release(struct inode *ino -----------------------------------------------------------------*/ static int sep_mmap(struct file *filp, struct vm_area_struct *vma) { - /* physical addr */ unsigned long phys_addr; - /*----------------------- - CODE - -------------------------*/ - dbg("-------->SEP Driver: mmap start\n"); /* check that the size of the mapped range is as the size of the message @@ -480,15 +463,8 @@ static int sep_mmap(struct file *filp, s static unsigned int sep_poll(struct file *filp, poll_table * wait) { unsigned long count; - unsigned int mask = 0; - - /* flow id */ - unsigned long retVal = 0; - - /*---------------------------------------------- - CODE - -------------------------------------------------*/ + unsigned long retVal = 0; /* flow id */ dbg("---------->SEP Driver poll: start\n"); @@ -532,7 +508,6 @@ static unsigned int sep_poll(struct file mask |= POLLIN | POLLRDNORM; } } - dbg("SEP Driver:<-------- poll exit\n"); return mask; } @@ -540,14 +515,7 @@ static unsigned int sep_poll(struct file static int sep_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) { - - /* error */ - int error; - - /*------------------------ - CODE - ------------------------*/ - error = 0; + int error = 0; dbg("------------>SEP Driver: ioctl start\n"); @@ -559,140 +527,83 @@ static int sep_ioctl(struct inode *inode switch (cmd) { case SEP_IOCSENDSEPCOMMAND: - /* send command to SEP */ sep_send_command_handler(); - edbg("SEP Driver: after sep_send_command_handler\n"); - break; - case SEP_IOCSENDSEPRPLYCOMMAND: - /* send reply command to SEP */ sep_send_reply_command_handler(); - break; - case SEP_IOCALLOCDATAPOLL: - /* allocate data pool */ error = sep_allocate_data_pool_memory_handler(arg); - break; - case SEP_IOCWRITEDATAPOLL: - /* write data into memory pool */ error = sep_write_into_data_pool_handler(arg); - break; - case SEP_IOCREADDATAPOLL: - /* read data from data pool into application memory */ error = sep_read_from_data_pool_handler(arg); - break; - case SEP_IOCCREATESYMDMATABLE: - /* create dma table for synhronic operation */ error = sep_create_sync_dma_tables_handler(arg); - break; - case SEP_IOCCREATEFLOWDMATABLE: - /* create flow dma tables */ error = sep_create_flow_dma_tables_handler(arg); - break; - case SEP_IOCFREEDMATABLEDATA: - /* free the pages */ error = sep_free_dma_table_data_handler(); - break; - case SEP_IOCSETFLOWID: - /* set flow id */ error = sep_set_flow_id_handler(arg); - break; - case SEP_IOCADDFLOWTABLE: - /* add tables to the dynamic flow */ error = sep_add_flow_tables_handler(arg); - break; - case SEP_IOCADDFLOWMESSAGE: - /* add message of add tables to flow */ error = sep_add_flow_tables_message_handler(arg); - break; - case SEP_IOCSEPSTART: - /* start command to sep */ error = sep_start_handler(); break; - case SEP_IOCSEPINIT: - /* init command to sep */ error = sep_init_handler(arg); break; - case SEP_IOCSETAPIMODE: - /* set non- blocking mode */ error = sep_set_api_mode_handler(arg); - break; - case SEP_IOCGETSTATICPOOLADDR: - /* get the physical and virtual addresses of the static pool */ error = sep_get_static_pool_addr_handler(arg); - break; - case SEP_IOCENDTRANSACTION: - error = sep_end_transaction_handler(arg); - break; - case SEP_IOCREALLOCCACHERES: - error = sep_realloc_cache_resident_handler(arg); - break; - case SEP_IOCGETMAPPEDADDROFFSET: - error = sep_get_physical_mapped_offset_handler(arg); - break; case SEP_IOCGETIME: - error = sep_get_time_handler(arg); - break; - default: error = -ENOTTY; break; } - dbg("SEP Driver:<-------- ioctl end\n"); - return error; } @@ -702,14 +613,7 @@ static int sep_ioctl(struct inode *inode */ static int sep_register_driver_to_fs(void) { - /* return value */ - int ret_val; - - /*--------------------- - CODE - -----------------------*/ - - ret_val = alloc_chrdev_region(&g_sep_device_number, 0, 1, "sep_sec_driver"); + int 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; @@ -737,14 +641,13 @@ static int sep_register_driver_to_fs(voi goto end_function; - end_function_unregister_devnum: +end_function_unregister_devnum: /* unregister dev numbers */ unregister_chrdev_region(g_sep_device_number, 1); - end_function: - - return ret_val; +end_function: + return ret_val; } /* @@ -752,12 +655,7 @@ static int sep_register_driver_to_fs(voi */ static void sep_unregister_driver_from_fs(void) { - /*------------------- - CODE - ---------------------*/ - cdev_del(&g_sep_cdev); - /* unregister dev numbers */ unregister_chrdev_region(g_sep_device_number, 1); } @@ -767,65 +665,48 @@ static void sep_unregister_driver_from_f ----------------------------------------------------------------*/ static int __init sep_init(void) { - /* return value */ - int ret_val; - - /* counter */ + int ret_val = 0; int counter; - - /* size to of memory for allocation */ - int size; - - /*------------------------ - CODE - ------------------------*/ + int size; /* size of memory for allocation */ dbg("SEP Driver:-------->Init start\n"); edbg("sep->shared_area_addr = %lx\n", (unsigned long) &sep_dev->shared_area_addr); - ret_val = 0; - -/* transaction counter that coordinates the transactions between SEP + /* transaction counter that coordinates the transactions between SEP and HOST */ sep_dev->host_to_sep_send_counter = 0; -/* counter for the messages from sep */ + /* counter for the messages from sep */ sep_dev->sep_to_host_reply_counter = 0; -/* counter for the number of bytes allocated in the pool -for the current transaction */ + /* counter for the number of bytes allocated in the pool + for the current transaction */ sep_dev->data_pool_bytes_allocated = 0; /* 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; } - /* 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; } - /* 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); #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); @@ -840,7 +721,6 @@ for the current transaction */ 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; @@ -851,82 +731,53 @@ for the current transaction */ edbg("sep_driver:flow queue creation failed\n"); goto end_function_deallocate_sep_shared_area; } - 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; - /* load the rom code */ sep_load_rom_code(); - goto end_function; - - end_function_unregister_from_fs: - +end_function_unregister_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); - - end_function_unmap_io_memory: - +end_function_unmap_io_memory: 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); - - end_function: - +end_function: dbg("SEP Driver:<-------- Init end\n"); - return ret_val; } - - /*------------------------------------------------------------- exit function --------------------------------------------------------------*/ static void __exit sep_exit(void) { - /* size */ int size; - /*----------------------------- - CODE - --------------------------------*/ - dbg("SEP Driver:--------> Exit start\n"); /* 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; - - /* 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"); - iounmap((void *) sep_dev->reg_base_address); - edbg("SEP Driver: iounmap \n"); - /* 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"); - dbg("SEP Driver:<-------- Exit end\n"); } @@ -936,25 +787,12 @@ static void __exit sep_exit(void) */ irqreturn_t sep_inthandler(int irq, void *dev_id) { - /* int error */ irqreturn_t int_error; - - /* error */ unsigned long error; - - /* reg value */ unsigned long reg_val; - - /* flow id */ unsigned long flow_id; - - /* 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 */ @@ -989,14 +827,10 @@ irqreturn_t sep_inthandler(int irq, void 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); - - end_function: - +end_function: return int_error; } @@ -1009,35 +843,22 @@ int sep_prepare_input_dma_table(unsigned { /* 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; - /* 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; - /* lli table pointer */ struct sep_lli_entry_t *in_lli_table_ptr; - /* the total data in one table */ unsigned long table_data_size; - /* number of entries in lli table */ unsigned long num_entries_in_table; - /* next table address */ unsigned long lli_table_alloc_addr; - - /* 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); @@ -1125,11 +946,8 @@ int sep_prepare_input_dma_table(unsigned /* the array of the pages */ kfree(lli_array_ptr); - - end_function: - +end_function: dbg("SEP Driver:<-------- sep_prepare_input_dma_table end\n"); - return 0; } @@ -1147,22 +965,12 @@ int sep_prepare_input_output_dma_table(u { /* 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; - - /* result */ - int result; - - - /*------------------------ - CODE - --------------------------*/ + int result = 0; dbg("SEP Driver:--------> sep_prepare_input_output_dma_table start\n"); - result = 0; - /* initialize the pages pointers */ sep_dev->in_page_array = 0; sep_dev->out_page_array = 0; @@ -1197,8 +1005,6 @@ int sep_prepare_input_output_dma_table(u 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); @@ -1212,24 +1018,15 @@ int sep_prepare_input_output_dma_table(u } /* 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); - - - end_function_with_error2: - +end_function_with_error2: kfree(lli_out_array); - - end_function_with_error1: - +end_function_with_error1: kfree(lli_in_array); - - end_function: - +end_function: dbg("SEP Driver:<-------- sep_prepare_input_output_dma_table end result = %d\n", (int) result); - return result; } @@ -1247,47 +1044,31 @@ int sep_construct_dma_tables_from_lli(st { /* 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; - /* 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_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_out_array */ unsigned long current_out_entry; - /* max size of the input table */ unsigned long in_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; - /* 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 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 */ @@ -1369,13 +1150,10 @@ int sep_construct_dma_tables_from_lli(st /* 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; } @@ -1386,23 +1164,13 @@ int sep_construct_dma_tables_from_lli(st */ 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; - - /* counter */ + unsigned long table_data_size = 0; unsigned long counter; - /*--------------------- - CODE - ----------------------*/ - - 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; - return table_data_size; } @@ -1412,16 +1180,10 @@ unsigned long sep_calculate_lli_table_ma */ 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; - /* 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 */ @@ -1475,15 +1237,11 @@ static void sep_build_lli_table(struct s 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; } @@ -1494,11 +1252,7 @@ static void sep_build_lli_table(struct s 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 entries_count; - /*----------------------------- - CODE - -------------------------------*/ dbg("SEP Driver:--------> sep_debug_print_lli_tables start\n"); @@ -1532,7 +1286,6 @@ static void sep_debug_print_lli_tables(s table_count++; } - dbg("SEP Driver:<-------- sep_debug_print_lli_tables end\n"); } @@ -1544,38 +1297,20 @@ static void sep_debug_print_lli_tables(s */ 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; - + int error = 0; /* 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 range in pages */ unsigned long num_pages; - - /* array of pointers ot page */ struct page **page_array; - - /* array of lli */ struct sep_lli_entry_t *lli_array; - - /* count */ unsigned long count; - - /* 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; @@ -1639,8 +1374,7 @@ int sep_lock_user_pages(unsigned long ap 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); + 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 */ @@ -1664,27 +1398,17 @@ int sep_lock_user_pages(unsigned long ap *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_error2: /* 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 */ +end_function_with_error1: kfree(page_array); - - end_function: - +end_function: dbg("SEP Driver:<-------- sep_lock_user_pages end\n"); - return 0; } @@ -1695,36 +1419,20 @@ int sep_lock_user_pages(unsigned long ap */ 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; - + int error = 0; /* 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 range in pages */ unsigned long num_pages; - - /* array of lli */ struct sep_lli_entry_t *lli_array; - /* next kernel address to map */ unsigned long next_kernel_address; - - /* 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; @@ -1739,7 +1447,6 @@ int sep_lock_kernel_pages(unsigned long 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; } @@ -1765,9 +1472,7 @@ int sep_lock_kernel_pages(unsigned long 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); - + 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; } @@ -1785,20 +1490,14 @@ int sep_lock_kernel_pages(unsigned long 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); + 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: - +end_function: dbg("SEP Driver:<-------- sep_lock_kernel_pages end\n"); - return 0; } @@ -1808,13 +1507,8 @@ int sep_lock_kernel_pages(unsigned long */ int sep_free_dma_pages(struct page **page_array_ptr, unsigned long num_pages, unsigned long dirtyFlag) { - /* count */ unsigned long count; - /*------------------- - CODE - ---------------------*/ - if (dirtyFlag) { for (count = 0; count < num_pages; count++) { /* the out array was written, therefore the data was changed */ @@ -1842,11 +1536,9 @@ int sep_free_dma_pages(struct page **pag */ static void sep_send_command_handler() { - unsigned long count; dbg("SEP Driver:--------> sep_send_command_handler start\n"); - sep_set_time(0, 0); /* flash cache */ @@ -1857,12 +1549,9 @@ static void sep_send_command_handler() /* 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); - dbg("SEP Driver:<-------- sep_send_command_handler end\n"); - return; } @@ -1878,25 +1567,16 @@ static void sep_send_reply_command_handl /* 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))); - - /* 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); - /* update both counters */ sep_dev->host_to_sep_send_counter++; - sep_dev->sep_to_host_reply_counter++; - dbg("SEP Driver:<-------- sep_send_reply_command_handler end\n"); - - return; } @@ -1910,19 +1590,11 @@ static void sep_send_reply_command_handl */ static int sep_allocate_data_pool_memory_handler(unsigned long arg) { - /* error */ int error; - - /* command paramaters */ struct sep_driver_alloc_t command_args; - /*------------------------- - CODE - ----------------------------*/ - 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; @@ -1945,10 +1617,8 @@ static int sep_allocate_data_pool_memory /* set the allocation */ sep_dev->data_pool_bytes_allocated += command_args.num_bytes; - end_function: - +end_function: dbg("SEP Driver:<-------- sep_allocate_data_pool_memory_handler end\n"); - return error; } @@ -1957,25 +1627,12 @@ static int sep_allocate_data_pool_memory */ static int sep_write_into_data_pool_handler(unsigned long arg) { - /* error */ int error; - - /* virtual address */ unsigned long virt_address; - - /* application in address */ unsigned long app_in_address; - - /* number of bytes */ unsigned long num_bytes; - - /* address of the data pool */ unsigned long data_pool_area_addr; - /*-------------------------- - CODE - -----------------------------*/ - dbg("SEP Driver:--------> sep_write_into_data_pool_handler start\n"); /* get the application address */ @@ -2002,14 +1659,10 @@ static int sep_write_into_data_pool_hand error = -ENOTTY; goto end_function; } - /* 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"); - return error; } @@ -2018,25 +1671,14 @@ static int sep_write_into_data_pool_hand */ static int sep_read_from_data_pool_handler(unsigned long arg) { - /* error */ int error; - /* virtual address of dest application buffer */ unsigned long app_out_address; - /* virtual address of the data pool */ unsigned long virt_address; - - /* number bytes */ unsigned long num_bytes; - - /* address of the data pool */ unsigned long data_pool_area_addr; - /*------------------------ - CODE - -----------------------------*/ - dbg("SEP Driver:--------> sep_read_from_data_pool_handler start\n"); /* get the application address */ @@ -2065,11 +1707,8 @@ static int sep_read_from_data_pool_handl /* 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"); - return error; } @@ -2080,16 +1719,10 @@ static int sep_read_from_data_pool_handl */ static int sep_create_sync_dma_tables_handler(unsigned long arg) { - /* error */ int error; - /* command arguments */ struct sep_driver_build_sync_table_t command_args; - /*------------------------ - CODE - --------------------------*/ - 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)); @@ -2101,7 +1734,6 @@ static int sep_create_sync_dma_tables_ha 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 */ @@ -2118,14 +1750,10 @@ static int sep_create_sync_dma_tables_ha if (error) goto end_function; - /* copy to user */ error = copy_to_user((void *) arg, (void *) &command_args, sizeof(struct sep_driver_build_sync_table_t)); - - end_function: - +end_function: dbg("SEP Driver:<-------- sep_create_sync_dma_tables_handler end\n"); - return error; } @@ -2134,10 +1762,6 @@ static int sep_create_sync_dma_tables_ha */ int sep_free_dma_table_data_handler() { - /*------------------------- - CODE - -----------------------------*/ - dbg("SEP Driver:--------> sep_free_dma_table_data_handler start\n"); /* free input pages array */ @@ -2152,10 +1776,7 @@ int sep_free_dma_table_data_handler() 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"); - return 0; } @@ -2164,28 +1785,17 @@ int sep_free_dma_table_data_handler() */ static int sep_create_flow_dma_tables_handler(unsigned long arg) { - /* error */ int error; - - /* command arguments */ struct sep_driver_build_flow_table_t command_args; - /* first table - output */ struct sep_lli_entry_t first_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 flow data strucutre */ struct sep_flow_context_t *flow_context_ptr; - /*------------------------ - CODE - --------------------------*/ - dbg("SEP Driver:--------> sep_create_flow_dma_tables_handler start\n"); /* init variables */ @@ -2232,17 +1842,12 @@ static int sep_create_flow_dma_tables_ha goto end_function; - end_function_with_error: - +end_function_with_error: /* 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"); - return error; - } /* @@ -2250,31 +1855,17 @@ static int sep_create_flow_dma_tables_ha */ static int sep_add_flow_tables_handler(unsigned long arg) { - /* error */ int error; - - /* number of entries */ unsigned long num_entries; - - /* 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; - /* first dma table data */ struct sep_lli_entry_t first_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; - /*-------------------------- - CODE - ----------------------------*/ - dbg("SEP Driver:--------> sep_add_flow_tables_handler start\n"); /* get input parameters */ @@ -2354,15 +1945,11 @@ static int sep_add_flow_tables_handler(u 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); - - end_function: - +end_function: dbg("SEP Driver:<-------- sep_add_flow_tables_handler end\n"); - return error; } @@ -2371,19 +1958,10 @@ static int sep_add_flow_tables_handler(u */ static int sep_add_flow_tables_message_handler(unsigned long arg) { - /* error */ int error; - - /* arguments */ struct sep_driver_add_message_t command_args; - - /* flow context */ struct sep_flow_context_t *flow_context_ptr; - /*---------------------------- - CODE - ------------------------------*/ - 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)); @@ -2403,14 +1981,9 @@ static int sep_add_flow_tables_message_h /* 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); - - - end_function: - +end_function: dbg("SEP Driver:<-------- sep_add_flow_tables_message_handler end\n"); - return error; } @@ -2420,16 +1993,9 @@ static int sep_add_flow_tables_message_h */ static int sep_get_static_pool_addr_handler(unsigned long arg) { - /* error */ int error; - - /* command arguments */ struct sep_driver_static_pool_addr_t command_args; - /*----------------------------- - CODE - ------------------------------*/ - dbg("SEP Driver:--------> sep_get_static_pool_addr_handler start\n"); /*prepare the output parameters in the struct */ @@ -2442,11 +2008,8 @@ static int sep_get_static_pool_addr_hand 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"); - return error; } @@ -2456,16 +2019,9 @@ static int sep_get_static_pool_addr_hand */ static int sep_get_physical_mapped_offset_handler(unsigned long arg) { - /* error */ int error; - - /* command arguments */ struct sep_driver_get_mapped_offset_t command_args; - /*----------------------------- - CODE - ------------------------------*/ - 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)); @@ -2486,11 +2042,8 @@ static int sep_get_physical_mapped_offse 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"); - return error; } @@ -2500,24 +2053,15 @@ static int sep_get_physical_mapped_offse */ static int sep_start_handler(void) { - /* reg val */ unsigned long reg_val; - - /* error */ - unsigned long error; - - /*----------------------------- - CODE - ------------------------------*/ + unsigned long error = 0; dbg("SEP Driver:--------> sep_start_handler start\n"); - error = 0; - /* wait in polling for message from SEP */ - do { + do reg_val = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR); - } while (!reg_val); + while (!reg_val); /* check the value */ if (reg_val == 0x1) { @@ -2525,11 +2069,8 @@ static int sep_start_handler(void) 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"); - return error; } @@ -2538,30 +2079,14 @@ static int sep_start_handler(void) */ static int sep_init_handler(unsigned long arg) { - /* word from message */ unsigned long message_word; - - /* message ptr */ unsigned long *message_ptr; - - /* command arguments */ struct sep_driver_init_t command_args; - - /* counter */ unsigned long counter; - - /* error */ unsigned long error; - - /* reg val */ unsigned long reg_val; - /*------------------- - CODE - ---------------------*/ - dbg("SEP Driver:--------> sep_init_handler start\n"); - error = 0; error = copy_from_user(&command_args, (void *) arg, sizeof(struct sep_driver_init_t)); @@ -2583,24 +2108,19 @@ static int sep_init_handler(unsigned lon 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); - edbg("SEP Driver:message_word is %lu\n", message_word); - /* wait for write complete */ sep_wait_sram_write(sep_dev); } - 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); - do { + do reg_val = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR3_REG_ADDR); - } while (!(reg_val & 0xFFFFFFFD)); + while (!(reg_val & 0xFFFFFFFD)); dbg("SEP Driver:--------> sep_init_handler - finished waiting for reg_val & 0xFFFFFFFD \n"); @@ -2616,11 +2136,8 @@ static int sep_init_handler(unsigned lon edbg("SEP Driver:error is %lu\n", error); goto end_function; } - - end_function: - +end_function: dbg("SEP Driver:<-------- sep_init_handler end\n"); - return error; } @@ -2630,22 +2147,11 @@ static int sep_init_handler(unsigned lon */ static int sep_realloc_cache_resident_handler(unsigned long arg) { - /* error */ int error; - - /* physical cache addr */ unsigned long phys_cache_address; - - /* physical resident addr */ unsigned long phys_resident_address; - - /* 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) @@ -2672,7 +2178,6 @@ static int sep_realloc_cache_resident_ha 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; @@ -2683,9 +2188,7 @@ static int sep_realloc_cache_resident_ha /* 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; } @@ -2694,21 +2197,11 @@ static int sep_realloc_cache_resident_ha */ static int sep_get_time_handler(unsigned long arg) { - /* error */ int error; - - /* command arguments */ struct sep_driver_get_time_t command_args; - /*------------------------ - CODE - --------------------------*/ - 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 error; } @@ -2718,16 +2211,9 @@ static int sep_get_time_handler(unsigned */ static int sep_set_api_mode_handler(unsigned long arg) { - /* error */ int error; - - /* flag */ unsigned long mode_flag; - /*---------------------------- - CODE - -----------------------------*/ - dbg("SEP Driver:--------> sep_set_api_mode_handler start\n"); error = get_user(mode_flag, &(((struct sep_driver_set_api_mode_t *) arg)->mode)); @@ -2736,12 +2222,8 @@ static int sep_set_api_mode_handler(unsi /* 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"); - return error; } @@ -2750,10 +2232,6 @@ static int sep_set_api_mode_handler(unsi */ static int sep_end_transaction_handler(unsigned long arg) { - /*---------------------------- - CODE - -----------------------------*/ - dbg("SEP Driver:--------> sep_end_transaction_handler start\n"); #if 0 /*!SEP_DRIVER_POLLING_MODE */ @@ -2775,11 +2253,7 @@ static int sep_end_transaction_handler(u /* handler for flow done interrupt */ static void sep_flow_done_handler(struct work_struct *work) { - /* flow context_ptr */ struct sep_flow_context_t *flow_data_ptr; - /*------------------------- - CODE - ---------------------------*/ /* obtain the mutex */ mutex_lock(&sep_mutex); @@ -2813,31 +2287,14 @@ static void sep_flow_done_handler(struct 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) { - /* error */ int error; - - /* virtaul address of one buffer */ unsigned long virt_buff_addr; - - /* virtual size of one buffer */ unsigned long virt_buff_size; - - /* table data for each created table */ struct sep_lli_entry_t table_data; - - /* info entry */ struct sep_lli_entry_t *info_entry_ptr; - - /* prevouis info entry */ struct sep_lli_entry_t *prev_info_entry_ptr; - - /* counter */ unsigned long i; - /*------------------------------- - CODE - ----------------------------------*/ - /* init vars */ error = 0; prev_info_entry_ptr = 0; @@ -2886,9 +2343,7 @@ static int sep_prepare_flow_dma_tables(u /* set the last table data */ *last_table_data_ptr = table_data; - - end_function: - +end_function: return error; } @@ -2899,34 +2354,18 @@ static int sep_prepare_flow_dma_tables(u */ 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; - /* the range in pages */ unsigned long lli_array_size; - - /* 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; - - /* address of the dma table */ unsigned long *start_dma_table_ptr; - /* total table data counter */ unsigned long dma_table_data_count; - - /* pointer that will keep the pointer t the pages of the virtual buffer */ + /* pointer that will keep the pointer to the pages of the virtual buffer */ struct page **page_array_ptr; - - /* 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) @@ -2983,30 +2422,19 @@ static int sep_prepare_one_flow_dma_tabl /* the array of the lli entries */ kfree(lli_array); - - end_function: - +end_function: return error; } /* This function returns pointer to the flow data structure - that conatins the given id + that contains the given id */ static int sep_find_flow_context(unsigned long flow_id, struct sep_flow_context_t **flow_data_ptr) { - /* count */ unsigned long count; - - /* error */ - int error; - - /*----------------------- - CODE - ---------------------------*/ - - error = 0; + int error = 0; /* always search for flow with id default first - in case we @@ -3032,27 +2460,14 @@ static int sep_find_flow_context(unsigne */ static int sep_find_free_flow_dma_table_space(unsigned long **table_address_ptr) { - /* error */ - int error; - + int error = 0; /* 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; - - /* 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; - /*--------------------- - CODE - -----------------------*/ - - 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; @@ -3084,24 +2499,15 @@ static int sep_find_free_flow_dma_table_ */ static void sep_deallocated_flow_tables(struct sep_lli_entry_t *first_table_ptr) { - /* id poiner */ + /* id pointer */ unsigned long *table_ptr; - /* end address of the flow dma area */ unsigned long num_entries; - unsigned long num_pages; - - /* pages ptr */ struct page **pages_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; @@ -3135,19 +2541,10 @@ static void sep_deallocated_flow_tables( */ static int sep_set_flow_id_handler(unsigned long arg) { - /* error */ int error; - - /* flow _id */ unsigned long flow_id; - - /* pointer to flow data structre */ struct sep_flow_context_t *flow_data_ptr; - /*---------------------- - CODE - -----------------------*/ - 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)); @@ -3163,11 +2560,8 @@ static int sep_set_flow_id_handler(unsig /* set flow id */ flow_data_ptr->flow_id = flow_id; - end_function: - +end_function: dbg("SEP Driver:<-------- sep_set_flow_id_handler end\n"); - - return error; } @@ -3177,20 +2571,13 @@ static int sep_set_flow_id_handler(unsig */ static int sep_set_time(unsigned long *address_ptr, unsigned long *time_in_sec_ptr) { - /* time struct */ struct timeval time; - /* address of time in the kernel */ unsigned long time_addr; - /*------------------------ - CODE - --------------------------*/ - dbg("SEP Driver:--------> sep_set_time start\n"); - do_gettimeofday(&time); /* set value in the SYSTEM MEMORY offset */ @@ -3229,7 +2616,6 @@ static void sep_wait_busy(struct sep_dev */ 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");