Staging: sep: first pass after indent

Again all formatting

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

2 files changed, 66 insertions, 704 deletions

diff --git a/drivers/staging/sep/sep_ext_with_pci_driver.c b/drivers/staging/sep/sep_ext_with_pci_driver.c
index 184c61f5770..d8591f59e78 100644
--- 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_tbl[] = {
 
 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(unsigned long src_cache_addr, unsigned long
 	/* 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(unsigned long shared_area_size, unsigned long
 		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(unsigned long shared_area_size, unsigned long
 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_virt(unsigned long phys_address)
 */
 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 pci_dev *pdev, const struct pci_device_id
 	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 pci_dev *pdev, const struct pci_device_id
 	sep_write_reg(sep_dev, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13)));
 
 #endif				/* SEP_DRIVER_POLLING_MODE */
-
-      end_function:
-
+end_function:
 	return error;
 }
 
diff --git a/drivers/staging/sep/sep_main_mod.c b/drivers/staging/sep/sep_main_mod.c
index 4bd3d0e0880..b2b900cc21b 100644
--- 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 long app_virt_addr, unsigned long data_s
 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_ptr, struct file *file_ptr)
 	/* 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_ptr, struct file *file_ptr)
 -------------------------------------------------------------*/
 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 *inode_ptr, struct file *file_ptr)
 -----------------------------------------------------------------*/
 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, struct vm_area_struct *vma)
 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 *filp, poll_table * wait)
 			mask |= POLLIN | POLLRDNORM;
 		}
 	}
-
 	dbg("SEP Driver:<-------- poll exit\n");
 	return mask;
 }
@@ -540,14 +515,7 @@ static unsigned int sep_poll(struct file *filp, poll_table * wait)
 
 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, struct file *filp, unsigned int cmd, u
 
 	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, struct file *filp, unsigned int cmd, u
 */
 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(void)
 
 	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(void)
 */
 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_fs(void)
 ----------------------------------------------------------------*/
 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 *dev_id)
 			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 long app_virt_addr, unsigned long data_
 {
 	/* 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 long app_virt_addr, unsigned long data_
 
 	/* 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(unsigned long app_virt_in_addr,
 {
 	/* 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(unsigned long app_virt_in_addr,
 			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(unsigned long app_virt_in_addr,
 	}
 
 	/* 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(struct sep_lli_entry_t *lli_in_array,
 {
 	/* 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(struct sep_lli_entry_t *lli_in_array,
 	/* 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(struct sep_lli_entry_t *lli_in_array,
 */
 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_max_size(struct sep_lli_entry_t *lli_in_ar
 */
 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 sep_lli_entry_t *lli_array_ptr, struct se
 	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 sep_lli_entry_t *lli_array_ptr, struct se
 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(struct sep_lli_entry_t *lli_table_ptr, un
 
 		table_count++;
 	}
-
 	dbg("SEP Driver:<-------- sep_debug_print_lli_tables end\n");
 }
 
@@ -1544,38 +1297,20 @@ static void sep_debug_print_lli_tables(struct sep_lli_entry_t *lli_table_ptr, un
 */
 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 app_virt_addr, unsigned long data_size, un
 		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 app_virt_addr, unsigned long data_size, un
 	*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 app_virt_addr, unsigned long data_size, un
 */
 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 kernel_virt_addr, unsigned long data_siz
 	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 kernel_virt_addr, unsigned long data_siz
 		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 kernel_virt_addr, unsigned long data_siz
 			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 kernel_virt_addr, unsigned long data_siz
 */
 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 **page_array_ptr, unsigned long num_pages, un
 */
 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_handler()
 
 	/* 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_handler()
 */
 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_handler(unsigned long arg)
 	/* 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_handler(unsigned long arg)
 */
 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_handler(unsigned long arg)
 		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_handler(unsigned long arg)
 */
 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_handler(unsigned long arg)
 
 	/* 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_handler(unsigned long arg)
 */
 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_handler(unsigned long arg)
 	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_handler(unsigned long arg)
 
 	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_handler(unsigned long arg)
 */
 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_handler(unsigned long arg)
 
 	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_handler(unsigned long arg)
 */
 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(unsigned long arg)
 	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(unsigned long arg)
 */
 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_handler(unsigned long arg)
 
 	/* 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_handler(unsigned long arg)
 */
 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_handler(unsigned long arg)
 	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_handler(unsigned long arg)
 */
 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_offset_handler(unsigned long arg)
 	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_offset_handler(unsigned long arg)
 */
 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 long arg)
 
 	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 long arg)
 		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 long arg)
 */
 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_handler(unsigned long arg)
 	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_handler(unsigned long arg)
 
 	/* 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_handler(unsigned long arg)
 */
 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 long arg)
 */
 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(unsigned long arg)
 
 	/* 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(unsigned long arg)
 */
 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(unsigned long arg)
 /* 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 work_struct *work)
 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(unsigned long num_virtual_buffers,
 
 	/* 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(unsigned long num_virtual_buffers,
 */
 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_table(unsigned long virt_buff_addr, unsigned
 
 	/* 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(unsigned long flow_id, struct sep_flow_context_
 */
 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_space(unsigned long **table_address_ptr)
 */
 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(struct sep_lli_entry_t *first_table_ptr)
 */
 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(unsigned long arg)
 	/* 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(unsigned long arg)
 */
 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_device *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");