Staging: sep: clean up some of the obvious sillies
authorAlan Cox <alan@linux.intel.com>
Wed, 24 Nov 2010 19:38:02 +0000 (19:38 +0000)
committerGreg Kroah-Hartman <gregkh@suse.de>
Mon, 29 Nov 2010 19:17:28 +0000 (11:17 -0800)
Various assignments are done but not used
dev_dbg formatting is a bit weird and wraps when not needed
Take out some of the blank lines and reformat a bit to reduce view size
Remove some comments that are obvious
Fix else formatting
Remove some user triggerable dev_warns
Fix copy_from_user error return cases (-EFAULT not bytes copied)

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
drivers/staging/sep/sep_driver.c

index 4a0bb43..f576285 100644 (file)
@@ -83,15 +83,13 @@ static struct sep_device *sep_dev;
  *     This functions copies the cache and resident from their source
  *     location into destination shared memory.
  */
-
 static int sep_load_firmware(struct sep_device *sep)
 {
        const struct firmware *fw;
        char *cache_name = "cache.image.bin";
        char *res_name = "resident.image.bin";
        char *extapp_name = "extapp.image.bin";
-
-       int error = 0;
+       int error ;
        unsigned int work1, work2, work3;
 
        /* set addresses and load resident */
@@ -110,7 +108,7 @@ static int sep_load_firmware(struct sep_device *sep)
 
        dev_dbg(&sep->pdev->dev, "resident virtual is %p\n",
                sep->resident_addr);
-       dev_dbg(&sep->pdev->dev, "residnet bus is %lx\n",
+       dev_dbg(&sep->pdev->dev, "resident bus is %lx\n",
                (unsigned long)sep->resident_bus);
        dev_dbg(&sep->pdev->dev, "resident size is %08x\n",
                sep->resident_size);
@@ -134,7 +132,7 @@ static int sep_load_firmware(struct sep_device *sep)
 
        error = request_firmware(&fw, cache_name, &sep->pdev->dev);
        if (error) {
-               dev_warn(&sep->pdev->dev, "cant request cache fw\n");
+               dev_warn(&sep->pdev->dev, "Unable to request cache firmware\n");
                return error;
        }
 
@@ -155,7 +153,7 @@ static int sep_load_firmware(struct sep_device *sep)
 
        error = request_firmware(&fw, extapp_name, &sep->pdev->dev);
        if (error) {
-               dev_warn(&sep->pdev->dev, "cant request extapp fw\n");
+               dev_warn(&sep->pdev->dev, "Unable to request extapp firmware\n");
                return error;
        }
 
@@ -181,15 +179,13 @@ MODULE_FIRMWARE("sep/extapp.image.bin");
  *     sep_dump_message - dump the message that is pending
  *     @sep: sep device
  */
-
 static void sep_dump_message(struct sep_device *sep)
 {
        int count;
        u32 *p = sep->shared_addr;
        for (count = 0; count < 12 * 4; count += 4)
-               dev_dbg(&sep->pdev->dev,
-                       "Word %d of the message is %x\n",
-                       count, *p++);
+               dev_dbg(&sep->pdev->dev, "Word %d of the message is %x\n",
+                                                               count, *p++);
 }
 
 /**
@@ -197,7 +193,6 @@ static void sep_dump_message(struct sep_device *sep)
  *     @sep: security processor
  *     @size: size of shared area
  */
-
 static int sep_map_and_alloc_shared_area(struct sep_device *sep)
 {
        sep->shared_addr = dma_alloc_coherent(&sep->pdev->dev,
@@ -211,8 +206,8 @@ static int sep_map_and_alloc_shared_area(struct sep_device *sep)
        }
        dev_dbg(&sep->pdev->dev,
                "sep: shared_addr %x bytes @%p (bus %llx)\n",
-               sep->shared_size, sep->shared_addr,
-                       (unsigned long long)sep->shared_bus);
+                               sep->shared_size, sep->shared_addr,
+                               (unsigned long long)sep->shared_bus);
        return 0;
 }
 
@@ -235,7 +230,6 @@ static void sep_unmap_and_free_shared_area(struct sep_device *sep)
  *     Returns virtual address inside the shared area according
  *     to the bus address.
  */
-
 static void *sep_shared_bus_to_virt(struct sep_device *sep,
                                                dma_addr_t bus_address)
 {
@@ -249,11 +243,9 @@ static void *sep_shared_bus_to_virt(struct sep_device *sep,
  *
  *     Called when the user opens the singleton device interface
  */
-
 static int sep_singleton_open(struct inode *inode_ptr, struct file *file_ptr)
 {
        int error = 0;
-
        struct sep_device *sep;
 
        /*
@@ -290,7 +282,6 @@ end_function:
  *
  *     Returns zero on success otherwise an error code.
  */
-
 static int sep_open(struct inode *inode, struct file *filp)
 {
        struct sep_device *sep;
@@ -317,16 +308,13 @@ static int sep_open(struct inode *inode, struct file *filp)
  *     multiple simultaenous opens that means this method is called when the
  *     final reference to the open handle is dropped.
  */
-
 static int sep_singleton_release(struct inode *inode, struct file *filp)
 {
        struct sep_device *sep = filp->private_data;
 
        dev_dbg(&sep->pdev->dev, "Singleton release for pid %d\n",
-               current->pid);
-
+                                                       current->pid);
        clear_bit(0, &sep->singleton_access_flag);
-
        return 0;
 }
 
@@ -340,14 +328,11 @@ static int sep_singleton_release(struct inode *inode, struct file *filp)
  *
  *     Returns zero on success otherwise an error code.
  */
-
 static int sep_request_daemon_open(struct inode *inode, struct file *filp)
 {
-       struct sep_device *sep;
-
+       struct sep_device *sep = sep_dev;
        int error = 0;
 
-       sep = sep_dev;
        filp->private_data = sep;
 
        dev_dbg(&sep->pdev->dev, "Request daemon open for pid %d\n",
@@ -355,13 +340,8 @@ static int sep_request_daemon_open(struct inode *inode, struct file *filp)
 
        /* There is supposed to be only one request daemon */
        dev_dbg(&sep->pdev->dev, "calling test and set for req_dmon open 0\n");
-       if (test_and_set_bit(0, &sep->request_daemon_open)) {
+       if (test_and_set_bit(0, &sep->request_daemon_open))
                error = -EBUSY;
-               goto end_function;
-       }
-
-end_function:
-
        return error;
 }
 
@@ -372,7 +352,6 @@ end_function:
  *
  *     Called on the final close of a SEP daemon.
  */
-
 static int sep_request_daemon_release(struct inode *inode, struct file *filp)
 {
        struct sep_device *sep = filp->private_data;
@@ -382,7 +361,6 @@ static int sep_request_daemon_release(struct inode *inode, struct file *filp)
 
        /* clear the request_daemon_open flag */
        clear_bit(0, &sep->request_daemon_open);
-
        return 0;
 }
 
@@ -395,15 +373,11 @@ static int sep_request_daemon_release(struct inode *inode, struct file *filp)
  */
 static int sep_req_daemon_send_reply_command_handler(struct sep_device *sep)
 {
-       int error = 0;
-
        unsigned long lck_flags;
 
        dev_dbg(&sep->pdev->dev,
                "sep_req_daemon_send_reply_command_handler start\n");
 
-       error = 0;
-
        sep_dump_message(sep);
 
        /* counters are lockable region */
@@ -426,7 +400,7 @@ static int sep_req_daemon_send_reply_command_handler(struct sep_device *sep)
        dev_dbg(&sep->pdev->dev,
                "sep_req_daemon_send_reply_command_handler end\n");
 
-       return error;
+       return 0;
 }
 
 
@@ -436,80 +410,56 @@ static int sep_req_daemon_send_reply_command_handler(struct sep_device *sep)
  *
  *     Handles the request to  free dma table for synchronic actions
  */
-
 static int sep_free_dma_table_data_handler(struct sep_device *sep)
 {
-       /* counter */
-       int count = 0;
-
-       /* dcb counter */
-       int dcb_counter = 0;
-
+       int count;
+       int dcb_counter;
        /* pointer to the current dma_resource struct */
        struct sep_dma_resource *dma;
 
-       dev_dbg(&sep->pdev->dev,
-               "sep_free_dma_table_data_handler start\n");
-
-
-       for (dcb_counter = 0; dcb_counter < sep->nr_dcb_creat;
-               dcb_counter++) {
+       dev_dbg(&sep->pdev->dev, "sep_free_dma_table_data_handler start\n");
 
+       for (dcb_counter = 0; dcb_counter < sep->nr_dcb_creat; dcb_counter++) {
                dma = &sep->dma_res_arr[dcb_counter];
 
                /* unmap and free input map array */
                if (dma->in_map_array) {
-
-                       for (count = 0; count < dma->in_num_pages;
-                               count++) {
-
+                       for (count = 0; count < dma->in_num_pages; count++) {
                                dma_unmap_page(&sep->pdev->dev,
                                        dma->in_map_array[count].dma_addr,
                                        dma->in_map_array[count].size,
                                        DMA_TO_DEVICE);
                        }
-
                        kfree(dma->in_map_array);
                }
 
                /* unmap output map array, DON'T free it yet */
                if (dma->out_map_array) {
-                       for (count = 0; count < dma->out_num_pages;
-                               count++) {
-
+                       for (count = 0; count < dma->out_num_pages; count++) {
                                dma_unmap_page(&sep->pdev->dev,
                                        dma->out_map_array[count].dma_addr,
                                        dma->out_map_array[count].size,
                                        DMA_FROM_DEVICE);
                        }
-
                        kfree(dma->out_map_array);
                }
 
                /* free page cache for output */
                if (dma->in_page_array) {
-                       for (count = 0; count < dma->in_num_pages;
-                               count++) {
-
+                       for (count = 0; count < dma->in_num_pages; count++) {
                                flush_dcache_page(dma->in_page_array[count]);
                                page_cache_release(dma->in_page_array[count]);
                        }
-
                        kfree(dma->in_page_array);
-
                }
 
                if (dma->out_page_array) {
-                       for (count = 0; count < dma->out_num_pages;
-                               count++) {
-
+                       for (count = 0; count < dma->out_num_pages; count++) {
                                if (!PageReserved(dma->out_page_array[count]))
                                        SetPageDirty(dma->out_page_array[count]);
-
                                flush_dcache_page(dma->out_page_array[count]);
                                page_cache_release(dma->out_page_array[count]);
                        }
-
                        kfree(dma->out_page_array);
                }
 
@@ -522,19 +472,15 @@ static int sep_free_dma_table_data_handler(struct sep_device *sep)
                dma->out_map_array = 0;
                dma->in_map_num_entries = 0;
                dma->out_map_num_entries = 0;
-
        }
 
        sep->nr_dcb_creat = 0;
        sep->num_lli_tables_created = 0;
 
-       dev_dbg(&sep->pdev->dev,
-               "sep_free_dma_table_data_handler end\n");
-
+       dev_dbg(&sep->pdev->dev, "sep_free_dma_table_data_handler end\n");
        return 0;
 }
 
-
 /**
  *     sep_request_daemon_mmap - maps the shared area to user space
  *     @filp: pointer to struct file
@@ -546,11 +492,8 @@ static int sep_free_dma_table_data_handler(struct sep_device *sep)
 static int sep_request_daemon_mmap(struct file  *filp,
        struct vm_area_struct  *vma)
 {
-       /* device */
        struct sep_device *sep = filp->private_data;
-
        dma_addr_t bus_address;
-
        int error = 0;
 
        dev_dbg(&sep->pdev->dev, "daemon mmap start\n");
@@ -563,23 +506,19 @@ static int sep_request_daemon_mmap(struct file  *filp,
        /* get physical address */
        bus_address = sep->shared_bus;
 
-       dev_dbg(&sep->pdev->dev,
-               "bus_address is %08lx\n",
-               (unsigned long)bus_address);
+       dev_dbg(&sep->pdev->dev, "bus_address is %08lx\n",
+                                       (unsigned long)bus_address);
 
        if (remap_pfn_range(vma, vma->vm_start, bus_address >> PAGE_SHIFT,
                vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
 
-               dev_warn(&sep->pdev->dev,
-                       "remap_page_range failed\n");
+               dev_warn(&sep->pdev->dev, "remap_page_range failed\n");
                error = -EAGAIN;
                goto end_function;
        }
 
 end_function:
-
        dev_dbg(&sep->pdev->dev, "daemon mmap end\n");
-
        return error;
 }
 
@@ -595,69 +534,46 @@ static unsigned int sep_request_daemon_poll(struct file *filp,
        poll_table  *wait)
 {
        u32     mask = 0;
-
        /* GPR2 register */
        u32     retval2;
-
        unsigned long lck_flags;
-
        struct sep_device *sep = filp->private_data;
 
-       dev_dbg(&sep->pdev->dev,
-               "daemon poll: start\n");
-
-       dev_dbg(&sep->pdev->dev, "daemon poll: calling poll wait sep_event\n");
+       dev_dbg(&sep->pdev->dev, "daemon poll: start\n");
 
        poll_wait(filp, &sep->event_request_daemon, wait);
 
-       dev_dbg(&sep->pdev->dev, "daemon poll: exit poll wait sep_event\n");
-
-       dev_dbg(&sep->pdev->dev,
-               "daemon poll: send_ct is %lx reply ct is %lx\n",
-               sep->send_ct, sep->reply_ct);
+       dev_dbg(&sep->pdev->dev, "daemon poll: send_ct is %lx reply ct is %lx\n",
+                                               sep->send_ct, sep->reply_ct);
 
        spin_lock_irqsave(&sep->snd_rply_lck, lck_flags);
        /* check if the data is ready */
        if (sep->send_ct == sep->reply_ct) {
-
                spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags);
 
                retval2 = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR2_REG_ADDR);
-
                dev_dbg(&sep->pdev->dev,
                        "daemon poll: data check (GPR2) is %x\n", retval2);
 
                /* check if PRINT request */
                if ((retval2 >> 30) & 0x1) {
-
-                       dev_dbg(&sep->pdev->dev,
-                               "daemon poll: PRINTF request in\n");
+                       dev_dbg(&sep->pdev->dev, "daemon poll: PRINTF request in\n");
                        mask |= POLLIN;
                        goto end_function;
                }
-
                /* check if NVS request */
                if (retval2 >> 31) {
-
-                       dev_dbg(&sep->pdev->dev,
-                               "daemon poll: NVS request in\n");
+                       dev_dbg(&sep->pdev->dev, "daemon poll: NVS request in\n");
                        mask |= POLLPRI | POLLWRNORM;
                }
-       }
-
-       else {
-
+       } else {
                spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags);
-
                dev_dbg(&sep->pdev->dev,
                        "daemon poll: no reply received; returning 0\n");
                mask = 0;
        }
-
 end_function:
-
-       dev_dbg(&sep->pdev->dev,
-               "daemon poll: exit\n");
+       dev_dbg(&sep->pdev->dev, "daemon poll: exit\n");
        return mask;
 }
 
@@ -668,7 +584,6 @@ end_function:
  *
  *     Called on the final close of a SEP device.
  */
-
 static int sep_release(struct inode *inode, struct file *filp)
 {
        struct sep_device *sep = filp->private_data;
@@ -709,9 +624,6 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
 
        dev_dbg(&sep->pdev->dev, "mmap start\n");
 
-
-       dev_dbg(&sep->pdev->dev, "calling wait on event_mmap, tsetbit"
-               " SEP_MMAP_LOCK_BIT in_use_flags 0\n");
        /* Set the transaction busy (own the device) */
        wait_event_interruptible(sep->event,
                test_and_set_bit(SEP_MMAP_LOCK_BIT,
@@ -748,8 +660,7 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
                goto end_function_with_error;
        }
 
-       dev_dbg(&sep->pdev->dev,
-               "shared_addr is %p\n", sep->shared_addr);
+       dev_dbg(&sep->pdev->dev, "shared_addr is %p\n", sep->shared_addr);
 
        /* get bus address */
        bus_addr = sep->shared_bus;
@@ -759,17 +670,14 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
 
        if (remap_pfn_range(vma, vma->vm_start, bus_addr >> PAGE_SHIFT,
                vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
-               dev_warn(&sep->pdev->dev,
-                       "remap_page_range failed\n");
+               dev_warn(&sep->pdev->dev, "remap_page_range failed\n");
                error = -EAGAIN;
                goto end_function_with_error;
        }
-
        dev_dbg(&sep->pdev->dev, "mmap end\n");
        goto end_function;
 
 end_function_with_error:
-
        /* clear the bit */
        clear_bit(SEP_MMAP_LOCK_BIT, &sep->in_use_flags);
        mutex_lock(&sep->sep_mutex);
@@ -782,7 +690,6 @@ end_function_with_error:
        wake_up(&sep->event);
 
 end_function:
-
        return error;
 }
 
@@ -799,7 +706,6 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
        u32 mask = 0;
        u32 retval = 0;
        u32 retval2 = 0;
-
        unsigned long lck_flags;
 
        struct sep_device *sep = filp->private_data;
@@ -814,7 +720,6 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
                mutex_unlock(&sep->sep_mutex);
                goto end_function;
        }
-
        mutex_unlock(&sep->sep_mutex);
 
        /* check if send command or send_reply were activated previously */
@@ -829,18 +734,13 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
 
        poll_wait(filp, &sep->event, wait);
 
-       dev_dbg(&sep->pdev->dev, "poll: exit wait sep_event\n");
-
        dev_dbg(&sep->pdev->dev, "poll: send_ct is %lx reply ct is %lx\n",
                sep->send_ct, sep->reply_ct);
 
        /* check if error occured during poll */
        retval2 = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
-
        if (retval2 != 0x0) {
-
-               dev_warn(&sep->pdev->dev, "poll; poll error %x\n",
-                       retval2);
+               dev_warn(&sep->pdev->dev, "poll; poll error %x\n", retval2);
                mask |= POLLERR;
                goto end_function;
        }
@@ -848,7 +748,6 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
        spin_lock_irqsave(&sep->snd_rply_lck, lck_flags);
 
        if (sep->send_ct == sep->reply_ct) {
-
                spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags);
                retval = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR2_REG_ADDR);
                dev_dbg(&sep->pdev->dev, "poll: data ready check (GPR2)  %x\n",
@@ -856,46 +755,33 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
 
                /* check if printf request  */
                if ((retval >> 30) & 0x1) {
-
                        dev_dbg(&sep->pdev->dev, "poll: sep printf request\n");
                        wake_up(&sep->event_request_daemon);
                        goto end_function;
-
                }
 
                /* check if the this is sep reply or request */
                if (retval >> 31) {
-
                        dev_dbg(&sep->pdev->dev, "poll: sep request\n");
                        wake_up(&sep->event_request_daemon);
-
                } else {
-
                        dev_dbg(&sep->pdev->dev, "poll: normal return\n");
-
                        /* in case it is again by send_reply_comand */
-
                        clear_bit(SEP_SEND_MSG_LOCK_BIT, &sep->in_use_flags);
-
                        sep_dump_message(sep);
-
                        dev_dbg(&sep->pdev->dev,
                                "poll; sep reply POLLIN | POLLRDNORM\n");
 
                        mask |= POLLIN | POLLRDNORM;
                }
-
        } else {
-
                spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags);
-
                dev_dbg(&sep->pdev->dev,
                        "poll; no reply received; returning mask of 0\n");
                mask = 0;
        }
 
 end_function:
-
        dev_dbg(&sep->pdev->dev, "poll: end\n");
        return mask;
 }
@@ -907,7 +793,6 @@ end_function:
  *     Return the address of the two dwords in memory used for time
  *     setting.
  */
-
 static u32 *sep_time_address(struct sep_device *sep)
 {
        return sep->shared_addr + SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES;
@@ -926,8 +811,7 @@ static unsigned long sep_set_time(struct sep_device *sep)
        u32 *time_addr; /* address of time as seen by the kernel */
 
 
-       dev_dbg(&sep->pdev->dev,
-               "sep:sep_set_time start\n");
+       dev_dbg(&sep->pdev->dev, "sep:sep_set_time start\n");
 
        do_gettimeofday(&time);
 
@@ -937,12 +821,9 @@ static unsigned long sep_set_time(struct sep_device *sep)
        time_addr[0] = SEP_TIME_VAL_TOKEN;
        time_addr[1] = time.tv_sec;
 
-       dev_dbg(&sep->pdev->dev,
-               "time.tv_sec is %lu\n", time.tv_sec);
-       dev_dbg(&sep->pdev->dev,
-               "time_addr is %p\n", time_addr);
-       dev_dbg(&sep->pdev->dev,
-               "sep->shared_addr is %p\n", sep->shared_addr);
+       dev_dbg(&sep->pdev->dev, "time.tv_sec is %lu\n", time.tv_sec);
+       dev_dbg(&sep->pdev->dev, "time_addr is %p\n", time_addr);
+       dev_dbg(&sep->pdev->dev, "sep->shared_addr is %p\n", sep->shared_addr);
 
        return time.tv_sec;
 }
@@ -958,14 +839,11 @@ static unsigned long sep_set_time(struct sep_device *sep)
 static int sep_set_caller_id_handler(struct sep_device *sep, u32 arg)
 {
        void __user *hash;
-       int   error;
+       int   error = 0;
        int   i;
        struct caller_id_struct command_args;
 
-       dev_dbg(&sep->pdev->dev,
-               "sep_set_caller_id_handler start\n");
-
-       error = 0;
+       dev_dbg(&sep->pdev->dev, "sep_set_caller_id_handler start\n");
 
        for (i = 0; i < SEP_CALLER_ID_TABLE_NUM_ENTRIES; i++) {
                if (sep->caller_id_table[i].pid == 0)
@@ -973,12 +851,9 @@ static int sep_set_caller_id_handler(struct sep_device *sep, u32 arg)
        }
 
        if (i == SEP_CALLER_ID_TABLE_NUM_ENTRIES) {
-               dev_warn(&sep->pdev->dev,
-                       "no more caller id entries left\n");
-               dev_warn(&sep->pdev->dev,
-                       "maximum number is %d\n",
-                       SEP_CALLER_ID_TABLE_NUM_ENTRIES);
-
+               dev_warn(&sep->pdev->dev, "no more caller id entries left\n");
+               dev_warn(&sep->pdev->dev, "maximum number is %d\n",
+                                       SEP_CALLER_ID_TABLE_NUM_ENTRIES);
                error = -EUSERS;
                goto end_function;
        }
@@ -1002,7 +877,7 @@ static int sep_set_caller_id_handler(struct sep_device *sep, u32 arg)
                command_args.callerIdSizeInBytes);
 
        if (command_args.callerIdSizeInBytes >
-                               SEP_CALLER_ID_HASH_SIZE_IN_BYTES) {
+                                       SEP_CALLER_ID_HASH_SIZE_IN_BYTES) {
                error = -EMSGSIZE;
                goto end_function;
        }
@@ -1013,8 +888,7 @@ static int sep_set_caller_id_handler(struct sep_device *sep, u32 arg)
                hash, command_args.callerIdSizeInBytes))
                error = -EFAULT;
 end_function:
-       dev_dbg(&sep->pdev->dev,
-               "sep_set_caller_id_handler end\n");
+       dev_dbg(&sep->pdev->dev, "sep_set_caller_id_handler end\n");
        return error;
 }
 
@@ -1030,29 +904,23 @@ static int sep_set_current_caller_id(struct sep_device *sep)
        int i;
 
        dev_dbg(&sep->pdev->dev, "sep_set_current_caller_id start\n");
-
        dev_dbg(&sep->pdev->dev, "current process is %d\n", current->pid);
 
        /* zero the previous value */
-       memset((void *)(sep->shared_addr +
-               (SEP_CALLER_ID_OFFSET_BYTES)),
-               0,
-               SEP_CALLER_ID_HASH_SIZE_IN_BYTES);
+       memset(sep->shared_addr + SEP_CALLER_ID_OFFSET_BYTES,
+                                       0, SEP_CALLER_ID_HASH_SIZE_IN_BYTES);
 
        for (i = 0; i < SEP_CALLER_ID_TABLE_NUM_ENTRIES; i++) {
                if (sep->caller_id_table[i].pid == current->pid) {
                        dev_dbg(&sep->pdev->dev, "Caller Id found\n");
 
-                       memcpy((void *)(sep->shared_addr +
-                               (SEP_CALLER_ID_OFFSET_BYTES)),
+                       memcpy(sep->shared_addr + SEP_CALLER_ID_OFFSET_BYTES,
                                (void *)(sep->caller_id_table[i].callerIdHash),
                                SEP_CALLER_ID_HASH_SIZE_IN_BYTES);
                        break;
                }
        }
-
        dev_dbg(&sep->pdev->dev, "sep_set_current_caller_id end\n");
-
        return 0;
 }
 
@@ -1065,7 +933,6 @@ static int sep_set_current_caller_id(struct sep_device *sep)
  *
  *      Note that this function does fall under the ioctl lock
  */
-
 static int sep_send_command_handler(struct sep_device *sep)
 {
        unsigned long lck_flags;
@@ -1073,13 +940,10 @@ static int sep_send_command_handler(struct sep_device *sep)
 
        dev_dbg(&sep->pdev->dev, "sep_send_command_handler start\n");
 
-       dev_dbg(&sep->pdev->dev, "calling test and set for "
-               " in_use_flags SEP_SEND_MSG_LOCK_BIT 0\n");
        if (test_and_set_bit(SEP_SEND_MSG_LOCK_BIT, &sep->in_use_flags)) {
                error = -EPROTO;
                goto end_function;
        }
-
        sep_set_time(sep);
 
        /* only Medfield has caller id */
@@ -1093,8 +957,9 @@ static int sep_send_command_handler(struct sep_device *sep)
        sep->send_ct++;
        spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags);
 
-       dev_dbg(&sep->pdev->dev, "sep_send_command_handler"
-               "send_ct %lx reply_ct %lx\n", sep->send_ct, sep->reply_ct);
+       dev_dbg(&sep->pdev->dev,
+               "sep_send_command_handler send_ct %lx reply_ct %lx\n",
+                                               sep->send_ct, sep->reply_ct);
 
        /* send interrupt to SEP */
        sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2);
@@ -1156,8 +1021,7 @@ static int sep_allocate_data_pool_memory_handler(struct sep_device *sep,
                SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES +
                (sep->num_of_data_allocations)*2*sizeof(u32));
 
-       dev_dbg(&sep->pdev->dev,
-               "allocation offset: %x\n",
+       dev_dbg(&sep->pdev->dev, "allocation offset: %x\n",
                SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES);
        dev_dbg(&sep->pdev->dev, "data pool token addr is %p\n", token_addr);
 
@@ -1173,7 +1037,7 @@ static int sep_allocate_data_pool_memory_handler(struct sep_device *sep,
        error = copy_to_user((void *)arg, (void *)&command_args,
                sizeof(struct alloc_struct));
        if (error) {
-
+               error = -EFAULT;
                dev_warn(&sep->pdev->dev,
                        "allocate data pool copy to user error\n");
                goto end_function;
@@ -1189,9 +1053,7 @@ static int sep_allocate_data_pool_memory_handler(struct sep_device *sep,
                (int)sep->data_pool_bytes_allocated);
 
 end_function:
-
-       dev_dbg(&sep->pdev->dev,
-               "sep_allocate_data_pool_memory_handler end\n");
+       dev_dbg(&sep->pdev->dev, "sep_allocate_data_pool_memory_handler end\n");
        return error;
 }
 
@@ -1216,12 +1078,9 @@ static int sep_lock_kernel_pages(struct sep_device *sep,
        int in_out_flag)
 
 {
-       /* error */
        int error = 0;
-
        /* array of lli */
        struct sep_lli_entry *lli_array;
-
        /* map array */
        struct sep_dma_map *map_array;
 
@@ -1235,11 +1094,9 @@ static int sep_lock_kernel_pages(struct sep_device *sep,
 
        lli_array = kmalloc(sizeof(struct sep_lli_entry), GFP_ATOMIC);
        if (!lli_array) {
-
                error = -ENOMEM;
                goto end_function;
        }
-
        map_array = kmalloc(sizeof(struct sep_dma_map), GFP_ATOMIC);
        if (!map_array) {
                error = -ENOMEM;
@@ -1260,8 +1117,7 @@ static int sep_lock_kernel_pages(struct sep_device *sep,
        lli_array[0].block_size = map_array[0].size;
 
        dev_dbg(&sep->pdev->dev,
-               "lli_array[0].bus_address is %08lx,"
-               " lli_array[0].block_size is %x\n",
+       "lli_array[0].bus_address is %08lx, lli_array[0].block_size is %x\n",
                (unsigned long)lli_array[0].bus_address,
                lli_array[0].block_size);
 
@@ -1279,18 +1135,13 @@ static int sep_lock_kernel_pages(struct sep_device *sep,
                sep->dma_res_arr[sep->nr_dcb_creat].out_map_array = map_array;
                sep->dma_res_arr[sep->nr_dcb_creat].out_map_num_entries = 1;
        }
-
        goto end_function;
 
 end_function_with_error:
-
        kfree(lli_array);
 
 end_function:
-
-       dev_dbg(&sep->pdev->dev,
-               "sep_lock_kernel_pages end\n");
-
+       dev_dbg(&sep->pdev->dev, "sep_lock_kernel_pages end\n");
        return error;
 }
 
@@ -1314,59 +1165,39 @@ static int sep_lock_user_pages(struct sep_device *sep,
        int in_out_flag)
 
 {
-       /* error */
-       int error;
-
+       int error = 0;
+       u32 count;
+       int result;
        /* the the page of the end address of the user space buffer */
        u32 end_page;
-
        /* the page of the start address of the user space buffer */
        u32 start_page;
-
        /* the range in pages */
        u32 num_pages;
-
-       /* array of pointers ot page */
+       /* array of pointers to page */
        struct page **page_array;
-
        /* array of lli */
        struct sep_lli_entry *lli_array;
-
        /* map array */
        struct sep_dma_map *map_array;
-
        /* direction of the DMA mapping for locked pages */
        enum dma_data_direction dir;
 
-       /* count */
-       u32 count;
-
-       /* result */
-       int result;
-
        dev_dbg(&sep->pdev->dev,
                "sep_lock_user_pages start\n");
 
-       error = 0;
-
        /* set start and end pages  and num pages */
        end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT;
        start_page = app_virt_addr >> PAGE_SHIFT;
        num_pages = end_page - start_page + 1;
 
-       dev_dbg(&sep->pdev->dev,
-               "app_virt_addr is %x\n", app_virt_addr);
-       dev_dbg(&sep->pdev->dev,
-               "data_size is %x\n", data_size);
-       dev_dbg(&sep->pdev->dev,
-               "start_page is %x\n", start_page);
-       dev_dbg(&sep->pdev->dev,
-               "end_page is %x\n", end_page);
-       dev_dbg(&sep->pdev->dev,
-               "num_pages is %x\n", num_pages);
+       dev_dbg(&sep->pdev->dev, "app_virt_addr is %x\n", app_virt_addr);
+       dev_dbg(&sep->pdev->dev, "data_size is %x\n", data_size);
+       dev_dbg(&sep->pdev->dev, "start_page is %x\n", start_page);
+       dev_dbg(&sep->pdev->dev, "end_page is %x\n", end_page);
+       dev_dbg(&sep->pdev->dev, "num_pages is %x\n", num_pages);
 
-       dev_dbg(&sep->pdev->dev,
-               "starting page_array malloc\n");
+       dev_dbg(&sep->pdev->dev, "starting page_array malloc\n");
 
        /* allocate array of pages structure pointers */
        page_array = kmalloc(sizeof(struct page *) * num_pages, GFP_ATOMIC);
@@ -1374,11 +1205,9 @@ static int sep_lock_user_pages(struct sep_device *sep,
                error = -ENOMEM;
                goto end_function;
        }
-
        map_array = kmalloc(sizeof(struct sep_dma_map) * num_pages, GFP_ATOMIC);
        if (!map_array) {
-               dev_warn(&sep->pdev->dev,
-                       "kmalloc for map_array failed\n");
+               dev_warn(&sep->pdev->dev, "kmalloc for map_array failed\n");
                error = -ENOMEM;
                goto end_function_with_error1;
        }
@@ -1387,15 +1216,12 @@ static int sep_lock_user_pages(struct sep_device *sep,
                GFP_ATOMIC);
 
        if (!lli_array) {
-
-               dev_warn(&sep->pdev->dev,
-                       "kmalloc for lli_array failed\n");
+               dev_warn(&sep->pdev->dev, "kmalloc for lli_array failed\n");
                error = -ENOMEM;
                goto end_function_with_error2;
        }
 
-       dev_dbg(&sep->pdev->dev,
-               "starting get_user_pages\n");
+       dev_dbg(&sep->pdev->dev, "starting get_user_pages\n");
 
        /* convert the application virtual address into a set of physical */
        down_read(&current->mm->mmap_sem);
@@ -1408,15 +1234,13 @@ static int sep_lock_user_pages(struct sep_device *sep,
 
        /* check the number of pages locked - if not all then exit with error */
        if (result != num_pages) {
-
                dev_warn(&sep->pdev->dev,
                        "not all pages locked by get_user_pages\n");
                error = -ENOMEM;
                goto end_function_with_error3;
        }
 
-       dev_dbg(&sep->pdev->dev,
-               "get_user_pages succeeded\n");
+       dev_dbg(&sep->pdev->dev, "get_user_pages succeeded\n");
 
        /* set direction */
        if (in_out_flag == SEP_DRIVER_IN_FLAG)
@@ -1441,9 +1265,7 @@ static int sep_lock_user_pages(struct sep_device *sep,
                lli_array[count].bus_address = (u32)map_array[count].dma_addr;
                lli_array[count].block_size = PAGE_SIZE;
 
-               dev_warn(&sep->pdev->dev,
-                       "lli_array[%x].bus_address is %08lx, \
-                       lli_array[%x].block_size is %x\n",
+               dev_warn(&sep->pdev->dev, "lli_array[%x].bus_address is %08lx, lli_array[%x].block_size is %x\n",
                        count, (unsigned long)lli_array[count].bus_address,
                        count, lli_array[count].block_size);
        }
@@ -1460,20 +1282,17 @@ static int sep_lock_user_pages(struct sep_device *sep,
                        PAGE_SIZE - (app_virt_addr & (~PAGE_MASK));
 
        dev_dbg(&sep->pdev->dev,
-               "lli_array[0].bus_address is %08lx, \
-               lli_array[0].block_size is %x\n",
+               "lli_array[0].bus_address is %08lx, lli_array[0].block_size is %x\n",
                (unsigned long)lli_array[count].bus_address,
                lli_array[count].block_size);
 
        /* check the size of the last page */
        if (num_pages > 1) {
-
                lli_array[num_pages - 1].block_size =
                        (app_virt_addr + data_size) & (~PAGE_MASK);
 
                dev_warn(&sep->pdev->dev,
-                       "lli_array[%x].bus_address is %08lx, \
-                       lli_array[%x].block_size is %x\n",
+                       "lli_array[%x].bus_address is %08lx, lli_array[%x].block_size is %x\n",
                        num_pages - 1,
                        (unsigned long)lli_array[count].bus_address,
                        num_pages - 1,
@@ -1483,47 +1302,35 @@ static int sep_lock_user_pages(struct sep_device *sep,
        /* set output params acording to the in_out flag */
        if (in_out_flag == SEP_DRIVER_IN_FLAG) {
                *lli_array_ptr = lli_array;
-               sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages =
-                       num_pages;
-               sep->dma_res_arr[sep->nr_dcb_creat].in_page_array =
-                       page_array;
-               sep->dma_res_arr[sep->nr_dcb_creat].in_map_array =
-                       map_array;
+               sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages = num_pages;
+               sep->dma_res_arr[sep->nr_dcb_creat].in_page_array = page_array;
+               sep->dma_res_arr[sep->nr_dcb_creat].in_map_array = map_array;
                sep->dma_res_arr[sep->nr_dcb_creat].in_map_num_entries =
-                       num_pages;
+                                                               num_pages;
        } else {
                *lli_array_ptr = lli_array;
-               sep->dma_res_arr[sep->nr_dcb_creat].out_num_pages =
-                       num_pages;
+               sep->dma_res_arr[sep->nr_dcb_creat].out_num_pages = num_pages;
                sep->dma_res_arr[sep->nr_dcb_creat].out_page_array =
-                       page_array;
-               sep->dma_res_arr[sep->nr_dcb_creat].out_map_array =
-                       map_array;
+                                                               page_array;
+               sep->dma_res_arr[sep->nr_dcb_creat].out_map_array = map_array;
                sep->dma_res_arr[sep->nr_dcb_creat].out_map_num_entries =
-                       num_pages;
+                                                               num_pages;
        }
-
        goto end_function;
 
 end_function_with_error3:
-
        /* free lli array */
        kfree(lli_array);
 
 end_function_with_error2:
-
        kfree(map_array);
 
 end_function_with_error1:
-
        /* free page array */
        kfree(page_array);
 
 end_function:
-
-       dev_dbg(&sep->pdev->dev,
-               "sep_lock_user_pages end\n");
-
+       dev_dbg(&sep->pdev->dev, "sep_lock_user_pages end\n");
        return error;
 }
 
@@ -1544,16 +1351,12 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep,
        u32 num_array_entries,
        u32 *last_table_flag)
 {
+       u32 counter;
        /* table data size */
-       u32 table_data_size;
-
+       u32 table_data_size = 0;
        /* data size for the next table */
        u32 next_table_data_size;
 
-       /* counter */
-       u32 counter;
-
-       table_data_size = 0;
        *last_table_flag = 0;
 
        /*
@@ -1562,7 +1365,7 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep,
         */
        for (counter = 0;
                (counter < (SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP - 1)) &&
-               (counter < num_array_entries); counter++)
+                       (counter < num_array_entries); counter++)
                table_data_size += lli_in_array_ptr[counter].block_size;
 
        /*
@@ -1571,7 +1374,6 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep,
         * and no need to check the block alignment
         */
        if (counter == num_array_entries) {
-
                /* set the last table flag */
                *last_table_flag = 1;
                goto end_function;
@@ -1584,11 +1386,8 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep,
         */
        next_table_data_size = 0;
        for (; counter < num_array_entries; counter++) {
-
                next_table_data_size += lli_in_array_ptr[counter].block_size;
-
                if (next_table_data_size >= SEP_DRIVER_MIN_DATA_SIZE_PER_TABLE)
-
                        break;
        }
 
@@ -1603,11 +1402,9 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep,
                table_data_size -= (SEP_DRIVER_MIN_DATA_SIZE_PER_TABLE -
                        next_table_data_size);
 
-       dev_dbg(&sep->pdev->dev,
-               "table data size is %x\n", table_data_size);
-
+       dev_dbg(&sep->pdev->dev, "table data size is %x\n",
+                                                       table_data_size);
 end_function:
-
        return table_data_size;
 }
 
@@ -1632,20 +1429,17 @@ static void sep_build_lli_table(struct sep_device *sep,
 {
        /* current table data size */
        u32 curr_table_data_size;
-
        /* counter of lli array entry */
        u32 array_counter;
 
-       dev_dbg(&sep->pdev->dev,
-               "sep_build_lli_table start\n");
+       dev_dbg(&sep->pdev->dev, "sep_build_lli_table start\n");
 
        /* init currrent table data size and lli array entry counter */
        curr_table_data_size = 0;
        array_counter = 0;
        *num_table_entries_ptr = 1;
 
-       dev_dbg(&sep->pdev->dev,
-               "table_data_size is %x\n", table_data_size);
+       dev_dbg(&sep->pdev->dev, "table_data_size is %x\n", table_data_size);
 
        /* fill the table till table size reaches the needed amount */
        while (curr_table_data_size < table_data_size) {
@@ -1660,18 +1454,15 @@ static void sep_build_lli_table(struct sep_device *sep,
 
                curr_table_data_size += lli_array_ptr[array_counter].block_size;
 
-               dev_dbg(&sep->pdev->dev,
-                       "lli_table_ptr is %p\n", lli_table_ptr);
-               dev_dbg(&sep->pdev->dev,
-                       "lli_table_ptr->bus_address is %08lx\n",
-                       (unsigned long)lli_table_ptr->bus_address);
-               dev_dbg(&sep->pdev->dev,
-                       "lli_table_ptr->block_size is %x\n",
+               dev_dbg(&sep->pdev->dev, "lli_table_ptr is %p\n",
+                                                               lli_table_ptr);
+               dev_dbg(&sep->pdev->dev, "lli_table_ptr->bus_address is %08lx\n",
+                               (unsigned long)lli_table_ptr->bus_address);
+               dev_dbg(&sep->pdev->dev, "lli_table_ptr->block_size is %x\n",
                        lli_table_ptr->block_size);
 
                /* check for overflow of the table data */
                if (curr_table_data_size > table_data_size) {
-
                        dev_dbg(&sep->pdev->dev,
                                "curr_table_data_size too large\n");
 
@@ -1686,15 +1477,13 @@ static void sep_build_lli_table(struct sep_device *sep,
                        /* update the block size left in the lli array */
                        lli_array_ptr[array_counter].block_size =
                                (curr_table_data_size - table_data_size);
-
                } else
-
                        /* advance to the next entry in the lli_array */
                        array_counter++;
 
                dev_dbg(&sep->pdev->dev,
                        "lli_table_ptr->bus_address is %08lx\n",
-                       (unsigned long)lli_table_ptr->bus_address);
+                               (unsigned long)lli_table_ptr->bus_address);
                dev_dbg(&sep->pdev->dev,
                        "lli_table_ptr->block_size is %x\n",
                        lli_table_ptr->block_size);
@@ -1707,26 +1496,19 @@ static void sep_build_lli_table(struct sep_device *sep,
        lli_table_ptr->bus_address = 0xffffffff;
        lli_table_ptr->block_size = 0;
 
-       dev_dbg(&sep->pdev->dev,
-               "lli_table_ptr is %p\n", lli_table_ptr);
-       dev_dbg(&sep->pdev->dev,
-               "lli_table_ptr->bus_address is %08lx\n",
-               (unsigned long)lli_table_ptr->bus_address);
-       dev_dbg(&sep->pdev->dev,
-               "lli_table_ptr->block_size is %x\n",
-               lli_table_ptr->block_size);
+       dev_dbg(&sep->pdev->dev, "lli_table_ptr is %p\n", lli_table_ptr);
+       dev_dbg(&sep->pdev->dev, "lli_table_ptr->bus_address is %08lx\n",
+                               (unsigned long)lli_table_ptr->bus_address);
+       dev_dbg(&sep->pdev->dev, "lli_table_ptr->block_size is %x\n",
+                                               lli_table_ptr->block_size);
 
        /* set the output parameter */
        *num_processed_entries_ptr += array_counter;
 
-       dev_dbg(&sep->pdev->dev,
-               "num_processed_entries_ptr is %x\n",
+       dev_dbg(&sep->pdev->dev, "num_processed_entries_ptr is %x\n",
                *num_processed_entries_ptr);
 
-       dev_dbg(&sep->pdev->dev,
-               "sep_build_lli_table end\n");
-
-       return;
+       dev_dbg(&sep->pdev->dev, "sep_build_lli_table end\n");
 }
 
 /**
@@ -1742,16 +1524,12 @@ static void sep_build_lli_table(struct sep_device *sep,
 static dma_addr_t sep_shared_area_virt_to_bus(struct sep_device *sep,
        void *virt_address)
 {
-       dev_dbg(&sep->pdev->dev,
-               "sh virt to phys v %08lx\n",
-               (unsigned long)virt_address);
-       dev_dbg(&sep->pdev->dev,
-               "sh virt to phys p %08lx\n",
-               (unsigned long)(sep->shared_bus
-               + (virt_address - sep->shared_addr)));
+       dev_dbg(&sep->pdev->dev, "sh virt to phys v %p\n", virt_address);
+       dev_dbg(&sep->pdev->dev, "sh virt to phys p %08lx\n",
+               (unsigned long)
+               sep->shared_bus + (virt_address - sep->shared_addr));
 
-       return sep->shared_bus
-               + (size_t)(virt_address - sep->shared_addr);
+       return sep->shared_bus + (size_t)(virt_address - sep->shared_addr);
 }
 
 /**
@@ -1764,18 +1542,14 @@ static dma_addr_t sep_shared_area_virt_to_bus(struct sep_device *sep,
  *     externa RAM device (ioremapped), or on the system RAM
  *     This implementation is for the external RAM
  */
-
 static void *sep_shared_area_bus_to_virt(struct sep_device *sep,
        dma_addr_t bus_address)
 {
-       dev_dbg(&sep->pdev->dev,
-               "shared bus to virt b=%x v=%x\n",
-               (u32)bus_address,
-               (u32)(sep->shared_addr +
+       dev_dbg(&sep->pdev->dev, "shared bus to virt b=%x v=%x\n",
+               (u32)bus_address, (u32)(sep->shared_addr +
                        (size_t)(bus_address - sep->shared_bus)));
 
-       return sep->shared_addr
-               + (size_t)(bus_address - sep->shared_bus);
+       return sep->shared_addr + (size_t)(bus_address - sep->shared_bus);
 }
 
 /**
@@ -1792,20 +1566,17 @@ static void sep_debug_print_lli_tables(struct sep_device *sep,
        unsigned long num_table_entries,
        unsigned long table_data_size)
 {
-       unsigned long table_count = 0;
+       unsigned long table_count = 1;
        unsigned long entries_count = 0;
 
-       dev_dbg(&sep->pdev->dev,
-               "sep_debug_print_lli_tables start\n");
+       dev_dbg(&sep->pdev->dev, "sep_debug_print_lli_tables start\n");
 
-       table_count = 1;
        while ((unsigned long) lli_table_ptr != 0xffffffff) {
                dev_dbg(&sep->pdev->dev,
                        "lli table %08lx, table_data_size is %lu\n",
                        table_count, table_data_size);
-               dev_dbg(&sep->pdev->dev,
-                       "num_table_entries is %lu\n",
-                       num_table_entries);
+               dev_dbg(&sep->pdev->dev, "num_table_entries is %lu\n",
+                                                       num_table_entries);
 
                /* print entries of the table (without info entry) */
                for (entries_count = 0; entries_count < num_table_entries;
@@ -1820,7 +1591,6 @@ static void sep_debug_print_lli_tables(struct sep_device *sep,
                                (unsigned long)lli_table_ptr->bus_address,
                                lli_table_ptr->block_size);
                }
-
                /* point to the info entry */
                lli_table_ptr--;
 
@@ -1850,8 +1620,7 @@ static void sep_debug_print_lli_tables(struct sep_device *sep,
 
                table_count++;
        }
-       dev_dbg(&sep->pdev->dev,
-                       "sep_debug_print_lli_tables end\n");
+       dev_dbg(&sep->pdev->dev, "sep_debug_print_lli_tables end\n");
 }
 
 
@@ -1863,7 +1632,6 @@ static void sep_debug_print_lli_tables(struct sep_device *sep,
  *     @table_data_size_ptr: point to table data size
  *
  *     This function creates empty lli tables when there is no data
-
  */
 static void sep_prepare_empty_lli_table(struct sep_device *sep,
                dma_addr_t *lli_table_addr_ptr,
@@ -1878,9 +1646,8 @@ static void sep_prepare_empty_lli_table(struct sep_device *sep,
        lli_table_ptr =
                (struct sep_lli_entry *)(sep->shared_addr +
                SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES +
-               sep->num_lli_tables_created *
-               sizeof(struct sep_lli_entry) *
-               SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
+               sep->num_lli_tables_created * sizeof(struct sep_lli_entry) *
+                       SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
 
        lli_table_ptr->bus_address = 0;
        lli_table_ptr->block_size = 0;
@@ -1931,43 +1698,29 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
        u32 *table_data_size_ptr,
        bool is_kva)
 {
+       int error = 0;
        /* pointer to the info entry of the table - the last entry */
        struct sep_lli_entry *info_entry_ptr;
-
-       /* array of pointers ot page */
+       /* array of pointers to page */
        struct sep_lli_entry *lli_array_ptr;
-
        /* points to the first entry to be processed in the lli_in_array */
        u32 current_entry = 0;
-
        /* num entries in the virtual buffer */
        u32 sep_lli_entries = 0;
-
        /* lli table pointer */
        struct sep_lli_entry *in_lli_table_ptr;
-
        /* the total data in one table */
        u32 table_data_size = 0;
-
        /* flag for last table */
        u32 last_table_flag = 0;
-
        /* number of entries in lli table */
        u32 num_entries_in_table = 0;
-
        /* next table address */
        u32 lli_table_alloc_addr = 0;
 
-       /* error */
-       int error = 0;
-
-       dev_dbg(&sep->pdev->dev,
-               "sep_prepare_input_dma_table start\n");
-
-       dev_dbg(&sep->pdev->dev,
-               "data_size is %x\n", data_size);
-       dev_dbg(&sep->pdev->dev,
-               "block_size is %x\n", block_size);
+       dev_dbg(&sep->pdev->dev, "sep_prepare_input_dma_table start\n");
+       dev_dbg(&sep->pdev->dev, "data_size is %x\n", data_size);
+       dev_dbg(&sep->pdev->dev, "block_size is %x\n", block_size);
 
        /* initialize the pages pointers */
        sep->dma_res_arr[sep->nr_dcb_creat].in_page_array = 0;
@@ -1976,29 +1729,22 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
        /* set the kernel address for first table to be allocated */
        lli_table_alloc_addr = (u32)(sep->shared_addr +
                SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES +
-               sep->num_lli_tables_created *
-               sizeof(struct sep_lli_entry) *
+               sep->num_lli_tables_created * sizeof(struct sep_lli_entry) *
                SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
 
        if (data_size == 0) {
-
                /* special case  - create meptu table - 2 entries, zero data */
                sep_prepare_empty_lli_table(sep, lli_table_ptr,
-                       num_entries_ptr,
-                       table_data_size_ptr);
-
+                               num_entries_ptr, table_data_size_ptr);
                goto update_dcb_counter;
        }
 
        /* check if the pages are in Kernel Virtual Address layout */
        if (is_kva == true)
-
                /* lock the pages in the kernel */
                error = sep_lock_kernel_pages(sep, app_virt_addr,
                        data_size, &lli_array_ptr, SEP_DRIVER_IN_FLAG);
-
        else
-
                /*
                 * lock the pages of the user buffer
                 * and translate them to pages
@@ -2009,15 +1755,13 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
        if (error)
                goto end_function;
 
-       dev_dbg(&sep->pdev->dev,
-               "output sep_in_num_pages is %x\n",
+       dev_dbg(&sep->pdev->dev, "output sep_in_num_pages is %x\n",
                sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages);
 
        current_entry = 0;
        info_entry_ptr = 0;
 
-       sep_lli_entries =
-               sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages;
+       sep_lli_entries = sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages;
 
        /* loop till all the entries in in array are not processed */
        while (current_entry < sep_lli_entries) {
@@ -2048,17 +1792,16 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
                        (sep_lli_entries - current_entry),
                        &last_table_flag);
 
-               /**
+               /*
                 * if this is not the last table -
                 * then allign it to the block size
                 */
                if (!last_table_flag)
                        table_data_size =
-                       (table_data_size / block_size) * block_size;
+                               (table_data_size / block_size) * block_size;
 
-               dev_dbg(&sep->pdev->dev,
-                       "output table_data_size is %x\n",
-                       table_data_size);
+               dev_dbg(&sep->pdev->dev, "output table_data_size is %x\n",
+                                                       table_data_size);
 
                /* construct input lli table */
                sep_build_lli_table(sep, &lli_array_ptr[current_entry],
@@ -2077,52 +1820,38 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
                                "output lli_table_in_ptr is %08lx\n",
                                (unsigned long)*lli_table_ptr);
 
-               }
-
-               else {
-
+               } else {
                        /* update the info entry of the previous in table */
                        info_entry_ptr->bus_address =
                                sep_shared_area_virt_to_bus(sep,
-                               in_lli_table_ptr);
-                               info_entry_ptr->block_size =
+                                                       in_lli_table_ptr);
+                       info_entry_ptr->block_size = 
                                ((num_entries_in_table) << 24) |
                                (table_data_size);
                }
-
                /* save the pointer to the info entry of the current tables */
                info_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1;
-
        }
-
        /* print input tables */
        sep_debug_print_lli_tables(sep, (struct sep_lli_entry *)
                sep_shared_area_bus_to_virt(sep, *lli_table_ptr),
-               *num_entries_ptr,
-               *table_data_size_ptr);
-
+               *num_entries_ptr, *table_data_size_ptr);
        /* the array of the pages */
        kfree(lli_array_ptr);
 
 update_dcb_counter:
-
        /* update dcb counter */
        sep->nr_dcb_creat++;
-
        goto end_function;
 
 end_function_error:
-
        /* free all the allocated resources */
        kfree(sep->dma_res_arr[sep->nr_dcb_creat].in_map_array);
        kfree(lli_array_ptr);
        kfree(sep->dma_res_arr[sep->nr_dcb_creat].in_page_array);
 
 end_function:
-
-       dev_dbg(&sep->pdev->dev,
-               "sep_prepare_input_dma_table end\n");
-
+       dev_dbg(&sep->pdev->dev, "sep_prepare_input_dma_table end\n");
        return error;
 
 }
@@ -2161,45 +1890,32 @@ static int sep_construct_dma_tables_from_lli(
 {
        /* points to the area where next lli table can be allocated */
        u32 lli_table_alloc_addr = 0;
-
        /* input lli table */
        struct sep_lli_entry *in_lli_table_ptr = 0;
-
        /* output lli table */
        struct sep_lli_entry *out_lli_table_ptr = 0;
-
        /* pointer to the info entry of the table - the last entry */
        struct sep_lli_entry *info_in_entry_ptr = 0;
-
        /* pointer to the info entry of the table - the last entry */
        struct sep_lli_entry *info_out_entry_ptr = 0;
-
        /* points to the first entry to be processed in the lli_in_array */
        u32 current_in_entry = 0;
-
        /* points to the first entry to be processed in the lli_out_array */
        u32 current_out_entry = 0;
-
        /* max size of the input table */
        u32 in_table_data_size = 0;
-
        /* max size of the output table */
        u32 out_table_data_size = 0;
-
        /* flag te signifies if this is the last tables build */
        u32 last_table_flag = 0;
-
        /* the data size that should be in table */
        u32 table_data_size = 0;
-
        /* number of etnries in the input table */
        u32 num_entries_in_table = 0;
-
        /* number of etnries in the output table */
        u32 num_entries_out_table = 0;
 
-       dev_dbg(&sep->pdev->dev,
-               "sep_construct_dma_tables_from_lli start\n");
+       dev_dbg(&sep->pdev->dev, "sep_construct_dma_tables_from_lli start\n");
 
        /* initiate to point after the message area */
        lli_table_alloc_addr = (u32)(sep->shared_addr +
@@ -2210,7 +1926,6 @@ static int sep_construct_dma_tables_from_lli(
 
        /* loop till all the entries in in array are not processed */
        while (current_in_entry < sep_in_lli_entries) {
-
                /* set the new input and output tables */
                in_lli_table_ptr =
                        (struct sep_lli_entry *)lli_table_alloc_addr;
@@ -2229,8 +1944,7 @@ static int sep_construct_dma_tables_from_lli(
                        SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES +
                        SYNCHRONIC_DMA_TABLES_AREA_SIZE_BYTES)) {
 
-                       dev_warn(&sep->pdev->dev,
-                               "dma table limit overrun\n");
+                       dev_warn(&sep->pdev->dev, "dma table limit overrun\n");
                        return -ENOMEM;
                }
 
@@ -2281,8 +1995,8 @@ static int sep_construct_dma_tables_from_lli(
                                block_size;
                }
 
-               dev_dbg(&sep->pdev->dev,
-                       "table_data_size is %x\n", table_data_size);
+               dev_dbg(&sep->pdev->dev, "table_data_size is %x\n",
+                                                       table_data_size);
 
                /* construct input lli table */
                sep_build_lli_table(sep, &lli_in_array[current_in_entry],
@@ -2380,9 +2094,7 @@ static int sep_construct_dma_tables_from_lli(
        *out_num_entries_ptr,
        *table_data_size_ptr);
 
-       dev_dbg(&sep->pdev->dev,
-               "sep_construct_dma_tables_from_lli end\n");
-
+       dev_dbg(&sep->pdev->dev, "sep_construct_dma_tables_from_lli end\n");
        return 0;
 }
 
@@ -2418,20 +2130,15 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep,
        bool is_kva)
 
 {
+       int error = 0;
        /* array of pointers of page */
        struct sep_lli_entry *lli_in_array;
-
        /* array of pointers of page */
        struct sep_lli_entry *lli_out_array;
 
-       /* error */
-       int error = 0;
-
-       dev_dbg(&sep->pdev->dev,
-               "sep_prepare_input_output_dma_table start\n");
+       dev_dbg(&sep->pdev->dev, "sep_prepare_input_output_dma_table start\n");
 
        if (data_size == 0) {
-
                /* prepare empty table for input and output */
                sep_prepare_empty_lli_table(sep, lli_table_in_ptr,
                        in_num_entries_ptr, table_data_size_ptr);
@@ -2471,8 +2178,8 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep,
                error = sep_lock_user_pages(sep, app_virt_in_addr,
                                data_size, &lli_in_array, SEP_DRIVER_IN_FLAG);
                if (error) {
-                       dev_warn(&sep->pdev->dev, "sep_lock_user_pages for "
-                                       "input virtual buffer failed\n");
+                       dev_warn(&sep->pdev->dev, 
+                               "sep_lock_user_pages for input virtual buffer failed\n");
                        goto end_function;
                }
 
@@ -2480,20 +2187,17 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep,
                        data_size, &lli_out_array, SEP_DRIVER_OUT_FLAG);
 
                if (error) {
-                       dev_warn(&sep->pdev->dev, "sep_lock_user_pages for "
-                                       "output virtual buffer failed\n");
+                       dev_warn(&sep->pdev->dev,
+                               "sep_lock_user_pages for output virtual buffer failed\n");
                        goto end_function_free_lli_in;
                }
        }
 
-       dev_dbg(&sep->pdev->dev,
-               "sep_in_num_pages is %x\n",
+       dev_dbg(&sep->pdev->dev, "sep_in_num_pages is %x\n",
                sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages);
-       dev_dbg(&sep->pdev->dev,
-               "sep_out_num_pages is %x\n",
+       dev_dbg(&sep->pdev->dev, "sep_out_num_pages is %x\n",
                sep->dma_res_arr[sep->nr_dcb_creat].out_num_pages);
-       dev_dbg(&sep->pdev->dev,
-               "SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n",
+       dev_dbg(&sep->pdev->dev, "SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n",
                SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
 
        /* call the fucntion that creates table from the lli arrays */
@@ -2514,38 +2218,32 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep,
        kfree(lli_in_array);
 
 update_dcb_counter:
-
        /* update dcb counter */
        sep->nr_dcb_creat++;
-
        /* fall through - free the lli entry arrays */
-       dev_dbg(&sep->pdev->dev,
-               "in_num_entries_ptr is %08x\n", *in_num_entries_ptr);
-       dev_dbg(&sep->pdev->dev,
-               "out_num_entries_ptr is %08x\n", *out_num_entries_ptr);
-       dev_dbg(&sep->pdev->dev,
-               "table_data_size_ptr is %08x\n", *table_data_size_ptr);
+       dev_dbg(&sep->pdev->dev, "in_num_entries_ptr is %08x\n",
+                                               *in_num_entries_ptr);
+       dev_dbg(&sep->pdev->dev, "out_num_entries_ptr is %08x\n",
+                                               *out_num_entries_ptr);
+       dev_dbg(&sep->pdev->dev, "table_data_size_ptr is %08x\n",
+                                               *table_data_size_ptr);
 
        goto end_function;
 
 end_function_with_error:
-
        kfree(sep->dma_res_arr[sep->nr_dcb_creat].out_map_array);
        kfree(sep->dma_res_arr[sep->nr_dcb_creat].out_page_array);
        kfree(lli_out_array);
 
 
 end_function_free_lli_in:
-
        kfree(sep->dma_res_arr[sep->nr_dcb_creat].in_map_array);
        kfree(sep->dma_res_arr[sep->nr_dcb_creat].in_page_array);
        kfree(lli_in_array);
 
 end_function:
-
        dev_dbg(&sep->pdev->dev,
-               "sep_prepare_input_output_dma_table"
-               " end result = %d\n", error);
+               "sep_prepare_input_output_dma_table end result = %d\n", error);
 
        return error;
 
@@ -2576,35 +2274,26 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
        bool            isapplet,
        bool            is_kva)
 {
-       /* error */
        int error = 0;
-
        /* size of tail */
        u32 tail_size = 0;
-
        /* address of the created dcb table */
        struct sep_dcblock *dcb_table_ptr = 0;
-
        /* the physical address of the first input DMA table */
        dma_addr_t in_first_mlli_address = 0;
-
        /* number of entries in the first input DMA table */
        u32  in_first_num_entries = 0;
-
        /* the physical address of the first output DMA table */
        dma_addr_t  out_first_mlli_address = 0;
-
        /* number of entries in the first output DMA table */
        u32  out_first_num_entries = 0;
-
        /* data in the first input/output table */
        u32  first_data_size = 0;
 
-       dev_dbg(&sep->pdev->dev,
-               "prepare_input_output_dma_table_in_dcb start\n");
+       dev_dbg(&sep->pdev->dev, "prepare_input_output_dma_table_in_dcb start\n");
 
        if (sep->nr_dcb_creat == SEP_MAX_NUM_SYNC_DMA_OPS) {
-               /*No more DCBS to allocate*/
+               /* No more DCBS to allocate */
                dev_warn(&sep->pdev->dev, "no more dcb's available\n");
                error = -ENOSPC;
                goto end_function;
@@ -2627,17 +2316,12 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
 
        if (isapplet == true) {
                tail_size = data_in_size % block_size;
-
                if (tail_size) {
-
                        if (data_in_size < tail_block_size) {
-                               dev_warn(&sep->pdev->dev,
-                                       "data in size smaller than tail"
-                                       "  block size\n");
+                               dev_warn(&sep->pdev->dev, "data in size smaller than tail block size\n");
                                error = -ENOSPC;
                                goto end_function;
                        }
-
                        if (tail_block_size)
                                /*
                                 * case the tail size should be
@@ -2645,7 +2329,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
                                 */
                                tail_size = tail_block_size +
                                        ((data_in_size -
-                                       tail_block_size) % block_size);
+                                               tail_block_size) % block_size);
                }
 
                /* check if there is enough data for dma operation */
@@ -2653,9 +2337,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
                        if (is_kva == true) {
                                memcpy(dcb_table_ptr->tail_data,
                                        (void *)app_in_address, data_in_size);
-                       }
-
-                       else {
+                       } else {
                                if (copy_from_user(dcb_table_ptr->tail_data,
                                        (void __user *)app_in_address,
                                        data_in_size)) {
@@ -2669,7 +2351,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
                        /* set the output user-space address for mem2mem op */
                        if (app_out_address)
                                dcb_table_ptr->out_vr_tail_pt =
-                                       (u32)app_out_address;
+                                                       (u32)app_out_address;
 
                        /*
                         * Update both data length parameters in order to avoid
@@ -2679,15 +2361,12 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
                        tail_size = 0x0;
                        data_in_size = 0x0;
                }
-
                if (tail_size) {
                        if (is_kva == true) {
                                memcpy(dcb_table_ptr->tail_data,
                                        (void *)(app_in_address + data_in_size -
                                        tail_size), tail_size);
-                       }
-
-                       else {
+                       } else {
                                /* we have tail data - copy it to dcb */
                                if (copy_from_user(dcb_table_ptr->tail_data,
                                        (void *)(app_in_address +
@@ -2696,17 +2375,16 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
                                        goto end_function;
                                }
                        }
-
                        if (app_out_address)
                                /*
-                                * Caclulate the output address
+                                * Calculate the output address
                                 * according to tail data size
                                 */
                                dcb_table_ptr->out_vr_tail_pt =
                                        app_out_address + data_in_size
                                        - tail_size;
 
-                       /*save the real tail data size*/
+                       /* Save the real tail data size */
                        dcb_table_ptr->tail_data_size = tail_size;
                        /*
                         * Update the data size without the tail
@@ -2715,7 +2393,6 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
                        data_in_size = (data_in_size - tail_size);
                }
        }
-
        /* check if we need to build only input table or input/output */
        if (app_out_address) {
                /* prepare input/output tables */
@@ -2730,9 +2407,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
                        &out_first_num_entries,
                        &first_data_size,
                        is_kva);
-       }
-
-       else {
+       } else {
                /* prepare input tables */
                error = sep_prepare_input_dma_table(sep,
                        app_in_address,
@@ -2745,8 +2420,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
        }
 
        if (error) {
-               dev_warn(&sep->pdev->dev, "prepare dma table call failed"
-                       " from prepare dcb call\n");
+               dev_warn(&sep->pdev->dev, "prepare dma table call failed from prepare dcb call\n");
                goto end_function;
        }
 
@@ -2759,7 +2433,6 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
        dcb_table_ptr->output_mlli_data_size = first_data_size;
 
 end_function:
-
        dev_dbg(&sep->pdev->dev,
                "sep_prepare_input_output_dma_table_in_dcb end\n");
        return error;
@@ -2788,28 +2461,22 @@ static int sep_create_sync_dma_tables_handler(struct sep_device *sep,
                "sep_create_sync_dma_tables_handler start\n");
 
        if (copy_from_user(&command_args, (void __user *)arg,
-               sizeof(struct bld_syn_tab_struct))) {
+                                       sizeof(struct bld_syn_tab_struct))) {
                error = -EFAULT;
-               dev_warn(&sep->pdev->dev, "create dma tables;"
-                       " copy_from_user fails\n");
                goto end_function;
        }
 
-       dev_dbg(&sep->pdev->dev,
-               "app_in_address is %08llx\n", command_args.app_in_address);
-       dev_dbg(&sep->pdev->dev,
-               "app_out_address is %08llx\n", command_args.app_out_address);
-       dev_dbg(&sep->pdev->dev,
-               "data_size is %u\n", command_args.data_in_size);
-       dev_dbg(&sep->pdev->dev,
-               "block_size is %u\n", command_args.block_size);
+       dev_dbg(&sep->pdev->dev, "app_in_address is %08llx\n",
+                                               command_args.app_in_address);
+       dev_dbg(&sep->pdev->dev, "app_out_address is %08llx\n",
+                                               command_args.app_out_address);
+       dev_dbg(&sep->pdev->dev, "data_size is %u\n",
+                                               command_args.data_in_size);
+       dev_dbg(&sep->pdev->dev, "block_size is %u\n",
+                                               command_args.block_size);
 
        /* validate user parameters */
        if (!command_args.app_in_address) {
-
-               dev_warn(&sep->pdev->dev,
-                       "params validation error\n");
-
                error = -EINVAL;
                goto end_function;
        }
@@ -2824,7 +2491,6 @@ static int sep_create_sync_dma_tables_handler(struct sep_device *sep,
                false);
 
 end_function:
-
        dev_dbg(&sep->pdev->dev, "sep_create_sync_dma_tables_handler end\n");
        return error;
 }
@@ -2840,17 +2506,14 @@ end_function:
 static int sep_free_dma_tables_and_dcb(struct sep_device *sep, bool isapplet,
        bool is_kva)
 {
-
        int i = 0;
        int error = 0;
        int error_temp = 0;
-
        struct sep_dcblock *dcb_table_ptr;
 
        dev_dbg(&sep->pdev->dev, "sep_free_dma_tables_and_dcb start\n");
 
        if (isapplet == true) {
-
                /* set pointer to first dcb table */
                dcb_table_ptr = (struct sep_dcblock *)
                        (sep->shared_addr +
@@ -2858,30 +2521,25 @@ static int sep_free_dma_tables_and_dcb(struct sep_device *sep, bool isapplet,
 
                /* go over each dcb and see if tail pointer must be updated */
                for (i = 0; i < sep->nr_dcb_creat; i++, dcb_table_ptr++) {
-
                        if (dcb_table_ptr->out_vr_tail_pt) {
-
                                if (is_kva == true) {
                                        memcpy((void *)dcb_table_ptr->out_vr_tail_pt,
                                                dcb_table_ptr->tail_data,
                                                dcb_table_ptr->tail_data_size);
-                               }
-
-                               else {
+                               } else {
                                        error_temp = copy_to_user(
                                                (void *)dcb_table_ptr->out_vr_tail_pt,
                                                dcb_table_ptr->tail_data,
                                                dcb_table_ptr->tail_data_size);
                                }
-
                                if (error_temp) {
                                        /* release the dma resource */
-                                       error = error_temp;
+                                       error = -EFAULT;
+                                       break;
                                }
                        }
                }
        }
-
        /* free the output pages, if any */
        sep_free_dma_table_data_handler(sep);
 
@@ -2901,9 +2559,7 @@ static int sep_get_static_pool_addr_handler(struct sep_device *sep,
        unsigned long arg)
 {
        struct stat_pool_addr_struct command_args;
-
        u32 *static_pool_addr = 0;
-
        unsigned long addr_hold;
 
        dev_dbg(&sep->pdev->dev, "sep_get_static_pool_addr_handler start\n");
@@ -3013,22 +2669,18 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
        struct init_struct command_args;
 
        dev_dbg(&sep->pdev->dev, "sep_init_handler start\n");
-       error = 0;
 
        /* make sure that we have not initialized already */
        reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
 
        if (reg_val != 0x2) {
                error = SEP_ALREADY_INITIALIZED_ERR;
-               dev_warn(&sep->pdev->dev,
-                       "init; device already initialized\n");
+               dev_warn(&sep->pdev->dev, "init; device already initialized\n");
                goto end_function;
        }
 
        /* only root can initialize */
        if (!capable(CAP_SYS_ADMIN)) {
-               dev_warn(&sep->pdev->dev,
-                       "init; only root can init\n");
                error = -EACCES;
                goto end_function;
        }
@@ -3038,17 +2690,13 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
                sizeof(struct init_struct));
 
        if (error) {
-               dev_warn(&sep->pdev->dev,
-                       "init; copy_from_user failed %x\n", error);
+               error = -EFAULT;
                goto end_function;
        }
 
        /* validate parameters */
        if (!command_args.message_addr || !command_args.sep_sram_addr ||
                command_args.message_size_in_words > 14) {
-
-               dev_warn(&sep->pdev->dev,
-                       "init; parameter error\n");
                error = -EINVAL;
                goto end_function;
        }
@@ -3060,9 +2708,7 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
                command_args.message_size_in_words*sizeof(u32));
 
        if (error) {
-
-               dev_warn(&sep->pdev->dev,
-                       "init; copy sep init message failed %x\n", error);
+               error = -EFAULT;
                goto end_function;
        }
 
@@ -3070,7 +2716,6 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
        error = sep_load_firmware(sep);
 
        if (error) {
-
                dev_warn(&sep->pdev->dev,
                        "init; copy sep init message failed %x\n", error);
                goto end_function;
@@ -3102,10 +2747,8 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
 
        /* debug print of message */
        for (counter = 0; counter < command_args.message_size_in_words;
-               counter++)
-
-               dev_dbg(&sep->pdev->dev,
-                       "init; sep message word %d is %x\n",
+                                                               counter++)
+               dev_dbg(&sep->pdev->dev, "init; sep message word %d is %x\n",
                        counter, message_buff[counter]);
 
        /* tell the sep the sram address */
@@ -3113,11 +2756,9 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
 
        /* push the message to the sep */
        for (counter = 0; counter < command_args.message_size_in_words;
-               counter++) {
-
+                                                               counter++) {
                sep_write_reg(sep, HW_SRAM_DATA_REG_ADDR,
-                       message_buff[counter]);
-
+                                               message_buff[counter]);
                sep_wait_sram_write(sep);
        }
 
@@ -3132,7 +2773,6 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
        while (!(reg_val & 0xFFFFFFFD));
 
        if (reg_val == 0x1) {
-
                dev_warn(&sep->pdev->dev, "init; device int failed\n");
                error = sep_read_reg(sep, 0x8060);
                dev_warn(&sep->pdev->dev, "init; sw monitor is %x\n", error);
@@ -3140,9 +2780,7 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
                dev_warn(&sep->pdev->dev, "init; error is %x\n", error);
                goto end_function;
        }
-
-       dev_dbg(&sep->pdev->dev, "init; end CC INIT, reg_val is %x\n",
-               reg_val);
+       dev_dbg(&sep->pdev->dev, "init; end CC INIT, reg_val is %x\n", reg_val);
 
        /* signal sep to zero the GPR3 */
        sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x10);
@@ -3154,7 +2792,6 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
                reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
        while (reg_val != 0);
 
-
 end_function:
        dev_dbg(&sep->pdev->dev, "init is done\n");
        return error;
@@ -3205,34 +2842,32 @@ static int sep_end_transaction_handler(struct sep_device *sep)
  *     This function will retrieve the RAR buffer physical addresses, type
  *     & size corresponding to the RAR handles provided in the buffers vector.
  */
-
 static int sep_prepare_dcb_handler(struct sep_device *sep, unsigned long arg)
 {
        /* error */
-       int error = 0;
-
+       int error;
        /* command arguments */
        struct build_dcb_struct command_args;
 
        dev_dbg(&sep->pdev->dev, "sep_prepare_dcb_handler start\n");
 
-       /* get the command arguments */
+       /* Get the command arguments */
        if (copy_from_user(&command_args, (void __user *)arg,
-               sizeof(struct build_dcb_struct))) {
+                                       sizeof(struct build_dcb_struct))) {
                error = -EFAULT;
                goto end_function;
        }
 
-       dev_dbg(&sep->pdev->dev,
-               "app_in_address is %08llx\n", command_args.app_in_address);
-       dev_dbg(&sep->pdev->dev,
-               "app_out_address is %08llx\n", command_args.app_out_address);
-       dev_dbg(&sep->pdev->dev,
-               "data_size is %x\n", command_args.data_in_size);
-       dev_dbg(&sep->pdev->dev,
-               "block_size is %x\n", command_args.block_size);
-       dev_dbg(&sep->pdev->dev,
-               "tail block_size is %x\n", command_args.tail_block_size);
+       dev_dbg(&sep->pdev->dev, "app_in_address is %08llx\n",
+                                               command_args.app_in_address);
+       dev_dbg(&sep->pdev->dev, "app_out_address is %08llx\n",
+                                               command_args.app_out_address);
+       dev_dbg(&sep->pdev->dev, "data_size is %x\n",
+                                               command_args.data_in_size);
+       dev_dbg(&sep->pdev->dev, "block_size is %x\n",
+                                               command_args.block_size);
+       dev_dbg(&sep->pdev->dev, "tail block_size is %x\n",
+                                               command_args.tail_block_size);
 
        error = sep_prepare_input_output_dma_table_in_dcb(sep,
                command_args.app_in_address, command_args.app_out_address,
@@ -3240,7 +2875,6 @@ static int sep_prepare_dcb_handler(struct sep_device *sep, unsigned long arg)
                command_args.tail_block_size, true, false);
 
 end_function:
-
        dev_dbg(&sep->pdev->dev, "sep_prepare_dcb_handler end\n");
        return error;
 
@@ -3274,52 +2908,40 @@ static int sep_free_dcb_handler(struct sep_device *sep)
  *     This function will retrieve the RAR buffer physical addresses, type
  *     & size corresponding to the RAR handles provided in the buffers vector.
  */
-
 static int sep_rar_prepare_output_msg_handler(struct sep_device *sep,
        unsigned long arg)
 {
-       /* error return code */
        int error = 0;
-
        /* command args */
        struct rar_hndl_to_bus_struct command_args;
        struct RAR_buffer rar_buf;
-
        /* bus address */
        dma_addr_t  rar_bus = 0;
-
        /* holds the RAR address in the system memory offset */
        u32 *rar_addr;
 
-       dev_dbg(&sep->pdev->dev,
-               "sep_rar_prepare_output_msg_handler start\n");
+       dev_dbg(&sep->pdev->dev, "sep_rar_prepare_output_msg_handler start\n");
 
        /* copy the data */
-       if (copy_from_user(&command_args,
-               (void __user *)arg,
-               sizeof(command_args))) {
+       if (copy_from_user(&command_args, (void __user *)arg,
+                                               sizeof(command_args))) {
                error = -EFAULT;
                goto end_function;
        }
 
        /* call to translation function only if user handle is not NULL */
        if (command_args.rar_handle) {
-
                memset(&rar_buf, 0, sizeof(rar_buf));
                rar_buf.info.handle = (u32)command_args.rar_handle;
 
                if (rar_handle_to_bus(&rar_buf, 1) != 1) {
-                       dev_dbg(&sep->pdev->dev,
-                               "rar_handle_to_bus failure\n");
+                       dev_dbg(&sep->pdev->dev, "rar_handle_to_bus failure\n");
                        error = -EFAULT;
                        goto end_function;
                }
-
                rar_bus = rar_buf.bus_address;
        }
-
-       dev_dbg(&sep->pdev->dev, "rar msg; rar_addr_bus = %x\n",
-               (u32)rar_bus);
+       dev_dbg(&sep->pdev->dev, "rar msg; rar_addr_bus = %x\n", (u32)rar_bus);
 
        /* set value in the SYSTEM MEMORY offset */
        rar_addr = (u32 *)(sep->shared_addr +
@@ -3330,10 +2952,7 @@ static int sep_rar_prepare_output_msg_handler(struct sep_device *sep,
        rar_addr[1] = rar_bus;
 
 end_function:
-
-       dev_dbg(&sep->pdev->dev,
-               "sep_rar_prepare_output_msg_handler start\n");
-
+       dev_dbg(&sep->pdev->dev, "sep_rar_prepare_output_msg_handler start\n");
        return error;
 }
 
@@ -3355,13 +2974,12 @@ static int sep_realloc_ext_cache_handler(struct sep_device *sep,
                SEP_DRIVER_SYSTEM_EXT_CACHE_ADDR_OFFSET_IN_BYTES);
 
        /* copy the physical address to the System Area for the sep */
-
        system_addr[0] = SEP_EXT_CACHE_ADDR_VAL_TOKEN;
-       dev_dbg(&sep->pdev->dev,
-               "ext cache init; system addr 0 is %x\n", system_addr[0]);
+       dev_dbg(&sep->pdev->dev, "ext cache init; system addr 0 is %x\n",
+                                                       system_addr[0]);
        system_addr[1] = sep->extapp_bus;
-       dev_dbg(&sep->pdev->dev,
-               "ext cache init; system addr 1 is %x\n", system_addr[1]);
+       dev_dbg(&sep->pdev->dev, "ext cache init; system addr 1 is %x\n",
+                                                       system_addr[1]);
 
        return 0;
 }
@@ -3410,8 +3028,7 @@ static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
        /* make sure we own this device */
        mutex_lock(&sep->sep_mutex);
        if ((current->pid != sep->pid_doing_transaction) &&
-               (sep->pid_doing_transaction != 0)) {
-
+                               (sep->pid_doing_transaction != 0)) {
                dev_dbg(&sep->pdev->dev, "ioctl pid is not owner\n");
                mutex_unlock(&sep->sep_mutex);
                error = -EACCES;
@@ -3485,15 +3102,13 @@ static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                error = sep_free_dcb_handler(sep);
                break;
        default:
-               dev_warn(&sep->pdev->dev, "invalid ioctl %x\n", cmd);
+               dev_dbg(&sep->pdev->dev, "invalid ioctl %x\n", cmd);
                error = -ENOTTY;
                break;
        }
-
        mutex_unlock(&sep->ioctl_mutex);
 
 end_function:
-
        dev_dbg(&sep->pdev->dev, "ioctl end\n");
        return error;
 }
@@ -3508,18 +3123,12 @@ end_function:
  */
 static long sep_singleton_ioctl(struct file  *filp, u32 cmd, unsigned long arg)
 {
-
        /* error */
-       long error;
+       long error = 0;
        struct sep_device *sep = filp->private_data;
 
-       error = 0;
-
-       dev_dbg(&sep->pdev->dev,
-               "singleton_ioctl start\n");
-
-       dev_dbg(&sep->pdev->dev,
-               "cmd is %x\n", cmd);
+       dev_dbg(&sep->pdev->dev, "singleton_ioctl start\n");
+       dev_dbg(&sep->pdev->dev, "cmd is %x\n", cmd);
 
        /* check that the command is for sep device */
        if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) {
@@ -3530,8 +3139,7 @@ static long sep_singleton_ioctl(struct file  *filp, u32 cmd, unsigned long arg)
        /* make sure we own this device */
        mutex_lock(&sep->sep_mutex);
        if ((current->pid != sep->pid_doing_transaction) &&
-               (sep->pid_doing_transaction != 0)) {
-
+                               (sep->pid_doing_transaction != 0)) {
                dev_dbg(&sep->pdev->dev, "singleton ioctl pid is not owner\n");
                mutex_unlock(&sep->sep_mutex);
                error = -EACCES;
@@ -3541,21 +3149,17 @@ static long sep_singleton_ioctl(struct file  *filp, u32 cmd, unsigned long arg)
        mutex_unlock(&sep->sep_mutex);
 
        switch (cmd) {
-
        case SEP_IOCTLSETCALLERID:
                mutex_lock(&sep->ioctl_mutex);
                error = sep_set_caller_id_handler(sep, arg);
                mutex_unlock(&sep->ioctl_mutex);
                break;
-
        default:
                error = sep_ioctl(filp, cmd, arg);
                break;
-
        }
 
 end_function:
-
        dev_dbg(&sep->pdev->dev, "singleton ioctl end\n");
        return error;
 }
@@ -3568,20 +3172,15 @@ end_function:
  *
  *     Called by the request daemon to perform ioctls on the daemon device
  */
-
 static long sep_request_daemon_ioctl(struct file *filp, u32 cmd,
        unsigned long arg)
 {
 
        long error;
-
        struct sep_device *sep = filp->private_data;
 
-       dev_dbg(&sep->pdev->dev,
-               "daemon ioctl: start\n");
-
-       dev_dbg(&sep->pdev->dev,
-               "daemon ioctl: cmd is %x\n", cmd);
+       dev_dbg(&sep->pdev->dev, "daemon ioctl: start\n");
+       dev_dbg(&sep->pdev->dev, "daemon ioctl: cmd is %x\n", cmd);
 
        /* check that the command is for sep device */
        if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) {
@@ -3594,13 +3193,10 @@ static long sep_request_daemon_ioctl(struct file *filp, u32 cmd,
 
        switch (cmd) {
        case SEP_IOCSENDSEPRPLYCOMMAND:
-
                /* send reply command to SEP */
                error = sep_req_daemon_send_reply_command_handler(sep);
                break;
-
        case SEP_IOCENDTRANSACTION:
-
                /*
                 * end req daemon transaction, do nothing
                 * will be removed upon update in middleware
@@ -3608,19 +3204,14 @@ static long sep_request_daemon_ioctl(struct file *filp, u32 cmd,
                 */
                error = 0;
                break;
-
        default:
-               dev_dbg(&sep->pdev->dev,
-               "daemon ioctl: no such IOCTL\n");
+               dev_dbg(&sep->pdev->dev, "daemon ioctl: no such IOCTL\n");
                error = -ENOTTY;
        }
-
        mutex_unlock(&sep->ioctl_mutex);
 
 end_function:
-
-       dev_dbg(&sep->pdev->dev,
-               "daemon ioctl: end\n");
+       dev_dbg(&sep->pdev->dev, "daemon ioctl: end\n");
        return error;
 
 }
@@ -3630,7 +3221,6 @@ end_function:
  *     @irq: interrupt
  *     @dev_id: device id
  */
-
 static irqreturn_t sep_inthandler(int irq, void *dev_id)
 {
        irqreturn_t int_error = IRQ_HANDLED;
@@ -3640,18 +3230,16 @@ static irqreturn_t sep_inthandler(int irq, void *dev_id)
 
        /* read the IRR register to check if this is SEP interrupt */
        reg_val = sep_read_reg(sep, HW_HOST_IRR_REG_ADDR);
-       dev_dbg(&sep->pdev->dev,
-               "SEP Interrupt - reg is %08x\n", reg_val);
+       dev_dbg(&sep->pdev->dev, "SEP Interrupt - reg is %08x\n", reg_val);
 
        if (reg_val & (0x1 << 13)) {
-
                /* lock and update the counter of reply messages */
                spin_lock_irqsave(&sep->snd_rply_lck, lck_flags);
                sep->reply_ct++;
                spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags);
 
                dev_dbg(&sep->pdev->dev, "sep int: send_ct %lx reply_ct %lx\n",
-                       sep->send_ct, sep->reply_ct);
+                                       sep->send_ct, sep->reply_ct);
 
                /* is this printf or daemon request? */
                reg_val2 = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR2_REG_ADDR);
@@ -3659,27 +3247,19 @@ static irqreturn_t sep_inthandler(int irq, void *dev_id)
                        "SEP Interrupt - reg2 is %08x\n", reg_val2);
 
                if ((reg_val2 >> 30) & 0x1) {
-
                        dev_dbg(&sep->pdev->dev, "int: printf request\n");
                        wake_up(&sep->event_request_daemon);
-               }
-
-               else if (reg_val2 >> 31) {
-
+               } else if (reg_val2 >> 31) {
                        dev_dbg(&sep->pdev->dev, "int: daemon request\n");
                        wake_up(&sep->event_request_daemon);
                } else {
-
                        dev_dbg(&sep->pdev->dev, "int: sep reply\n");
                        wake_up(&sep->event);
                }
-
        } else {
-
                dev_dbg(&sep->pdev->dev, "int: not sep interrupt\n");
                int_error = IRQ_NONE;
        }
-
        if (int_error == IRQ_HANDLED)
                sep_write_reg(sep, HW_HOST_ICR_REG_ADDR, reg_val);
 
@@ -3695,16 +3275,14 @@ static irqreturn_t sep_inthandler(int irq, void *dev_id)
  */
 static int sep_callback(unsigned long sep_context_pointer)
 {
-       int error = 0;
-       struct sep_device *sep =
-               (struct sep_device *)sep_context_pointer;
-
-       dma_addr_t rar_end_address = 0;
+       int error;
+       struct sep_device *sep = (struct sep_device *)sep_context_pointer;
+       dma_addr_t rar_end_address;
 
        dev_dbg(&sep->pdev->dev, "callback start\n");
 
        error = rar_get_address(RAR_TYPE_IMAGE, &sep->rar_bus,
-               &rar_end_address);
+                                                       &rar_end_address);
 
        if (error) {
                dev_warn(&sep->pdev->dev, "mrst cant get rar region\n");
@@ -3714,9 +3292,9 @@ static int sep_callback(unsigned long sep_context_pointer)
        sep->rar_size = (size_t)(rar_end_address - sep->rar_bus + 1);
 
        if (!request_mem_region(sep->rar_bus, sep->rar_size,
-               "sep_sec_driver")) {
+                                                       "sep_sec_driver")) {
                dev_warn(&sep->pdev->dev,
-                       "request mem region for mrst failed\n");
+                               "request mem region for mrst failed\n");
                error = -1;
                goto end_function;
        }
@@ -3724,18 +3302,15 @@ static int sep_callback(unsigned long sep_context_pointer)
        sep->rar_addr = ioremap_nocache(sep->rar_bus, sep->rar_size);
        if (!sep->rar_addr) {
                dev_warn(&sep->pdev->dev,
-                       "ioremap nocache for mrst rar failed\n");
-               error = -1;
+                               "ioremap nocache for mrst rar failed\n");
+               error = -ENOMEM;
                goto end_function;
        }
-
-       dev_dbg(&sep->pdev->dev, "rar start is %p, phy is %llx,"
-               " size is %x\n",
-               sep->rar_addr, (unsigned long long)sep->rar_bus,
-               sep->rar_size);
+       dev_dbg(&sep->pdev->dev, "rar start is %p, phy is %llx, size is %x\n",
+                       sep->rar_addr, (unsigned long long)sep->rar_bus,
+                       sep->rar_size);
 
 end_function:
-
        dev_dbg(&sep->pdev->dev, "callback end\n");
        return error;
 }
@@ -3769,7 +3344,6 @@ static int __devinit sep_probe(struct pci_dev *pdev,
 
        /* allocate the sep_device structure for this device */
        sep_dev = kmalloc(sizeof(struct sep_device), GFP_ATOMIC);
-
        if (sep_dev == NULL) {
                dev_warn(&pdev->dev,
                        "can't kmalloc the sep_device structure\n");
@@ -3865,8 +3439,7 @@ static int __devinit sep_probe(struct pci_dev *pdev,
                        sep->rar_size);
        }
 
-       dev_dbg(&sep->pdev->dev,
-               "about to write IMR and ICR REG_ADDR\n");
+       dev_dbg(&sep->pdev->dev, "about to write IMR and ICR REG_ADDR\n");
 
        /* clear ICR register */
        sep_write_reg(sep, HW_HOST_ICR_REG_ADDR, 0xFFFFFFFF);
@@ -3874,18 +3447,14 @@ static int __devinit sep_probe(struct pci_dev *pdev,
        /* set the IMR register - open only GPR 2 */
        sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13)));
 
-       dev_dbg(&sep->pdev->dev,
-               "about to call request_irq\n");
+       dev_dbg(&sep->pdev->dev, "about to call request_irq\n");
        /* get the interrupt line */
        error = request_irq(pdev->irq, sep_inthandler, IRQF_SHARED,
                "sep_driver", sep);
 
-       if (error)
-               goto end_function_free_res;
-
-       goto end_function;
+       if (!error)
+               goto end_function;
 
-end_function_free_res:
        if (sep->rar_addr)
                dma_free_coherent(&sep->pdev->dev, sep->rar_size,
                        sep->rar_addr, sep->rar_bus);
@@ -3959,37 +3528,29 @@ static const struct file_operations sep_file_operations = {
  */
 static int sep_reconfig_shared_area(struct sep_device *sep)
 {
-       int ret_val = 0;
+       int ret_val;
 
        dev_dbg(&sep->pdev->dev, "reconfig shared area start\n");
 
        /* send the new SHARED MESSAGE AREA to the SEP */
        dev_dbg(&sep->pdev->dev, "sending %08llx to sep\n",
-               (unsigned long long)sep->shared_bus);
+                               (unsigned long long)sep->shared_bus);
 
-       sep_write_reg(sep, HW_HOST_HOST_SEP_GPR1_REG_ADDR,
-               sep->shared_bus);
+       sep_write_reg(sep, HW_HOST_HOST_SEP_GPR1_REG_ADDR, sep->shared_bus);
 
        /* poll for SEP response */
        ret_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR1_REG_ADDR);
 
-       while (ret_val != 0xffffffff &&
-               ret_val != sep->shared_bus) {
-
-               ret_val = sep_read_reg(sep,
-                 HW_HOST_SEP_HOST_GPR1_REG_ADDR);
-       }
+       while (ret_val != 0xffffffff && ret_val != sep->shared_bus)
+               ret_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR1_REG_ADDR);
 
        /* check the return value (register) */
        if (ret_val != sep->shared_bus) {
                dev_warn(&sep->pdev->dev, "could not reconfig shared area\n");
                dev_warn(&sep->pdev->dev, "result was %x\n", ret_val);
                ret_val = -ENOMEM;
-       }
-
-       else {
+       } else
                ret_val = 0;
-       }
 
        dev_dbg(&sep->pdev->dev, "reconfig shared area end\n");
        return ret_val;
@@ -4003,7 +3564,7 @@ static int sep_reconfig_shared_area(struct sep_device *sep)
  */
 static int sep_register_driver_to_fs(struct sep_device *sep)
 {
-       int ret_val = 0;
+       int ret_val;
 
        sep->miscdev_sep.minor = MISC_DYNAMIC_MINOR;
        sep->miscdev_sep.name = SEP_DEV_NAME;
@@ -4035,8 +3596,7 @@ static int sep_register_driver_to_fs(struct sep_device *sep)
        if (!sep->mrst) {
                ret_val = misc_register(&sep->miscdev_daemon);
                if (ret_val) {
-                       dev_warn(&sep->pdev->dev,
-                               "misc reg fails for dmn %x\n",
+                       dev_warn(&sep->pdev->dev, "misc reg fails for dmn %x\n",
                                ret_val);
                        misc_deregister(&sep->miscdev_sep);
                        misc_deregister(&sep->miscdev_singleton);
@@ -4044,7 +3604,6 @@ static int sep_register_driver_to_fs(struct sep_device *sep)
                        return ret_val;
                }
        }
-
        return ret_val;
 }
 
@@ -4062,8 +3621,8 @@ static int __init sep_init(void)
 
        ret_val = pci_register_driver(&sep_pci_driver);
        if (ret_val) {
-               pr_debug("sep_driver:sep_driver_to_device failed,"
-                       " ret_val is %d\n", ret_val);
+               pr_debug("sep_driver:sep_driver_to_device failed, ret_val is %d\n",
+                                                               ret_val);
                goto end_function;
        }
 
@@ -4085,11 +3644,9 @@ static int __init sep_init(void)
        /* register driver to fs */
        ret_val = sep_register_driver_to_fs(sep);
        if (ret_val) {
-               dev_warn(&sep->pdev->dev,
-                       "error registering device to file\n");
+               dev_warn(&sep->pdev->dev, "error registering device to file\n");
                goto end_function_unregister_pci;
        }
-
        goto end_function;
 
 end_function_unregister_pci: