Skip to content

L
linux
Commit 6eb44c53 authored by Alan Cox's avatar Alan Cox Committed by Greg Kroah-Hartman
Browse files
Options

Staging: sep: Make SEP consistent 

SEP is initials so make it consistent in the driver, ditto DMA and DCB
Consistent capitalisation of comment leads
Signed-off-by: default avatarAlan Cox <alan@linux.intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 7c9eb691
Show whitespace changes
Inline Side-by-side
Showing with 313 additions and 318 deletions
drivers/staging/sep/sep_driver.c
View file @ 6eb44c53
...@@ -92,7 +92,7 @@ static int sep_load_firmware(struct sep_device *sep) ...@@ -92,7 +92,7 @@ static int sep_load_firmware(struct sep_device *sep)
int error ; int error ;
unsigned int work1, work2, work3; unsigned int work1, work2, work3;
/* set addresses and load resident */ /* Set addresses and load resident */
sep->resident_bus = sep->rar_bus; sep->resident_bus = sep->rar_bus;
sep->resident_addr = sep->rar_addr; sep->resident_addr = sep->rar_addr;
...@@ -113,7 +113,7 @@ static int sep_load_firmware(struct sep_device *sep) ...@@ -113,7 +113,7 @@ static int sep_load_firmware(struct sep_device *sep)
dev_dbg(&sep->pdev->dev, "resident size is %08x\n", dev_dbg(&sep->pdev->dev, "resident size is %08x\n",
sep->resident_size); sep->resident_size);
/* set addresses for dcache (no loading needed) */ /* Set addresses for dcache (no loading needed) */
work1 = (unsigned int)sep->resident_bus; work1 = (unsigned int)sep->resident_bus;
work2 = (unsigned int)sep->resident_size; work2 = (unsigned int)sep->resident_size;
work3 = (work1 + work2 + (1024 * 4)) & 0xfffff000; work3 = (work1 + work2 + (1024 * 4)) & 0xfffff000;
...@@ -126,7 +126,7 @@ static int sep_load_firmware(struct sep_device *sep) ...@@ -126,7 +126,7 @@ static int sep_load_firmware(struct sep_device *sep)
sep->dcache_size = 1024 * 128; sep->dcache_size = 1024 * 128;
/* set addresses and load cache */ /* Set addresses and load cache */
sep->cache_bus = sep->dcache_bus + sep->dcache_size; sep->cache_bus = sep->dcache_bus + sep->dcache_size;
sep->cache_addr = sep->dcache_addr + sep->dcache_size; sep->cache_addr = sep->dcache_addr + sep->dcache_size;
...@@ -147,7 +147,7 @@ static int sep_load_firmware(struct sep_device *sep) ...@@ -147,7 +147,7 @@ static int sep_load_firmware(struct sep_device *sep)
dev_dbg(&sep->pdev->dev, "cache size is %08x\n", dev_dbg(&sep->pdev->dev, "cache size is %08x\n",
sep->cache_size); sep->cache_size);
/* set addresses and load extapp */ /* Set addresses and load extapp */
sep->extapp_bus = sep->cache_bus + (1024 * 370); sep->extapp_bus = sep->cache_bus + (1024 * 370);
sep->extapp_addr = sep->cache_addr + (1024 * 370); sep->extapp_addr = sep->cache_addr + (1024 * 370);
...@@ -177,7 +177,7 @@ MODULE_FIRMWARE("sep/extapp.image.bin"); ...@@ -177,7 +177,7 @@ MODULE_FIRMWARE("sep/extapp.image.bin");
/** /**
* sep_dump_message - dump the message that is pending * sep_dump_message - dump the message that is pending
* @sep: sep device * @sep: SEP device
*/ */
static void sep_dump_message(struct sep_device *sep) static void sep_dump_message(struct sep_device *sep)
{ {
...@@ -205,7 +205,7 @@ static int sep_map_and_alloc_shared_area(struct sep_device *sep) ...@@ -205,7 +205,7 @@ static int sep_map_and_alloc_shared_area(struct sep_device *sep)
return -ENOMEM; return -ENOMEM;
} }
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
"sep: shared_addr %x bytes @%p (bus %llx)\n", "shared_addr %x bytes @%p (bus %llx)\n",
sep->shared_size, sep->shared_addr, sep->shared_size, sep->shared_addr,
(unsigned long long)sep->shared_bus); (unsigned long long)sep->shared_bus);
return 0; return 0;
...@@ -249,7 +249,7 @@ static int sep_singleton_open(struct inode *inode_ptr, struct file *file_ptr) ...@@ -249,7 +249,7 @@ static int sep_singleton_open(struct inode *inode_ptr, struct file *file_ptr)
struct sep_device *sep; struct sep_device *sep;
/* /*
* Get the sep device structure and use it for the * Get the SEP device structure and use it for the
* private_data field in filp for other methods * private_data field in filp for other methods
*/ */
sep = sep_dev; sep = sep_dev;
...@@ -274,8 +274,8 @@ static int sep_singleton_open(struct inode *inode_ptr, struct file *file_ptr) ...@@ -274,8 +274,8 @@ static int sep_singleton_open(struct inode *inode_ptr, struct file *file_ptr)
/** /**
* sep_open - device open method * sep_open - device open method
* @inode: inode of sep device * @inode: inode of SEP device
* @filp: file handle to sep device * @filp: file handle to SEP device
* *
* Open method for the SEP device. Called when userspace opens * Open method for the SEP device. Called when userspace opens
* the SEP device node. * the SEP device node.
...@@ -287,7 +287,7 @@ static int sep_open(struct inode *inode, struct file *filp) ...@@ -287,7 +287,7 @@ static int sep_open(struct inode *inode, struct file *filp)
struct sep_device *sep; struct sep_device *sep;
/* /*
* Get the sep device structure and use it for the * Get the SEP device structure and use it for the
* private_data field in filp for other methods * private_data field in filp for other methods
*/ */
sep = sep_dev; sep = sep_dev;
...@@ -320,8 +320,8 @@ static int sep_singleton_release(struct inode *inode, struct file *filp) ...@@ -320,8 +320,8 @@ static int sep_singleton_release(struct inode *inode, struct file *filp)
/** /**
* sep_request_daemonopen - request daemon open method * sep_request_daemonopen - request daemon open method
* @inode: inode of sep device * @inode: inode of SEP device
* @filp: file handle to sep device * @filp: file handle to SEP device
* *
* Open method for the SEP request daemon. Called when * Open method for the SEP request daemon. Called when
* request daemon in userspace opens the SEP device node. * request daemon in userspace opens the SEP device node.
...@@ -359,7 +359,7 @@ static int sep_request_daemon_release(struct inode *inode, struct file *filp) ...@@ -359,7 +359,7 @@ static int sep_request_daemon_release(struct inode *inode, struct file *filp)
dev_dbg(&sep->pdev->dev, "Reques daemon release for pid %d\n", dev_dbg(&sep->pdev->dev, "Reques daemon release for pid %d\n",
current->pid); current->pid);
/* clear the request_daemon_open flag */ /* Clear the request_daemon_open flag */
clear_bit(0, &sep->request_daemon_open); clear_bit(0, &sep->request_daemon_open);
return 0; return 0;
} }
...@@ -380,12 +380,12 @@ static int sep_req_daemon_send_reply_command_handler(struct sep_device *sep) ...@@ -380,12 +380,12 @@ static int sep_req_daemon_send_reply_command_handler(struct sep_device *sep)
sep_dump_message(sep); sep_dump_message(sep);
/* counters are lockable region */ /* Counters are lockable region */
spin_lock_irqsave(&sep->snd_rply_lck, lck_flags); spin_lock_irqsave(&sep->snd_rply_lck, lck_flags);
sep->send_ct++; sep->send_ct++;
sep->reply_ct++; sep->reply_ct++;
/* send the interrupt to SEP */ /* Send the interrupt to SEP */
sep_write_reg(sep, HW_HOST_HOST_SEP_GPR2_REG_ADDR, sep_write_reg(sep, HW_HOST_HOST_SEP_GPR2_REG_ADDR,
sep->send_ct); sep->send_ct);
...@@ -408,13 +408,13 @@ static int sep_req_daemon_send_reply_command_handler(struct sep_device *sep) ...@@ -408,13 +408,13 @@ static int sep_req_daemon_send_reply_command_handler(struct sep_device *sep)
* sep_free_dma_table_data_handler - free DMA table * sep_free_dma_table_data_handler - free DMA table
* @sep: pointere to struct sep_device * @sep: pointere to struct sep_device
* *
* Handles the request to free dma table for synchronic actions * Handles the request to free DMA table for synchronic actions
*/ */
static int sep_free_dma_table_data_handler(struct sep_device *sep) static int sep_free_dma_table_data_handler(struct sep_device *sep)
{ {
int count; int count;
int dcb_counter; int dcb_counter;
/* pointer to the current dma_resource struct */ /* Pointer to the current dma_resource struct */
struct sep_dma_resource *dma; struct sep_dma_resource *dma;
dev_dbg(&sep->pdev->dev, "sep_free_dma_table_data_handler start\n"); dev_dbg(&sep->pdev->dev, "sep_free_dma_table_data_handler start\n");
...@@ -422,7 +422,7 @@ static int sep_free_dma_table_data_handler(struct sep_device *sep) ...@@ -422,7 +422,7 @@ static int sep_free_dma_table_data_handler(struct sep_device *sep)
for (dcb_counter = 0; dcb_counter < sep->nr_dcb_creat; dcb_counter++) { for (dcb_counter = 0; dcb_counter < sep->nr_dcb_creat; dcb_counter++) {
dma = &sep->dma_res_arr[dcb_counter]; dma = &sep->dma_res_arr[dcb_counter];
/* unmap and free input map array */ /* Unmap and free input map array */
if (dma->in_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_unmap_page(&sep->pdev->dev,
...@@ -433,7 +433,7 @@ static int sep_free_dma_table_data_handler(struct sep_device *sep) ...@@ -433,7 +433,7 @@ static int sep_free_dma_table_data_handler(struct sep_device *sep)
kfree(dma->in_map_array); kfree(dma->in_map_array);
} }
/* unmap output map array, DON'T free it yet */ /* Unmap output map array, DON'T free it yet */
if (dma->out_map_array) { 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_unmap_page(&sep->pdev->dev,
...@@ -444,7 +444,7 @@ static int sep_free_dma_table_data_handler(struct sep_device *sep) ...@@ -444,7 +444,7 @@ static int sep_free_dma_table_data_handler(struct sep_device *sep)
kfree(dma->out_map_array); kfree(dma->out_map_array);
} }
/* free page cache for output */ /* Free page cache for output */
if (dma->in_page_array) { 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]); flush_dcache_page(dma->in_page_array[count]);
...@@ -463,7 +463,7 @@ static int sep_free_dma_table_data_handler(struct sep_device *sep) ...@@ -463,7 +463,7 @@ static int sep_free_dma_table_data_handler(struct sep_device *sep)
kfree(dma->out_page_array); kfree(dma->out_page_array);
} }
/* reset all the values */ /* Reset all the values */
dma->in_page_array = 0; dma->in_page_array = 0;
dma->out_page_array = 0; dma->out_page_array = 0;
dma->in_num_pages = 0; dma->in_num_pages = 0;
...@@ -503,7 +503,7 @@ static int sep_request_daemon_mmap(struct file *filp, ...@@ -503,7 +503,7 @@ static int sep_request_daemon_mmap(struct file *filp,
goto end_function; goto end_function;
} }
/* get physical address */ /* Get physical address */
bus_address = sep->shared_bus; bus_address = sep->shared_bus;
dev_dbg(&sep->pdev->dev, "bus_address is %08lx\n", dev_dbg(&sep->pdev->dev, "bus_address is %08lx\n",
...@@ -524,7 +524,7 @@ static int sep_request_daemon_mmap(struct file *filp, ...@@ -524,7 +524,7 @@ static int sep_request_daemon_mmap(struct file *filp,
/** /**
* sep_request_daemon_poll - poll implementation * sep_request_daemon_poll - poll implementation
* @sep: struct sep_device * for current sep device * @sep: struct sep_device * for current SEP device
* @filp: struct file * for open file * @filp: struct file * for open file
* @wait: poll_table * for poll * @wait: poll_table * for poll
* *
...@@ -547,7 +547,7 @@ static unsigned int sep_request_daemon_poll(struct file *filp, ...@@ -547,7 +547,7 @@ static unsigned int sep_request_daemon_poll(struct file *filp,
sep->send_ct, sep->reply_ct); sep->send_ct, sep->reply_ct);
spin_lock_irqsave(&sep->snd_rply_lck, lck_flags); spin_lock_irqsave(&sep->snd_rply_lck, lck_flags);
/* check if the data is ready */ /* Check if the data is ready */
if (sep->send_ct == sep->reply_ct) { if (sep->send_ct == sep->reply_ct) {
spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags); spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags);
...@@ -555,13 +555,13 @@ static unsigned int sep_request_daemon_poll(struct file *filp, ...@@ -555,13 +555,13 @@ static unsigned int sep_request_daemon_poll(struct file *filp,
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
"daemon poll: data check (GPR2) is %x\n", retval2); "daemon poll: data check (GPR2) is %x\n", retval2);
/* check if PRINT request */ /* Check if PRINT request */
if ((retval2 >> 30) & 0x1) { 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; mask |= POLLIN;
goto end_function; goto end_function;
} }
/* check if NVS request */ /* Check if NVS request */
if (retval2 >> 31) { 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; mask |= POLLPRI | POLLWRNORM;
...@@ -591,7 +591,7 @@ static int sep_release(struct inode *inode, struct file *filp) ...@@ -591,7 +591,7 @@ static int sep_release(struct inode *inode, struct file *filp)
dev_dbg(&sep->pdev->dev, "Release for pid %d\n", current->pid); dev_dbg(&sep->pdev->dev, "Release for pid %d\n", current->pid);
mutex_lock(&sep->sep_mutex); mutex_lock(&sep->sep_mutex);
/* is this the process that has a transaction open? /* Is this the process that has a transaction open?
* If so, lets reset pid_doing_transaction to 0 and * If so, lets reset pid_doing_transaction to 0 and
* clear the in use flags, and then wake up sep_event * clear the in use flags, and then wake up sep_event
* so that other processes can do transactions * so that other processes can do transactions
...@@ -614,7 +614,7 @@ static int sep_release(struct inode *inode, struct file *filp) ...@@ -614,7 +614,7 @@ static int sep_release(struct inode *inode, struct file *filp)
* @filp: pointer to struct file * @filp: pointer to struct file
* @vma: pointer to vm_area_struct * @vma: pointer to vm_area_struct
* *
* Called on an mmap of our space via the normal sep device * Called on an mmap of our space via the normal SEP device
*/ */
static int sep_mmap(struct file *filp, struct vm_area_struct *vma) static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
{ {
...@@ -636,8 +636,8 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma) ...@@ -636,8 +636,8 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
/* /*
* The pid_doing_transaction indicates that this process * The pid_doing_transaction indicates that this process
* now owns the facilities to performa a transaction with * now owns the facilities to performa a transaction with
* the sep. While this process is performing a transaction, * the SEP. While this process is performing a transaction,
* no other process who has the sep device open can perform * no other process who has the SEP device open can perform
* any transactions. This method allows more than one process * any transactions. This method allows more than one process
* to have the device open at any given time, which provides * to have the device open at any given time, which provides
* finer granularity for device utilization by multiple * finer granularity for device utilization by multiple
...@@ -647,12 +647,12 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma) ...@@ -647,12 +647,12 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
sep->pid_doing_transaction = current->pid; sep->pid_doing_transaction = current->pid;
mutex_unlock(&sep->sep_mutex); mutex_unlock(&sep->sep_mutex);
/* zero the pools and the number of data pool alocation pointers */ /* Zero the pools and the number of data pool alocation pointers */
sep->data_pool_bytes_allocated = 0; sep->data_pool_bytes_allocated = 0;
sep->num_of_data_allocations = 0; sep->num_of_data_allocations = 0;
/* /*
* check that the size of the mapped range is as the size of the message * Check that the size of the mapped range is as the size of the message
* shared area * shared area
*/ */
if ((vma->vm_end - vma->vm_start) > SEP_DRIVER_MMMAP_AREA_SIZE) { if ((vma->vm_end - vma->vm_start) > SEP_DRIVER_MMMAP_AREA_SIZE) {
...@@ -662,7 +662,7 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma) ...@@ -662,7 +662,7 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
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 */ /* Get bus address */
bus_addr = sep->shared_bus; bus_addr = sep->shared_bus;
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
...@@ -678,13 +678,13 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma) ...@@ -678,13 +678,13 @@ static int sep_mmap(struct file *filp, struct vm_area_struct *vma)
goto end_function; goto end_function;
end_function_with_error: end_function_with_error:
/* clear the bit */ /* Clear the bit */
clear_bit(SEP_MMAP_LOCK_BIT, &sep->in_use_flags); clear_bit(SEP_MMAP_LOCK_BIT, &sep->in_use_flags);
mutex_lock(&sep->sep_mutex); mutex_lock(&sep->sep_mutex);
sep->pid_doing_transaction = 0; sep->pid_doing_transaction = 0;
mutex_unlock(&sep->sep_mutex); mutex_unlock(&sep->sep_mutex);
/* raise event for stuck contextes */ /* Raise event for stuck contextes */
dev_warn(&sep->pdev->dev, "mmap error - waking up event\n"); dev_warn(&sep->pdev->dev, "mmap error - waking up event\n");
wake_up(&sep->event); wake_up(&sep->event);
...@@ -722,14 +722,14 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait) ...@@ -722,14 +722,14 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
} }
mutex_unlock(&sep->sep_mutex); mutex_unlock(&sep->sep_mutex);
/* check if send command or send_reply were activated previously */ /* Check if send command or send_reply were activated previously */
if (!test_bit(SEP_SEND_MSG_LOCK_BIT, &sep->in_use_flags)) { if (!test_bit(SEP_SEND_MSG_LOCK_BIT, &sep->in_use_flags)) {
dev_warn(&sep->pdev->dev, "poll; lock bit set\n"); dev_warn(&sep->pdev->dev, "poll; lock bit set\n");
mask = POLLERR; mask = POLLERR;
goto end_function; goto end_function;
} }
/* add the event to the polling wait table */ /* Add the event to the polling wait table */
dev_dbg(&sep->pdev->dev, "poll: calling wait sep_event\n"); dev_dbg(&sep->pdev->dev, "poll: calling wait sep_event\n");
poll_wait(filp, &sep->event, wait); poll_wait(filp, &sep->event, wait);
...@@ -737,7 +737,7 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait) ...@@ -737,7 +737,7 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
dev_dbg(&sep->pdev->dev, "poll: send_ct is %lx reply ct is %lx\n", dev_dbg(&sep->pdev->dev, "poll: send_ct is %lx reply ct is %lx\n",
sep->send_ct, sep->reply_ct); sep->send_ct, sep->reply_ct);
/* check if error occured during poll */ /* Check if error occured during poll */
retval2 = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR); retval2 = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
if (retval2 != 0x0) { 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);
...@@ -753,25 +753,24 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait) ...@@ -753,25 +753,24 @@ static unsigned int sep_poll(struct file *filp, poll_table *wait)
dev_dbg(&sep->pdev->dev, "poll: data ready check (GPR2) %x\n", dev_dbg(&sep->pdev->dev, "poll: data ready check (GPR2) %x\n",
retval); retval);
/* check if printf request */ /* Check if printf request */
if ((retval >> 30) & 0x1) { if ((retval >> 30) & 0x1) {
dev_dbg(&sep->pdev->dev, "poll: sep printf request\n"); dev_dbg(&sep->pdev->dev, "poll: SEP printf request\n");
wake_up(&sep->event_request_daemon); wake_up(&sep->event_request_daemon);
goto end_function; goto end_function;
} }
/* check if the this is sep reply or request */ /* Check if the this is SEP reply or request */
if (retval >> 31) { if (retval >> 31) {
dev_dbg(&sep->pdev->dev, "poll: sep request\n"); dev_dbg(&sep->pdev->dev, "poll: SEP request\n");
wake_up(&sep->event_request_daemon); wake_up(&sep->event_request_daemon);
} else { } else {
dev_dbg(&sep->pdev->dev, "poll: normal return\n"); dev_dbg(&sep->pdev->dev, "poll: normal return\n");
/* in case it is again by send_reply_comand */ /* In case it is again by send_reply_comand */
clear_bit(SEP_SEND_MSG_LOCK_BIT, &sep->in_use_flags); clear_bit(SEP_SEND_MSG_LOCK_BIT, &sep->in_use_flags);
sep_dump_message(sep); sep_dump_message(sep);
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
"poll; sep reply POLLIN | POLLRDNORM\n"); "poll; SEP reply POLLIN | POLLRDNORM\n");
mask |= POLLIN | POLLRDNORM; mask |= POLLIN | POLLRDNORM;
} }
} else { } else {
...@@ -803,19 +802,19 @@ static u32 *sep_time_address(struct sep_device *sep) ...@@ -803,19 +802,19 @@ static u32 *sep_time_address(struct sep_device *sep)
* @sep: the SEP we are setting the time for * @sep: the SEP we are setting the time for
* *
* Calculates time and sets it at the predefined address. * Calculates time and sets it at the predefined address.
* Called with the sep mutex held. * Called with the SEP mutex held.
*/ */
static unsigned long sep_set_time(struct sep_device *sep) static unsigned long sep_set_time(struct sep_device *sep)
{ {
struct timeval time; struct timeval time;
u32 *time_addr; /* address of time as seen by the kernel */ 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_set_time start\n");
do_gettimeofday(&time); do_gettimeofday(&time);
/* set value in the SYSTEM MEMORY offset */ /* Set value in the SYSTEM MEMORY offset */
time_addr = sep_time_address(sep); time_addr = sep_time_address(sep);
time_addr[0] = SEP_TIME_VAL_TOKEN; time_addr[0] = SEP_TIME_VAL_TOKEN;
...@@ -830,7 +829,7 @@ static unsigned long sep_set_time(struct sep_device *sep) ...@@ -830,7 +829,7 @@ static unsigned long sep_set_time(struct sep_device *sep)
/** /**
* sep_set_caller_id_handler - insert caller id entry * sep_set_caller_id_handler - insert caller id entry
* @sep: sep device * @sep: SEP device
* @arg: pointer to struct caller_id_struct * @arg: pointer to struct caller_id_struct
* *
* Inserts the data into the caller id table. Note that this function * Inserts the data into the caller id table. Note that this function
...@@ -858,7 +857,7 @@ static int sep_set_caller_id_handler(struct sep_device *sep, u32 arg) ...@@ -858,7 +857,7 @@ static int sep_set_caller_id_handler(struct sep_device *sep, u32 arg)
goto end_function; goto end_function;
} }
/* copy the data */ /* Copy the data */
if (copy_from_user(&command_args, (void __user *)arg, if (copy_from_user(&command_args, (void __user *)arg,
sizeof(command_args))) { sizeof(command_args))) {
error = -EFAULT; error = -EFAULT;
...@@ -894,9 +893,9 @@ static int sep_set_caller_id_handler(struct sep_device *sep, u32 arg) ...@@ -894,9 +893,9 @@ static int sep_set_caller_id_handler(struct sep_device *sep, u32 arg)
/** /**
* sep_set_current_caller_id - set the caller id * sep_set_current_caller_id - set the caller id
* @sep: pointer to struct_sep * @sep: pointer to struct_sep_device
* *
* Set the caller ID (if it exists) to the sep. Note that this * Set the caller ID (if it exists) to the SEP. Note that this
* function falls under the ioctl lock * function falls under the ioctl lock
*/ */
static int sep_set_current_caller_id(struct sep_device *sep) static int sep_set_current_caller_id(struct sep_device *sep)
...@@ -906,7 +905,7 @@ static int sep_set_current_caller_id(struct sep_device *sep) ...@@ -906,7 +905,7 @@ static int sep_set_current_caller_id(struct sep_device *sep)
dev_dbg(&sep->pdev->dev, "sep_set_current_caller_id start\n"); dev_dbg(&sep->pdev->dev, "sep_set_current_caller_id start\n");
dev_dbg(&sep->pdev->dev, "current process is %d\n", current->pid); dev_dbg(&sep->pdev->dev, "current process is %d\n", current->pid);
/* zero the previous value */ /* Zero the previous value */
memset(sep->shared_addr + SEP_CALLER_ID_OFFSET_BYTES, memset(sep->shared_addr + SEP_CALLER_ID_OFFSET_BYTES,
0, SEP_CALLER_ID_HASH_SIZE_IN_BYTES); 0, SEP_CALLER_ID_HASH_SIZE_IN_BYTES);
...@@ -926,7 +925,7 @@ static int sep_set_current_caller_id(struct sep_device *sep) ...@@ -926,7 +925,7 @@ static int sep_set_current_caller_id(struct sep_device *sep)
/** /**
* sep_send_command_handler - kick off a command * sep_send_command_handler - kick off a command
* @sep: sep being signalled * @sep: SEP being signalled
* *
* This function raises interrupt to SEP that signals that is has a new * This function raises interrupt to SEP that signals that is has a new
* command from the host * command from the host
...@@ -946,13 +945,13 @@ static int sep_send_command_handler(struct sep_device *sep) ...@@ -946,13 +945,13 @@ static int sep_send_command_handler(struct sep_device *sep)
} }
sep_set_time(sep); sep_set_time(sep);
/* only Medfield has caller id */ /* Only Medfield has caller id */
if (sep->mrst == 0) if (sep->mrst == 0)
sep_set_current_caller_id(sep); sep_set_current_caller_id(sep);
sep_dump_message(sep); sep_dump_message(sep);
/* update counter */ /* Update counter */
spin_lock_irqsave(&sep->snd_rply_lck, lck_flags); spin_lock_irqsave(&sep->snd_rply_lck, lck_flags);
sep->send_ct++; sep->send_ct++;
spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags); spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags);
...@@ -961,7 +960,7 @@ static int sep_send_command_handler(struct sep_device *sep) ...@@ -961,7 +960,7 @@ static int sep_send_command_handler(struct sep_device *sep)
"sep_send_command_handler send_ct %lx reply_ct %lx\n", "sep_send_command_handler send_ct %lx reply_ct %lx\n",
sep->send_ct, sep->reply_ct); sep->send_ct, sep->reply_ct);
/* send interrupt to SEP */ /* Send interrupt to SEP */
sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2); sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2);
end_function: end_function:
...@@ -971,7 +970,7 @@ static int sep_send_command_handler(struct sep_device *sep) ...@@ -971,7 +970,7 @@ static int sep_send_command_handler(struct sep_device *sep)
/** /**
* sep_allocate_data_pool_memory_handler -allocate pool memory * sep_allocate_data_pool_memory_handler -allocate pool memory
* @sep: pointer to struct_sep * @sep: pointer to struct sep_device
* @arg: pointer to struct alloc_struct * @arg: pointer to struct alloc_struct
* *
* This function handles the allocate data pool memory request * This function handles the allocate data pool memory request
...@@ -1016,7 +1015,7 @@ static int sep_allocate_data_pool_memory_handler(struct sep_device *sep, ...@@ -1016,7 +1015,7 @@ static int sep_allocate_data_pool_memory_handler(struct sep_device *sep,
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
"command_args.offset: %x\n", command_args.offset); "command_args.offset: %x\n", command_args.offset);
/* Place in the shared area that is known by the sep */ /* Place in the shared area that is known by the SEP */
token_addr = (u32 *)(sep->shared_addr + token_addr = (u32 *)(sep->shared_addr +
SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES + SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES +
(sep->num_of_data_allocations)*2*sizeof(u32)); (sep->num_of_data_allocations)*2*sizeof(u32));
...@@ -1043,7 +1042,7 @@ static int sep_allocate_data_pool_memory_handler(struct sep_device *sep, ...@@ -1043,7 +1042,7 @@ static int sep_allocate_data_pool_memory_handler(struct sep_device *sep,
goto end_function; goto end_function;
} }
/* update the allocation */ /* Update the allocation */
sep->data_pool_bytes_allocated += command_args.num_bytes; sep->data_pool_bytes_allocated += command_args.num_bytes;
sep->num_of_data_allocations += 1; sep->num_of_data_allocations += 1;
...@@ -1079,9 +1078,9 @@ static int sep_lock_kernel_pages(struct sep_device *sep, ...@@ -1079,9 +1078,9 @@ static int sep_lock_kernel_pages(struct sep_device *sep,
{ {
int error = 0; int error = 0;
/* array of lli */ /* Array of lli */
struct sep_lli_entry *lli_array; struct sep_lli_entry *lli_array;
/* map array */ /* Map array */
struct sep_dma_map *map_array; struct sep_dma_map *map_array;
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
...@@ -1110,7 +1109,7 @@ static int sep_lock_kernel_pages(struct sep_device *sep, ...@@ -1110,7 +1109,7 @@ static int sep_lock_kernel_pages(struct sep_device *sep,
/* /*
* set the start address of the first page - app data may start not at * Set the start address of the first page - app data may start not at
* the beginning of the page * the beginning of the page
*/ */
lli_array[0].bus_address = (u32)map_array[0].dma_addr; lli_array[0].bus_address = (u32)map_array[0].dma_addr;
...@@ -1121,7 +1120,7 @@ static int sep_lock_kernel_pages(struct sep_device *sep, ...@@ -1121,7 +1120,7 @@ static int sep_lock_kernel_pages(struct sep_device *sep,
(unsigned long)lli_array[0].bus_address, (unsigned long)lli_array[0].bus_address,
lli_array[0].block_size); lli_array[0].block_size);
/* set the output parameters */ /* Set the output parameters */
if (in_out_flag == SEP_DRIVER_IN_FLAG) { if (in_out_flag == SEP_DRIVER_IN_FLAG) {
*lli_array_ptr = lli_array; *lli_array_ptr = lli_array;
sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages = 1; sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages = 1;
...@@ -1168,25 +1167,25 @@ static int sep_lock_user_pages(struct sep_device *sep, ...@@ -1168,25 +1167,25 @@ static int sep_lock_user_pages(struct sep_device *sep,
int error = 0; int error = 0;
u32 count; u32 count;
int result; int result;
/* the the page of the end address of the user space buffer */ /* The the page of the end address of the user space buffer */
u32 end_page; u32 end_page;
/* the page of the start address of the user space buffer */ /* The page of the start address of the user space buffer */
u32 start_page; u32 start_page;
/* the range in pages */ /* The range in pages */
u32 num_pages; u32 num_pages;
/* array of pointers to page */ /* Array of pointers to page */
struct page **page_array; struct page **page_array;
/* array of lli */ /* Array of lli */
struct sep_lli_entry *lli_array; struct sep_lli_entry *lli_array;
/* map array */ /* Map array */
struct sep_dma_map *map_array; struct sep_dma_map *map_array;
/* direction of the DMA mapping for locked pages */ /* Direction of the DMA mapping for locked pages */
enum dma_data_direction dir; enum dma_data_direction dir;
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
"sep_lock_user_pages start\n"); "sep_lock_user_pages start\n");
/* set start and end pages and num pages */ /* Set start and end pages and num pages */
end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT; end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT;
start_page = app_virt_addr >> PAGE_SHIFT; start_page = app_virt_addr >> PAGE_SHIFT;
num_pages = end_page - start_page + 1; num_pages = end_page - start_page + 1;
...@@ -1199,7 +1198,7 @@ static int sep_lock_user_pages(struct sep_device *sep, ...@@ -1199,7 +1198,7 @@ static int sep_lock_user_pages(struct sep_device *sep,
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 */ /* Allocate array of pages structure pointers */
page_array = kmalloc(sizeof(struct page *) * num_pages, GFP_ATOMIC); page_array = kmalloc(sizeof(struct page *) * num_pages, GFP_ATOMIC);
if (!page_array) { if (!page_array) {
error = -ENOMEM; error = -ENOMEM;
...@@ -1223,7 +1222,7 @@ static int sep_lock_user_pages(struct sep_device *sep, ...@@ -1223,7 +1222,7 @@ static int sep_lock_user_pages(struct sep_device *sep,
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 */ /* Convert the application virtual address into a set of physical */
down_read(&current->mm->mmap_sem); down_read(&current->mm->mmap_sem);
result = get_user_pages(current, current->mm, app_virt_addr, result = get_user_pages(current, current->mm, app_virt_addr,
num_pages, num_pages,
...@@ -1232,7 +1231,7 @@ static int sep_lock_user_pages(struct sep_device *sep, ...@@ -1232,7 +1231,7 @@ static int sep_lock_user_pages(struct sep_device *sep,
up_read(&current->mm->mmap_sem); up_read(&current->mm->mmap_sem);
/* check the number of pages locked - if not all then exit with error */ /* Check the number of pages locked - if not all then exit with error */
if (result != num_pages) { if (result != num_pages) {
dev_warn(&sep->pdev->dev, dev_warn(&sep->pdev->dev,
"not all pages locked by get_user_pages\n"); "not all pages locked by get_user_pages\n");
...@@ -1242,26 +1241,25 @@ static int sep_lock_user_pages(struct sep_device *sep, ...@@ -1242,26 +1241,25 @@ static int sep_lock_user_pages(struct sep_device *sep,
dev_dbg(&sep->pdev->dev, "get_user_pages succeeded\n"); dev_dbg(&sep->pdev->dev, "get_user_pages succeeded\n");
/* set direction */ /* Set direction */
if (in_out_flag == SEP_DRIVER_IN_FLAG) if (in_out_flag == SEP_DRIVER_IN_FLAG)
dir = DMA_TO_DEVICE; dir = DMA_TO_DEVICE;
else else
dir = DMA_FROM_DEVICE; dir = DMA_FROM_DEVICE;
/* /*
* fill the array using page array data and * Fill the array using page array data and
* map the pages - this action * map the pages - this action will also flush the cache as needed
* will also flush the cache as needed
*/ */
for (count = 0; count < num_pages; count++) { for (count = 0; count < num_pages; count++) {
/* fill the map array */ /* Fill the map array */
map_array[count].dma_addr = map_array[count].dma_addr =
dma_map_page(&sep->pdev->dev, page_array[count], dma_map_page(&sep->pdev->dev, page_array[count],
0, PAGE_SIZE, /*dir*/DMA_BIDIRECTIONAL); 0, PAGE_SIZE, /*dir*/DMA_BIDIRECTIONAL);
map_array[count].size = PAGE_SIZE; map_array[count].size = PAGE_SIZE;
/* fill the lli array entry */ /* Fill the lli array entry */
lli_array[count].bus_address = (u32)map_array[count].dma_addr; lli_array[count].bus_address = (u32)map_array[count].dma_addr;
lli_array[count].block_size = PAGE_SIZE; lli_array[count].block_size = PAGE_SIZE;
...@@ -1270,11 +1268,11 @@ static int sep_lock_user_pages(struct sep_device *sep, ...@@ -1270,11 +1268,11 @@ static int sep_lock_user_pages(struct sep_device *sep,
count, lli_array[count].block_size); count, lli_array[count].block_size);
} }
/* check the offset for the first page */ /* Check the offset for the first page */
lli_array[0].bus_address = lli_array[0].bus_address =
lli_array[0].bus_address + (app_virt_addr & (~PAGE_MASK)); lli_array[0].bus_address + (app_virt_addr & (~PAGE_MASK));
/* check that not all the data is in the first page only */ /* Check that not all the data is in the first page only */
if ((PAGE_SIZE - (app_virt_addr & (~PAGE_MASK))) >= data_size) if ((PAGE_SIZE - (app_virt_addr & (~PAGE_MASK))) >= data_size)
lli_array[0].block_size = data_size; lli_array[0].block_size = data_size;
else else
...@@ -1286,7 +1284,7 @@ static int sep_lock_user_pages(struct sep_device *sep, ...@@ -1286,7 +1284,7 @@ static int sep_lock_user_pages(struct sep_device *sep,
(unsigned long)lli_array[count].bus_address, (unsigned long)lli_array[count].bus_address,
lli_array[count].block_size); lli_array[count].block_size);
/* check the size of the last page */ /* Check the size of the last page */
if (num_pages > 1) { if (num_pages > 1) {
lli_array[num_pages - 1].block_size = lli_array[num_pages - 1].block_size =
(app_virt_addr + data_size) & (~PAGE_MASK); (app_virt_addr + data_size) & (~PAGE_MASK);
...@@ -1299,7 +1297,7 @@ static int sep_lock_user_pages(struct sep_device *sep, ...@@ -1299,7 +1297,7 @@ static int sep_lock_user_pages(struct sep_device *sep,
lli_array[count].block_size); lli_array[count].block_size);
} }
/* set output params acording to the in_out flag */ /* Set output params acording to the in_out flag */
if (in_out_flag == SEP_DRIVER_IN_FLAG) { if (in_out_flag == SEP_DRIVER_IN_FLAG) {
*lli_array_ptr = lli_array; *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_num_pages = num_pages;
...@@ -1319,14 +1317,14 @@ static int sep_lock_user_pages(struct sep_device *sep, ...@@ -1319,14 +1317,14 @@ static int sep_lock_user_pages(struct sep_device *sep,
goto end_function; goto end_function;
end_function_with_error3: end_function_with_error3:
/* free lli array */ /* Free lli array */
kfree(lli_array); kfree(lli_array);
end_function_with_error2: end_function_with_error2:
kfree(map_array); kfree(map_array);
end_function_with_error1: end_function_with_error1:
/* free page array */ /* Free page array */
kfree(page_array); kfree(page_array);
end_function: end_function:
...@@ -1352,15 +1350,15 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep, ...@@ -1352,15 +1350,15 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep,
u32 *last_table_flag) u32 *last_table_flag)
{ {
u32 counter; u32 counter;
/* table data size */ /* Table data size */
u32 table_data_size = 0; u32 table_data_size = 0;
/* data size for the next table */ /* Data size for the next table */
u32 next_table_data_size; u32 next_table_data_size;
*last_table_flag = 0; *last_table_flag = 0;
/* /*
* calculate the data in the out lli table till we fill the whole * Calculate the data in the out lli table till we fill the whole
* table or till the data has ended * table or till the data has ended
*/ */
for (counter = 0; for (counter = 0;
...@@ -1369,20 +1367,19 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep, ...@@ -1369,20 +1367,19 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep,
table_data_size += lli_in_array_ptr[counter].block_size; table_data_size += lli_in_array_ptr[counter].block_size;
/* /*
* check if we reached the last entry, * Check if we reached the last entry,
* meaning this ia the last table to build, * meaning this ia the last table to build,
* and no need to check the block alignment * and no need to check the block alignment
*/ */
if (counter == num_array_entries) { if (counter == num_array_entries) {
/* set the last table flag */ /* Set the last table flag */
*last_table_flag = 1; *last_table_flag = 1;
goto end_function; goto end_function;
} }
/* /*
* calculate the data size of the next table. * Calculate the data size of the next table.
* Stop if no entries left or * Stop if no entries left or if data size is more the DMA restriction
* if data size is more the DMA restriction
*/ */
next_table_data_size = 0; next_table_data_size = 0;
for (; counter < num_array_entries; counter++) { for (; counter < num_array_entries; counter++) {
...@@ -1392,7 +1389,7 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep, ...@@ -1392,7 +1389,7 @@ static u32 sep_calculate_lli_table_max_size(struct sep_device *sep,
} }
/* /*
* check if the next table data size is less then DMA rstriction. * Check if the next table data size is less then DMA rstriction.
* if it is - recalculate the current table size, so that the next * if it is - recalculate the current table size, so that the next
* table data size will be adaquete for DMA * table data size will be adaquete for DMA
*/ */
...@@ -1427,23 +1424,23 @@ static void sep_build_lli_table(struct sep_device *sep, ...@@ -1427,23 +1424,23 @@ static void sep_build_lli_table(struct sep_device *sep,
u32 *num_table_entries_ptr, u32 *num_table_entries_ptr,
u32 table_data_size) u32 table_data_size)
{ {
/* current table data size */ /* Current table data size */
u32 curr_table_data_size; u32 curr_table_data_size;
/* counter of lli array entry */ /* Counter of lli array entry */
u32 array_counter; 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 */ /* Init currrent table data size and lli array entry counter */
curr_table_data_size = 0; curr_table_data_size = 0;
array_counter = 0; array_counter = 0;
*num_table_entries_ptr = 1; *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 */ /* Fill the table till table size reaches the needed amount */
while (curr_table_data_size < table_data_size) { while (curr_table_data_size < table_data_size) {
/* update the number of entries in table */ /* Update the number of entries in table */
(*num_table_entries_ptr)++; (*num_table_entries_ptr)++;
lli_table_ptr->bus_address = lli_table_ptr->bus_address =
...@@ -1461,24 +1458,24 @@ static void sep_build_lli_table(struct sep_device *sep, ...@@ -1461,24 +1458,24 @@ static void sep_build_lli_table(struct sep_device *sep,
dev_dbg(&sep->pdev->dev, "lli_table_ptr->block_size is %x\n", dev_dbg(&sep->pdev->dev, "lli_table_ptr->block_size is %x\n",
lli_table_ptr->block_size); lli_table_ptr->block_size);
/* check for overflow of the table data */ /* Check for overflow of the table data */
if (curr_table_data_size > table_data_size) { if (curr_table_data_size > table_data_size) {
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
"curr_table_data_size too large\n"); "curr_table_data_size too large\n");
/* update the size of block in the table */ /* Update the size of block in the table */
lli_table_ptr->block_size -= lli_table_ptr->block_size -=
cpu_to_le32((curr_table_data_size - table_data_size)); cpu_to_le32((curr_table_data_size - table_data_size));
/* update the physical address in the lli array */ /* Update the physical address in the lli array */
lli_array_ptr[array_counter].bus_address += lli_array_ptr[array_counter].bus_address +=
cpu_to_le32(lli_table_ptr->block_size); cpu_to_le32(lli_table_ptr->block_size);
/* update the block size left in the lli array */ /* Update the block size left in the lli array */
lli_array_ptr[array_counter].block_size = lli_array_ptr[array_counter].block_size =
(curr_table_data_size - table_data_size); (curr_table_data_size - table_data_size);
} else } else
/* advance to the next entry in the lli_array */ /* Advance to the next entry in the lli_array */
array_counter++; array_counter++;
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
...@@ -1488,11 +1485,11 @@ static void sep_build_lli_table(struct sep_device *sep, ...@@ -1488,11 +1485,11 @@ static void sep_build_lli_table(struct sep_device *sep,
"lli_table_ptr->block_size is %x\n", "lli_table_ptr->block_size is %x\n",
lli_table_ptr->block_size); lli_table_ptr->block_size);
/* move to the next entry in table */ /* Move to the next entry in table */
lli_table_ptr++; lli_table_ptr++;
} }
/* set the info entry to default */ /* Set the info entry to default */
lli_table_ptr->bus_address = 0xffffffff; lli_table_ptr->bus_address = 0xffffffff;
lli_table_ptr->block_size = 0; lli_table_ptr->block_size = 0;
...@@ -1502,7 +1499,7 @@ static void sep_build_lli_table(struct sep_device *sep, ...@@ -1502,7 +1499,7 @@ static void sep_build_lli_table(struct sep_device *sep,
dev_dbg(&sep->pdev->dev, "lli_table_ptr->block_size is %x\n", dev_dbg(&sep->pdev->dev, "lli_table_ptr->block_size is %x\n",
lli_table_ptr->block_size); lli_table_ptr->block_size);
/* set the output parameter */ /* Set the output parameter */
*num_processed_entries_ptr += array_counter; *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",
...@@ -1578,7 +1575,7 @@ static void sep_debug_print_lli_tables(struct sep_device *sep, ...@@ -1578,7 +1575,7 @@ static void sep_debug_print_lli_tables(struct sep_device *sep,
dev_dbg(&sep->pdev->dev, "num_table_entries is %lu\n", dev_dbg(&sep->pdev->dev, "num_table_entries is %lu\n",
num_table_entries); num_table_entries);
/* print entries of the table (without info entry) */ /* Print entries of the table (without info entry) */
for (entries_count = 0; entries_count < num_table_entries; for (entries_count = 0; entries_count < num_table_entries;
entries_count++, lli_table_ptr++) { entries_count++, lli_table_ptr++) {
...@@ -1591,7 +1588,7 @@ static void sep_debug_print_lli_tables(struct sep_device *sep, ...@@ -1591,7 +1588,7 @@ static void sep_debug_print_lli_tables(struct sep_device *sep,
(unsigned long)lli_table_ptr->bus_address, (unsigned long)lli_table_ptr->bus_address,
lli_table_ptr->block_size); lli_table_ptr->block_size);
} }
/* point to the info entry */ /* Point to the info entry */
lli_table_ptr--; lli_table_ptr--;
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
...@@ -1642,7 +1639,7 @@ static void sep_prepare_empty_lli_table(struct sep_device *sep, ...@@ -1642,7 +1639,7 @@ static void sep_prepare_empty_lli_table(struct sep_device *sep,
dev_dbg(&sep->pdev->dev, "sep_prepare_empty_lli_table start\n"); dev_dbg(&sep->pdev->dev, "sep_prepare_empty_lli_table start\n");
/* find the area for new table */ /* Find the area for new table */
lli_table_ptr = lli_table_ptr =
(struct sep_lli_entry *)(sep->shared_addr + (struct sep_lli_entry *)(sep->shared_addr +
SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES + SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES +
...@@ -1656,18 +1653,18 @@ static void sep_prepare_empty_lli_table(struct sep_device *sep, ...@@ -1656,18 +1653,18 @@ static void sep_prepare_empty_lli_table(struct sep_device *sep,
lli_table_ptr->bus_address = 0xFFFFFFFF; lli_table_ptr->bus_address = 0xFFFFFFFF;
lli_table_ptr->block_size = 0; lli_table_ptr->block_size = 0;
/* set the output parameter value */ /* Set the output parameter value */
*lli_table_addr_ptr = sep->shared_bus + *lli_table_addr_ptr = sep->shared_bus +
SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES + SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES +
sep->num_lli_tables_created * sep->num_lli_tables_created *
sizeof(struct sep_lli_entry) * sizeof(struct sep_lli_entry) *
SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP;
/* set the num of entries and table data size for empty table */ /* Set the num of entries and table data size for empty table */
*num_entries_ptr = 2; *num_entries_ptr = 2;
*table_data_size_ptr = 0; *table_data_size_ptr = 0;
/* update the number of created tables */ /* Update the number of created tables */
sep->num_lli_tables_created++; sep->num_lli_tables_created++;
dev_dbg(&sep->pdev->dev, "sep_prepare_empty_lli_table start\n"); dev_dbg(&sep->pdev->dev, "sep_prepare_empty_lli_table start\n");
...@@ -1686,7 +1683,7 @@ static void sep_prepare_empty_lli_table(struct sep_device *sep, ...@@ -1686,7 +1683,7 @@ static void sep_prepare_empty_lli_table(struct sep_device *sep,
* *
* This function prepares only input DMA table for synhronic symmetric * This function prepares only input DMA table for synhronic symmetric
* operations (HASH) * operations (HASH)
* Note that all bus addresses that are passed to the sep * Note that all bus addresses that are passed to the SEP
* are in 32 bit format; the SEP is a 32 bit device * are in 32 bit format; the SEP is a 32 bit device
*/ */
static int sep_prepare_input_dma_table(struct sep_device *sep, static int sep_prepare_input_dma_table(struct sep_device *sep,
...@@ -1699,54 +1696,54 @@ static int sep_prepare_input_dma_table(struct sep_device *sep, ...@@ -1699,54 +1696,54 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
bool is_kva) bool is_kva)
{ {
int error = 0; int error = 0;
/* pointer to the info entry of the table - the last entry */ /* Pointer to the info entry of the table - the last entry */
struct sep_lli_entry *info_entry_ptr; struct sep_lli_entry *info_entry_ptr;
/* array of pointers to page */ /* Array of pointers to page */
struct sep_lli_entry *lli_array_ptr; struct sep_lli_entry *lli_array_ptr;
/* points to the first entry to be processed in the lli_in_array */ /* Points to the first entry to be processed in the lli_in_array */
u32 current_entry = 0; u32 current_entry = 0;
/* num entries in the virtual buffer */ /* Num entries in the virtual buffer */
u32 sep_lli_entries = 0; u32 sep_lli_entries = 0;
/* lli table pointer */ /* Lli table pointer */
struct sep_lli_entry *in_lli_table_ptr; struct sep_lli_entry *in_lli_table_ptr;
/* the total data in one table */ /* The total data in one table */
u32 table_data_size = 0; u32 table_data_size = 0;
/* flag for last table */ /* Flag for last table */
u32 last_table_flag = 0; u32 last_table_flag = 0;
/* number of entries in lli table */ /* Number of entries in lli table */
u32 num_entries_in_table = 0; u32 num_entries_in_table = 0;
/* next table address */ /* Next table address */
u32 lli_table_alloc_addr = 0; u32 lli_table_alloc_addr = 0;
dev_dbg(&sep->pdev->dev, "sep_prepare_input_dma_table start\n"); 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, "data_size is %x\n", data_size);
dev_dbg(&sep->pdev->dev, "block_size is %x\n", block_size); dev_dbg(&sep->pdev->dev, "block_size is %x\n", block_size);
/* initialize the pages pointers */ /* Initialize the pages pointers */
sep->dma_res_arr[sep->nr_dcb_creat].in_page_array = 0; sep->dma_res_arr[sep->nr_dcb_creat].in_page_array = 0;
sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages = 0; sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages = 0;
/* set the kernel address for first table to be allocated */ /* Set the kernel address for first table to be allocated */
lli_table_alloc_addr = (u32)(sep->shared_addr + lli_table_alloc_addr = (u32)(sep->shared_addr +
SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES + 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); SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
if (data_size == 0) { if (data_size == 0) {
/* special case - create meptu table - 2 entries, zero data */ /* Special case - create meptu table - 2 entries, zero data */
sep_prepare_empty_lli_table(sep, lli_table_ptr, 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; goto update_dcb_counter;
} }
/* check if the pages are in Kernel Virtual Address layout */ /* Check if the pages are in Kernel Virtual Address layout */
if (is_kva == true) if (is_kva == true)
/* lock the pages in the kernel */ /* Lock the pages in the kernel */
error = sep_lock_kernel_pages(sep, app_virt_addr, error = sep_lock_kernel_pages(sep, app_virt_addr,
data_size, &lli_array_ptr, SEP_DRIVER_IN_FLAG); data_size, &lli_array_ptr, SEP_DRIVER_IN_FLAG);
else else
/* /*
* lock the pages of the user buffer * Lock the pages of the user buffer
* and translate them to pages * and translate them to pages
*/ */
error = sep_lock_user_pages(sep, app_virt_addr, error = sep_lock_user_pages(sep, app_virt_addr,
...@@ -1763,10 +1760,10 @@ static int sep_prepare_input_dma_table(struct sep_device *sep, ...@@ -1763,10 +1760,10 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
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 */ /* Loop till all the entries in in array are not processed */
while (current_entry < sep_lli_entries) { while (current_entry < sep_lli_entries) {
/* set the new input and output tables */ /* Set the new input and output tables */
in_lli_table_ptr = in_lli_table_ptr =
(struct sep_lli_entry *)lli_table_alloc_addr; (struct sep_lli_entry *)lli_table_alloc_addr;
...@@ -1783,17 +1780,17 @@ static int sep_prepare_input_dma_table(struct sep_device *sep, ...@@ -1783,17 +1780,17 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
} }
/* update the number of created tables */ /* Update the number of created tables */
sep->num_lli_tables_created++; sep->num_lli_tables_created++;
/* calculate the maximum size of data for input table */ /* Calculate the maximum size of data for input table */
table_data_size = sep_calculate_lli_table_max_size(sep, table_data_size = sep_calculate_lli_table_max_size(sep,
&lli_array_ptr[current_entry], &lli_array_ptr[current_entry],
(sep_lli_entries - current_entry), (sep_lli_entries - current_entry),
&last_table_flag); &last_table_flag);
/* /*
* if this is not the last table - * If this is not the last table -
* then allign it to the block size * then allign it to the block size
*/ */
if (!last_table_flag) if (!last_table_flag)
...@@ -1803,14 +1800,14 @@ static int sep_prepare_input_dma_table(struct sep_device *sep, ...@@ -1803,14 +1800,14 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
dev_dbg(&sep->pdev->dev, "output table_data_size is %x\n", dev_dbg(&sep->pdev->dev, "output table_data_size is %x\n",
table_data_size); table_data_size);
/* construct input lli table */ /* Construct input lli table */
sep_build_lli_table(sep, &lli_array_ptr[current_entry], sep_build_lli_table(sep, &lli_array_ptr[current_entry],
in_lli_table_ptr, in_lli_table_ptr,
&current_entry, &num_entries_in_table, table_data_size); &current_entry, &num_entries_in_table, table_data_size);
if (info_entry_ptr == 0) { if (info_entry_ptr == 0) {
/* set the output parameters to physical addresses */ /* Set the output parameters to physical addresses */
*lli_table_ptr = sep_shared_area_virt_to_bus(sep, *lli_table_ptr = sep_shared_area_virt_to_bus(sep,
in_lli_table_ptr); in_lli_table_ptr);
*num_entries_ptr = num_entries_in_table; *num_entries_ptr = num_entries_in_table;
...@@ -1821,7 +1818,7 @@ static int sep_prepare_input_dma_table(struct sep_device *sep, ...@@ -1821,7 +1818,7 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
(unsigned long)*lli_table_ptr); (unsigned long)*lli_table_ptr);
} else { } else {
/* update the info entry of the previous in table */ /* Update the info entry of the previous in table */
info_entry_ptr->bus_address = info_entry_ptr->bus_address =
sep_shared_area_virt_to_bus(sep, sep_shared_area_virt_to_bus(sep,
in_lli_table_ptr); in_lli_table_ptr);
...@@ -1829,23 +1826,23 @@ static int sep_prepare_input_dma_table(struct sep_device *sep, ...@@ -1829,23 +1826,23 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
((num_entries_in_table) << 24) | ((num_entries_in_table) << 24) |
(table_data_size); (table_data_size);
} }
/* save the pointer to the info entry of the current tables */ /* Save the pointer to the info entry of the current tables */
info_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1; info_entry_ptr = in_lli_table_ptr + num_entries_in_table - 1;
} }
/* print input tables */ /* Print input tables */
sep_debug_print_lli_tables(sep, (struct sep_lli_entry *) sep_debug_print_lli_tables(sep, (struct sep_lli_entry *)
sep_shared_area_bus_to_virt(sep, *lli_table_ptr), 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 */ /* The array of the pages */
kfree(lli_array_ptr); kfree(lli_array_ptr);
update_dcb_counter: update_dcb_counter:
/* update dcb counter */ /* Update DCB counter */
sep->nr_dcb_creat++; sep->nr_dcb_creat++;
goto end_function; goto end_function;
end_function_error: end_function_error:
/* free all the allocated resources */ /* Free all the allocated resources */
kfree(sep->dma_res_arr[sep->nr_dcb_creat].in_map_array); kfree(sep->dma_res_arr[sep->nr_dcb_creat].in_map_array);
kfree(lli_array_ptr); kfree(lli_array_ptr);
kfree(sep->dma_res_arr[sep->nr_dcb_creat].in_page_array); kfree(sep->dma_res_arr[sep->nr_dcb_creat].in_page_array);
...@@ -1857,7 +1854,7 @@ static int sep_prepare_input_dma_table(struct sep_device *sep, ...@@ -1857,7 +1854,7 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
} }
/** /**
* sep_construct_dma_tables_from_lli - prepare AES/DES mappings * sep_construct_dma_tables_from_lli - prepare AES/DES mappings
* @sep: pointer to struct_sep * @sep: pointer to struct sep_device
* @lli_in_array: * @lli_in_array:
* @sep_in_lli_entries: * @sep_in_lli_entries:
* @lli_out_array: * @lli_out_array:
...@@ -1869,10 +1866,10 @@ static int sep_prepare_input_dma_table(struct sep_device *sep, ...@@ -1869,10 +1866,10 @@ static int sep_prepare_input_dma_table(struct sep_device *sep,
* @out_num_entries_ptr * @out_num_entries_ptr
* @table_data_size_ptr * @table_data_size_ptr
* *
* This function creates the input and output dma tables for * This function creates the input and output DMA tables for
* symmetric operations (AES/DES) according to the block * symmetric operations (AES/DES) according to the block
* size from LLI arays * size from LLI arays
* Note that all bus addresses that are passed to the sep * Note that all bus addresses that are passed to the SEP
* are in 32 bit format; the SEP is a 32 bit device * are in 32 bit format; the SEP is a 32 bit device
*/ */
static int sep_construct_dma_tables_from_lli( static int sep_construct_dma_tables_from_lli(
...@@ -1888,56 +1885,56 @@ static int sep_construct_dma_tables_from_lli( ...@@ -1888,56 +1885,56 @@ static int sep_construct_dma_tables_from_lli(
u32 *out_num_entries_ptr, u32 *out_num_entries_ptr,
u32 *table_data_size_ptr) u32 *table_data_size_ptr)
{ {
/* points to the area where next lli table can be allocated */ /* Points to the area where next lli table can be allocated */
u32 lli_table_alloc_addr = 0; u32 lli_table_alloc_addr = 0;
/* input lli table */ /* Input lli table */
struct sep_lli_entry *in_lli_table_ptr = 0; struct sep_lli_entry *in_lli_table_ptr = 0;
/* output lli table */ /* Output lli table */
struct sep_lli_entry *out_lli_table_ptr = 0; struct sep_lli_entry *out_lli_table_ptr = 0;
/* pointer to the info entry of the table - the last entry */ /* Pointer to the info entry of the table - the last entry */
struct sep_lli_entry *info_in_entry_ptr = 0; struct sep_lli_entry *info_in_entry_ptr = 0;
/* pointer to the info entry of the table - the last entry */ /* Pointer to the info entry of the table - the last entry */
struct sep_lli_entry *info_out_entry_ptr = 0; struct sep_lli_entry *info_out_entry_ptr = 0;
/* points to the first entry to be processed in the lli_in_array */ /* Points to the first entry to be processed in the lli_in_array */
u32 current_in_entry = 0; u32 current_in_entry = 0;
/* points to the first entry to be processed in the lli_out_array */ /* Points to the first entry to be processed in the lli_out_array */
u32 current_out_entry = 0; u32 current_out_entry = 0;
/* max size of the input table */ /* Max size of the input table */
u32 in_table_data_size = 0; u32 in_table_data_size = 0;
/* max size of the output table */ /* Max size of the output table */
u32 out_table_data_size = 0; u32 out_table_data_size = 0;
/* flag te signifies if this is the last tables build */ /* Flag te signifies if this is the last tables build */
u32 last_table_flag = 0; u32 last_table_flag = 0;
/* the data size that should be in table */ /* The data size that should be in table */
u32 table_data_size = 0; u32 table_data_size = 0;
/* number of etnries in the input table */ /* Number of etnries in the input table */
u32 num_entries_in_table = 0; u32 num_entries_in_table = 0;
/* number of etnries in the output table */ /* Number of etnries in the output table */
u32 num_entries_out_table = 0; 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 */ /* Initiate to point after the message area */
lli_table_alloc_addr = (u32)(sep->shared_addr + lli_table_alloc_addr = (u32)(sep->shared_addr +
SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES + SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES +
(sep->num_lli_tables_created * (sep->num_lli_tables_created *
(sizeof(struct sep_lli_entry) * (sizeof(struct sep_lli_entry) *
SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP))); SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP)));
/* loop till all the entries in in array are not processed */ /* Loop till all the entries in in array are not processed */
while (current_in_entry < sep_in_lli_entries) { while (current_in_entry < sep_in_lli_entries) {
/* set the new input and output tables */ /* Set the new input and output tables */
in_lli_table_ptr = in_lli_table_ptr =
(struct sep_lli_entry *)lli_table_alloc_addr; (struct sep_lli_entry *)lli_table_alloc_addr;
lli_table_alloc_addr += sizeof(struct sep_lli_entry) * lli_table_alloc_addr += sizeof(struct sep_lli_entry) *
SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP;
/* set the first output tables */ /* Set the first output tables */
out_lli_table_ptr = out_lli_table_ptr =
(struct sep_lli_entry *)lli_table_alloc_addr; (struct sep_lli_entry *)lli_table_alloc_addr;
/* check if the DMA table area limit was overrun */ /* Check if the DMA table area limit was overrun */
if ((lli_table_alloc_addr + sizeof(struct sep_lli_entry) * if ((lli_table_alloc_addr + sizeof(struct sep_lli_entry) *
SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP) > SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP) >
((u32)sep->shared_addr + ((u32)sep->shared_addr +
...@@ -1948,20 +1945,20 @@ static int sep_construct_dma_tables_from_lli( ...@@ -1948,20 +1945,20 @@ static int sep_construct_dma_tables_from_lli(
return -ENOMEM; return -ENOMEM;
} }
/* update the number of the lli tables created */ /* Update the number of the lli tables created */
sep->num_lli_tables_created += 2; sep->num_lli_tables_created += 2;
lli_table_alloc_addr += sizeof(struct sep_lli_entry) * lli_table_alloc_addr += sizeof(struct sep_lli_entry) *
SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP; SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP;
/* calculate the maximum size of data for input table */ /* Calculate the maximum size of data for input table */
in_table_data_size = in_table_data_size =
sep_calculate_lli_table_max_size(sep, sep_calculate_lli_table_max_size(sep,
&lli_in_array[current_in_entry], &lli_in_array[current_in_entry],
(sep_in_lli_entries - current_in_entry), (sep_in_lli_entries - current_in_entry),
&last_table_flag); &last_table_flag);
/* calculate the maximum size of data for output table */ /* Calculate the maximum size of data for output table */
out_table_data_size = out_table_data_size =
sep_calculate_lli_table_max_size(sep, sep_calculate_lli_table_max_size(sep,
&lli_out_array[current_out_entry], &lli_out_array[current_out_entry],
...@@ -1980,7 +1977,7 @@ static int sep_construct_dma_tables_from_lli( ...@@ -1980,7 +1977,7 @@ static int sep_construct_dma_tables_from_lli(
if (!last_table_flag) { if (!last_table_flag) {
/* /*
* if this is not the last table, * If this is not the last table,
* then must check where the data is smallest * then must check where the data is smallest
* and then align it to the block size * and then align it to the block size
*/ */
...@@ -1988,7 +1985,7 @@ static int sep_construct_dma_tables_from_lli( ...@@ -1988,7 +1985,7 @@ static int sep_construct_dma_tables_from_lli(
table_data_size = out_table_data_size; table_data_size = out_table_data_size;
/* /*
* now calculate the table size so that * Now calculate the table size so that
* it will be module block size * it will be module block size
*/ */
table_data_size = (table_data_size / block_size) * table_data_size = (table_data_size / block_size) *
...@@ -1998,23 +1995,23 @@ static int sep_construct_dma_tables_from_lli( ...@@ -1998,23 +1995,23 @@ static int sep_construct_dma_tables_from_lli(
dev_dbg(&sep->pdev->dev, "table_data_size is %x\n", dev_dbg(&sep->pdev->dev, "table_data_size is %x\n",
table_data_size); table_data_size);
/* construct input lli table */ /* Construct input lli table */
sep_build_lli_table(sep, &lli_in_array[current_in_entry], sep_build_lli_table(sep, &lli_in_array[current_in_entry],
in_lli_table_ptr, in_lli_table_ptr,
&current_in_entry, &current_in_entry,
&num_entries_in_table, &num_entries_in_table,
table_data_size); table_data_size);
/* construct output lli table */ /* Construct output lli table */
sep_build_lli_table(sep, &lli_out_array[current_out_entry], sep_build_lli_table(sep, &lli_out_array[current_out_entry],
out_lli_table_ptr, out_lli_table_ptr,
&current_out_entry, &current_out_entry,
&num_entries_out_table, &num_entries_out_table,
table_data_size); table_data_size);
/* if info entry is null - this is the first table built */ /* If info entry is null - this is the first table built */
if (info_in_entry_ptr == 0) { if (info_in_entry_ptr == 0) {
/* set the output parameters to physical addresses */ /* Set the output parameters to physical addresses */
*lli_table_in_ptr = *lli_table_in_ptr =
sep_shared_area_virt_to_bus(sep, in_lli_table_ptr); sep_shared_area_virt_to_bus(sep, in_lli_table_ptr);
...@@ -2034,7 +2031,7 @@ static int sep_construct_dma_tables_from_lli( ...@@ -2034,7 +2031,7 @@ static int sep_construct_dma_tables_from_lli(
"output lli_table_out_ptr is %08lx\n", "output lli_table_out_ptr is %08lx\n",
(unsigned long)*lli_table_out_ptr); (unsigned long)*lli_table_out_ptr);
} else { } else {
/* update the info entry of the previous in table */ /* Update the info entry of the previous in table */
info_in_entry_ptr->bus_address = info_in_entry_ptr->bus_address =
sep_shared_area_virt_to_bus(sep, sep_shared_area_virt_to_bus(sep,
in_lli_table_ptr); in_lli_table_ptr);
...@@ -2043,7 +2040,7 @@ static int sep_construct_dma_tables_from_lli( ...@@ -2043,7 +2040,7 @@ static int sep_construct_dma_tables_from_lli(
((num_entries_in_table) << 24) | ((num_entries_in_table) << 24) |
(table_data_size); (table_data_size);
/* update the info entry of the previous in table */ /* Update the info entry of the previous in table */
info_out_entry_ptr->bus_address = info_out_entry_ptr->bus_address =
sep_shared_area_virt_to_bus(sep, sep_shared_area_virt_to_bus(sep,
out_lli_table_ptr); out_lli_table_ptr);
...@@ -2063,7 +2060,7 @@ static int sep_construct_dma_tables_from_lli( ...@@ -2063,7 +2060,7 @@ static int sep_construct_dma_tables_from_lli(
info_out_entry_ptr->block_size); info_out_entry_ptr->block_size);
} }
/* save the pointer to the info entry of the current tables */ /* Save the pointer to the info entry of the current tables */
info_in_entry_ptr = in_lli_table_ptr + info_in_entry_ptr = in_lli_table_ptr +
num_entries_in_table - 1; num_entries_in_table - 1;
info_out_entry_ptr = out_lli_table_ptr + info_out_entry_ptr = out_lli_table_ptr +
...@@ -2080,14 +2077,14 @@ static int sep_construct_dma_tables_from_lli( ...@@ -2080,14 +2077,14 @@ static int sep_construct_dma_tables_from_lli(
(unsigned long)info_out_entry_ptr); (unsigned long)info_out_entry_ptr);
} }
/* print input tables */ /* Print input tables */
sep_debug_print_lli_tables(sep, sep_debug_print_lli_tables(sep,
(struct sep_lli_entry *) (struct sep_lli_entry *)
sep_shared_area_bus_to_virt(sep, *lli_table_in_ptr), sep_shared_area_bus_to_virt(sep, *lli_table_in_ptr),
*in_num_entries_ptr, *in_num_entries_ptr,
*table_data_size_ptr); *table_data_size_ptr);
/* print output tables */ /* Print output tables */
sep_debug_print_lli_tables(sep, sep_debug_print_lli_tables(sep,
(struct sep_lli_entry *) (struct sep_lli_entry *)
sep_shared_area_bus_to_virt(sep, *lli_table_out_ptr), sep_shared_area_bus_to_virt(sep, *lli_table_out_ptr),
...@@ -2114,7 +2111,7 @@ static int sep_construct_dma_tables_from_lli( ...@@ -2114,7 +2111,7 @@ static int sep_construct_dma_tables_from_lli(
* This function builds input and output DMA tables for synhronic * This function builds input and output DMA tables for synhronic
* symmetric operations (AES, DES, HASH). It also checks that each table * symmetric operations (AES, DES, HASH). It also checks that each table
* is of the modular block size * is of the modular block size
* Note that all bus addresses that are passed to the sep * Note that all bus addresses that are passed to the SEP
* are in 32 bit format; the SEP is a 32 bit device * are in 32 bit format; the SEP is a 32 bit device
*/ */
static int sep_prepare_input_output_dma_table(struct sep_device *sep, static int sep_prepare_input_output_dma_table(struct sep_device *sep,
...@@ -2131,15 +2128,15 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep, ...@@ -2131,15 +2128,15 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep,
{ {
int error = 0; int error = 0;
/* array of pointers of page */ /* Array of pointers of page */
struct sep_lli_entry *lli_in_array; struct sep_lli_entry *lli_in_array;
/* array of pointers of page */ /* Array of pointers of page */
struct sep_lli_entry *lli_out_array; struct sep_lli_entry *lli_out_array;
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) { if (data_size == 0) {
/* prepare empty table for input and output */ /* Prepare empty table for input and output */
sep_prepare_empty_lli_table(sep, lli_table_in_ptr, sep_prepare_empty_lli_table(sep, lli_table_in_ptr,
in_num_entries_ptr, table_data_size_ptr); in_num_entries_ptr, table_data_size_ptr);
...@@ -2149,11 +2146,11 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep, ...@@ -2149,11 +2146,11 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep,
goto update_dcb_counter; goto update_dcb_counter;
} }
/* initialize the pages pointers */ /* Initialize the pages pointers */
sep->dma_res_arr[sep->nr_dcb_creat].in_page_array = 0; sep->dma_res_arr[sep->nr_dcb_creat].in_page_array = 0;
sep->dma_res_arr[sep->nr_dcb_creat].out_page_array = 0; sep->dma_res_arr[sep->nr_dcb_creat].out_page_array = 0;
/* lock the pages of the buffer and translate them to pages */ /* Lock the pages of the buffer and translate them to pages */
if (is_kva == true) { if (is_kva == true) {
error = sep_lock_kernel_pages(sep, app_virt_in_addr, error = sep_lock_kernel_pages(sep, app_virt_in_addr,
data_size, &lli_in_array, SEP_DRIVER_IN_FLAG); data_size, &lli_in_array, SEP_DRIVER_IN_FLAG);
...@@ -2200,7 +2197,7 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep, ...@@ -2200,7 +2197,7 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep,
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); SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
/* call the fucntion that creates table from the lli arrays */ /* Call the fucntion that creates table from the lli arrays */
error = sep_construct_dma_tables_from_lli(sep, lli_in_array, error = sep_construct_dma_tables_from_lli(sep, lli_in_array,
sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages, sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages,
lli_out_array, lli_out_array,
...@@ -2218,9 +2215,9 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep, ...@@ -2218,9 +2215,9 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep,
kfree(lli_in_array); kfree(lli_in_array);
update_dcb_counter: update_dcb_counter:
/* update dcb counter */ /* Update DCB counter */
sep->nr_dcb_creat++; sep->nr_dcb_creat++;
/* fall through - free the lli entry arrays */ /* Fall through - free the lli entry arrays */
dev_dbg(&sep->pdev->dev, "in_num_entries_ptr is %08x\n", dev_dbg(&sep->pdev->dev, "in_num_entries_ptr is %08x\n",
*in_num_entries_ptr); *in_num_entries_ptr);
dev_dbg(&sep->pdev->dev, "out_num_entries_ptr is %08x\n", dev_dbg(&sep->pdev->dev, "out_num_entries_ptr is %08x\n",
...@@ -2259,10 +2256,10 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep, ...@@ -2259,10 +2256,10 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep,
* @isapplet: bool; to indicate external app * @isapplet: bool; to indicate external app
* @is_kva: bool; kernel buffer; only used for kernel crypto module * @is_kva: bool; kernel buffer; only used for kernel crypto module
* *
* This function prepares the linked dma tables and puts the * This function prepares the linked DMA tables and puts the
* address for the linked list of tables inta a dcb (data control * address for the linked list of tables inta a DCB (data control
* block) the address of which is known by the sep hardware * block) the address of which is known by the SEP hardware
* Note that all bus addresses that are passed to the sep * Note that all bus addresses that are passed to the SEP
* are in 32 bit format; the SEP is a 32 bit device * are in 32 bit format; the SEP is a 32 bit device
*/ */
static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep, static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
...@@ -2275,36 +2272,36 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep, ...@@ -2275,36 +2272,36 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
bool is_kva) bool is_kva)
{ {
int error = 0; int error = 0;
/* size of tail */ /* Size of tail */
u32 tail_size = 0; u32 tail_size = 0;
/* address of the created dcb table */ /* Address of the created DCB table */
struct sep_dcblock *dcb_table_ptr = 0; struct sep_dcblock *dcb_table_ptr = 0;
/* the physical address of the first input DMA table */ /* The physical address of the first input DMA table */
dma_addr_t in_first_mlli_address = 0; dma_addr_t in_first_mlli_address = 0;
/* number of entries in the first input DMA table */ /* Number of entries in the first input DMA table */
u32 in_first_num_entries = 0; u32 in_first_num_entries = 0;
/* the physical address of the first output DMA table */ /* The physical address of the first output DMA table */
dma_addr_t out_first_mlli_address = 0; dma_addr_t out_first_mlli_address = 0;
/* number of entries in the first output DMA table */ /* Number of entries in the first output DMA table */
u32 out_first_num_entries = 0; u32 out_first_num_entries = 0;
/* data in the first input/output table */ /* Data in the first input/output table */
u32 first_data_size = 0; 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) { 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"); dev_warn(&sep->pdev->dev, "no more DCBs available\n");
error = -ENOSPC; error = -ENOSPC;
goto end_function; goto end_function;
} }
/* allocate new DCB */ /* Allocate new DCB */
dcb_table_ptr = (struct sep_dcblock *)(sep->shared_addr + dcb_table_ptr = (struct sep_dcblock *)(sep->shared_addr +
SEP_DRIVER_SYSTEM_DCB_MEMORY_OFFSET_IN_BYTES + SEP_DRIVER_SYSTEM_DCB_MEMORY_OFFSET_IN_BYTES +
(sep->nr_dcb_creat * sizeof(struct sep_dcblock))); (sep->nr_dcb_creat * sizeof(struct sep_dcblock)));
/* set the default values in the dcb */ /* Set the default values in the DCB */
dcb_table_ptr->input_mlli_address = 0; dcb_table_ptr->input_mlli_address = 0;
dcb_table_ptr->input_mlli_num_entries = 0; dcb_table_ptr->input_mlli_num_entries = 0;
dcb_table_ptr->input_mlli_data_size = 0; dcb_table_ptr->input_mlli_data_size = 0;
...@@ -2324,7 +2321,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep, ...@@ -2324,7 +2321,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
} }
if (tail_block_size) if (tail_block_size)
/* /*
* case the tail size should be * Case the tail size should be
* bigger than the real block size * bigger than the real block size
*/ */
tail_size = tail_block_size + tail_size = tail_block_size +
...@@ -2332,7 +2329,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep, ...@@ -2332,7 +2329,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
tail_block_size) % block_size); tail_block_size) % block_size);
} }
/* check if there is enough data for dma operation */ /* Check if there is enough data for DMA operation */
if (data_in_size < SEP_DRIVER_MIN_DATA_SIZE_PER_TABLE) { if (data_in_size < SEP_DRIVER_MIN_DATA_SIZE_PER_TABLE) {
if (is_kva == true) { if (is_kva == true) {
memcpy(dcb_table_ptr->tail_data, memcpy(dcb_table_ptr->tail_data,
...@@ -2348,7 +2345,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep, ...@@ -2348,7 +2345,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
dcb_table_ptr->tail_data_size = data_in_size; dcb_table_ptr->tail_data_size = data_in_size;
/* set the output user-space address for mem2mem op */ /* Set the output user-space address for mem2mem op */
if (app_out_address) if (app_out_address)
dcb_table_ptr->out_vr_tail_pt = dcb_table_ptr->out_vr_tail_pt =
(u32)app_out_address; (u32)app_out_address;
...@@ -2367,7 +2364,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep, ...@@ -2367,7 +2364,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
(void *)(app_in_address + data_in_size - (void *)(app_in_address + data_in_size -
tail_size), tail_size); tail_size), tail_size);
} else { } else {
/* we have tail data - copy it to dcb */ /* We have tail data - copy it to DCB */
if (copy_from_user(dcb_table_ptr->tail_data, if (copy_from_user(dcb_table_ptr->tail_data,
(void *)(app_in_address + (void *)(app_in_address +
data_in_size - tail_size), tail_size)) { data_in_size - tail_size), tail_size)) {
...@@ -2393,9 +2390,9 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep, ...@@ -2393,9 +2390,9 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
data_in_size = (data_in_size - tail_size); data_in_size = (data_in_size - tail_size);
} }
} }
/* check if we need to build only input table or input/output */ /* Check if we need to build only input table or input/output */
if (app_out_address) { if (app_out_address) {
/* prepare input/output tables */ /* Prepare input/output tables */
error = sep_prepare_input_output_dma_table(sep, error = sep_prepare_input_output_dma_table(sep,
app_in_address, app_in_address,
app_out_address, app_out_address,
...@@ -2408,7 +2405,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep, ...@@ -2408,7 +2405,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
&first_data_size, &first_data_size,
is_kva); is_kva);
} else { } else {
/* prepare input tables */ /* Prepare input tables */
error = sep_prepare_input_dma_table(sep, error = sep_prepare_input_dma_table(sep,
app_in_address, app_in_address,
data_in_size, data_in_size,
...@@ -2420,11 +2417,11 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep, ...@@ -2420,11 +2417,11 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
} }
if (error) { 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; goto end_function;
} }
/* set the dcb values */ /* Set the DCB values */
dcb_table_ptr->input_mlli_address = in_first_mlli_address; dcb_table_ptr->input_mlli_address = in_first_mlli_address;
dcb_table_ptr->input_mlli_num_entries = in_first_num_entries; dcb_table_ptr->input_mlli_num_entries = in_first_num_entries;
dcb_table_ptr->input_mlli_data_size = first_data_size; dcb_table_ptr->input_mlli_data_size = first_data_size;
...@@ -2441,7 +2438,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep, ...@@ -2441,7 +2438,7 @@ static int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
/** /**
* sep_create_sync_dma_tables_handler - create sync dma tables * sep_create_sync_dma_tables_handler - create sync DMA tables
* @sep: pointer to struct sep_device * @sep: pointer to struct sep_device
* @arg: pointer to struct bld_syn_tab_struct * @arg: pointer to struct bld_syn_tab_struct
* *
...@@ -2454,7 +2451,7 @@ static int sep_create_sync_dma_tables_handler(struct sep_device *sep, ...@@ -2454,7 +2451,7 @@ static int sep_create_sync_dma_tables_handler(struct sep_device *sep,
{ {
int error = 0; int error = 0;
/* command arguments */ /* Command arguments */
struct bld_syn_tab_struct command_args; struct bld_syn_tab_struct command_args;
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
...@@ -2475,7 +2472,7 @@ static int sep_create_sync_dma_tables_handler(struct sep_device *sep, ...@@ -2475,7 +2472,7 @@ static int sep_create_sync_dma_tables_handler(struct sep_device *sep,
dev_dbg(&sep->pdev->dev, "block_size is %u\n", dev_dbg(&sep->pdev->dev, "block_size is %u\n",
command_args.block_size); command_args.block_size);
/* validate user parameters */ /* Validate user parameters */
if (!command_args.app_in_address) { if (!command_args.app_in_address) {
error = -EINVAL; error = -EINVAL;
goto end_function; goto end_function;
...@@ -2501,7 +2498,7 @@ static int sep_create_sync_dma_tables_handler(struct sep_device *sep, ...@@ -2501,7 +2498,7 @@ static int sep_create_sync_dma_tables_handler(struct sep_device *sep,
* @isapplet: indicates external application (used for kernel access) * @isapplet: indicates external application (used for kernel access)
* @is_kva: indicates kernel addresses (only used for kernel crypto) * @is_kva: indicates kernel addresses (only used for kernel crypto)
* *
* This function frees the dma tables and dcb block * This function frees the DMA tables and DCB
*/ */
static int sep_free_dma_tables_and_dcb(struct sep_device *sep, bool isapplet, static int sep_free_dma_tables_and_dcb(struct sep_device *sep, bool isapplet,
bool is_kva) bool is_kva)
...@@ -2514,12 +2511,12 @@ static int sep_free_dma_tables_and_dcb(struct sep_device *sep, bool isapplet, ...@@ -2514,12 +2511,12 @@ static int sep_free_dma_tables_and_dcb(struct sep_device *sep, bool isapplet,
dev_dbg(&sep->pdev->dev, "sep_free_dma_tables_and_dcb start\n"); dev_dbg(&sep->pdev->dev, "sep_free_dma_tables_and_dcb start\n");
if (isapplet == true) { if (isapplet == true) {
/* set pointer to first dcb table */ /* Set pointer to first DCB table */
dcb_table_ptr = (struct sep_dcblock *) dcb_table_ptr = (struct sep_dcblock *)
(sep->shared_addr + (sep->shared_addr +
SEP_DRIVER_SYSTEM_DCB_MEMORY_OFFSET_IN_BYTES); SEP_DRIVER_SYSTEM_DCB_MEMORY_OFFSET_IN_BYTES);
/* go over each dcb and see if tail pointer must be updated */ /* Go over each DCB and see if tail pointer must be updated */
for (i = 0; i < sep->nr_dcb_creat; i++, dcb_table_ptr++) { for (i = 0; i < sep->nr_dcb_creat; i++, dcb_table_ptr++) {
if (dcb_table_ptr->out_vr_tail_pt) { if (dcb_table_ptr->out_vr_tail_pt) {
if (is_kva == true) { if (is_kva == true) {
...@@ -2533,14 +2530,14 @@ static int sep_free_dma_tables_and_dcb(struct sep_device *sep, bool isapplet, ...@@ -2533,14 +2530,14 @@ static int sep_free_dma_tables_and_dcb(struct sep_device *sep, bool isapplet,
dcb_table_ptr->tail_data_size); dcb_table_ptr->tail_data_size);
} }
if (error_temp) { if (error_temp) {
/* release the dma resource */ /* Release the DMA resource */
error = -EFAULT; error = -EFAULT;
break; break;
} }
} }
} }
} }
/* free the output pages, if any */ /* Free the output pages, if any */
sep_free_dma_table_data_handler(sep); sep_free_dma_table_data_handler(sep);
dev_dbg(&sep->pdev->dev, "sep_free_dma_tables_and_dcb end\n"); dev_dbg(&sep->pdev->dev, "sep_free_dma_tables_and_dcb end\n");
...@@ -2579,7 +2576,7 @@ static int sep_get_static_pool_addr_handler(struct sep_device *sep, ...@@ -2579,7 +2576,7 @@ static int sep_get_static_pool_addr_handler(struct sep_device *sep,
(u32)static_pool_addr[1], (u32)static_pool_addr[1],
(u32)command_args.static_virt_address); (u32)command_args.static_virt_address);
/* send the parameters to user application */ /* Send the parameters to user application */
if (copy_to_user((void __user *) arg, &command_args, if (copy_to_user((void __user *) arg, &command_args,
sizeof(struct stat_pool_addr_struct))) sizeof(struct stat_pool_addr_struct)))
return -EFAULT; return -EFAULT;
...@@ -2600,14 +2597,14 @@ static int sep_start_handler(struct sep_device *sep) ...@@ -2600,14 +2597,14 @@ static int sep_start_handler(struct sep_device *sep)
dev_dbg(&sep->pdev->dev, "sep_start_handler start\n"); dev_dbg(&sep->pdev->dev, "sep_start_handler start\n");
/* wait in polling for message from SEP */ /* Wait in polling for message from SEP */
do do
reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR); reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
while (!reg_val); while (!reg_val);
/* check the value */ /* Check the value */
if (reg_val == 0x1) if (reg_val == 0x1)
/* fatal error - read error status from GPRO */ /* Fatal error - read error status from GPRO */
error = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR); error = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
dev_dbg(&sep->pdev->dev, "sep_start_handler end\n"); dev_dbg(&sep->pdev->dev, "sep_start_handler end\n");
return error; return error;
...@@ -2619,7 +2616,7 @@ static int sep_start_handler(struct sep_device *sep) ...@@ -2619,7 +2616,7 @@ static int sep_start_handler(struct sep_device *sep)
* @length: buffer size * @length: buffer size
* *
* This function performs a checksum for messages that are sent * This function performs a checksum for messages that are sent
* to the sep * to the SEP.
*/ */
static u32 sep_check_sum_calc(u8 *data, u32 length) static u32 sep_check_sum_calc(u8 *data, u32 length)
{ {
...@@ -2651,7 +2648,7 @@ static u32 sep_check_sum_calc(u8 *data, u32 length) ...@@ -2651,7 +2648,7 @@ static u32 sep_check_sum_calc(u8 *data, u32 length)
* Handles the request for SEP initialization * Handles the request for SEP initialization
* Note that this will go away for Medfield once the SCU * Note that this will go away for Medfield once the SCU
* SEP initialization is complete * SEP initialization is complete
* Also note that the message to the sep has components * Also note that the message to the SEP has components
* from user space as well as components written by the driver * from user space as well as components written by the driver
* This is becuase the portions of the message that pertain to * This is becuase the portions of the message that pertain to
* physical addresses must be set by the driver after the message * physical addresses must be set by the driver after the message
...@@ -2670,7 +2667,7 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg) ...@@ -2670,7 +2667,7 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
dev_dbg(&sep->pdev->dev, "sep_init_handler start\n"); dev_dbg(&sep->pdev->dev, "sep_init_handler start\n");
/* make sure that we have not initialized already */ /* Make sure that we have not initialized already */
reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR); reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
if (reg_val != 0x2) { if (reg_val != 0x2) {
...@@ -2679,13 +2676,13 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg) ...@@ -2679,13 +2676,13 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
goto end_function; goto end_function;
} }
/* only root can initialize */ /* Only root can initialize */
if (!capable(CAP_SYS_ADMIN)) { if (!capable(CAP_SYS_ADMIN)) {
error = -EACCES; error = -EACCES;
goto end_function; goto end_function;
} }
/* copy in the parameters */ /* Copy in the parameters */
error = copy_from_user(&command_args, (void __user *)arg, error = copy_from_user(&command_args, (void __user *)arg,
sizeof(struct init_struct)); sizeof(struct init_struct));
...@@ -2694,14 +2691,14 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg) ...@@ -2694,14 +2691,14 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
goto end_function; goto end_function;
} }
/* validate parameters */ /* Validate parameters */
if (!command_args.message_addr || !command_args.sep_sram_addr || if (!command_args.message_addr || !command_args.sep_sram_addr ||
command_args.message_size_in_words > 14) { command_args.message_size_in_words > 14) {
error = -EINVAL; error = -EINVAL;
goto end_function; goto end_function;
} }
/* copy in the sep init message */ /* Copy in the SEP init message */
addr_hold = (unsigned long)command_args.message_addr; addr_hold = (unsigned long)command_args.message_addr;
error = copy_from_user(message_buff, error = copy_from_user(message_buff,
(void __user *)addr_hold, (void __user *)addr_hold,
...@@ -2712,16 +2709,16 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg) ...@@ -2712,16 +2709,16 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
goto end_function; goto end_function;
} }
/* load resident, cache, and extapp firmware */ /* Load resident, cache, and extapp firmware */
error = sep_load_firmware(sep); error = sep_load_firmware(sep);
if (error) { if (error) {
dev_warn(&sep->pdev->dev, dev_warn(&sep->pdev->dev,
"init; copy sep init message failed %x\n", error); "init; copy SEP init message failed %x\n", error);
goto end_function; goto end_function;
} }
/* compute the base address */ /* Compute the base address */
new_base_addr = sep->shared_bus; new_base_addr = sep->shared_bus;
if (sep->resident_bus < new_base_addr) if (sep->resident_bus < new_base_addr)
...@@ -2733,7 +2730,7 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg) ...@@ -2733,7 +2730,7 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
if (sep->dcache_bus < new_base_addr) if (sep->dcache_bus < new_base_addr)
new_base_addr = sep->dcache_bus; new_base_addr = sep->dcache_bus;
/* put physical addresses in sep message */ /* Put physical addresses in SEP message */
message_buff[3] = (u32)new_base_addr; message_buff[3] = (u32)new_base_addr;
message_buff[4] = (u32)sep->shared_bus; message_buff[4] = (u32)sep->shared_bus;
message_buff[6] = (u32)sep->resident_bus; message_buff[6] = (u32)sep->resident_bus;
...@@ -2745,16 +2742,16 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg) ...@@ -2745,16 +2742,16 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
sep_check_sum_calc((u8 *)message_buff, sep_check_sum_calc((u8 *)message_buff,
command_args.message_size_in_words*sizeof(u32)); command_args.message_size_in_words*sizeof(u32));
/* debug print of message */ /* Debug print of message */
for (counter = 0; counter < command_args.message_size_in_words; for (counter = 0; counter < command_args.message_size_in_words;
counter++) counter++)
dev_dbg(&sep->pdev->dev, "init; sep message word %d is %x\n", dev_dbg(&sep->pdev->dev, "init; SEP message word %d is %x\n",
counter, message_buff[counter]); counter, message_buff[counter]);
/* tell the sep the sram address */ /* Tell the SEP the sram address */
sep_write_reg(sep, HW_SRAM_ADDR_REG_ADDR, command_args.sep_sram_addr); sep_write_reg(sep, HW_SRAM_ADDR_REG_ADDR, command_args.sep_sram_addr);
/* push the message to the sep */ /* Push the message to the SEP */
for (counter = 0; counter < command_args.message_size_in_words; for (counter = 0; counter < command_args.message_size_in_words;
counter++) { counter++) {
sep_write_reg(sep, HW_SRAM_DATA_REG_ADDR, sep_write_reg(sep, HW_SRAM_DATA_REG_ADDR,
...@@ -2762,10 +2759,10 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg) ...@@ -2762,10 +2759,10 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
sep_wait_sram_write(sep); sep_wait_sram_write(sep);
} }
/* signal sep that message is ready and to init */ /* Signal SEP that message is ready and to init */
sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x1); sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x1);
/* wait for acknowledge */ /* Wait for acknowledge */
dev_dbg(&sep->pdev->dev, "init; waiting for msg response\n"); dev_dbg(&sep->pdev->dev, "init; waiting for msg response\n");
do do
...@@ -2782,10 +2779,10 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg) ...@@ -2782,10 +2779,10 @@ static int sep_init_handler(struct sep_device *sep, unsigned long arg)
} }
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 */ /* Signal SEP to zero the GPR3 */
sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x10); sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x10);
/* wait for response */ /* Wait for response */
dev_dbg(&sep->pdev->dev, "init; waiting for zero set response\n"); dev_dbg(&sep->pdev->dev, "init; waiting for zero set response\n");
do do
...@@ -2807,25 +2804,25 @@ static int sep_end_transaction_handler(struct sep_device *sep) ...@@ -2807,25 +2804,25 @@ static int sep_end_transaction_handler(struct sep_device *sep)
{ {
dev_dbg(&sep->pdev->dev, "sep_end_transaction_handler start\n"); dev_dbg(&sep->pdev->dev, "sep_end_transaction_handler start\n");
/* clear the data pool pointers Token */ /* Clear the data pool pointers Token */
memset((void *)(sep->shared_addr + memset((void *)(sep->shared_addr +
SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES), SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES),
0, sep->num_of_data_allocations*2*sizeof(u32)); 0, sep->num_of_data_allocations*2*sizeof(u32));
/* check that all the dma resources were freed */ /* Check that all the DMA resources were freed */
sep_free_dma_table_data_handler(sep); sep_free_dma_table_data_handler(sep);
clear_bit(SEP_MMAP_LOCK_BIT, &sep->in_use_flags); clear_bit(SEP_MMAP_LOCK_BIT, &sep->in_use_flags);
/* /*
* we are now through with the transaction. Let's * We are now through with the transaction. Let's
* allow other processes who have the device open * allow other processes who have the device open
* to perform transactions * to perform transactions
*/ */
mutex_lock(&sep->sep_mutex); mutex_lock(&sep->sep_mutex);
sep->pid_doing_transaction = 0; sep->pid_doing_transaction = 0;
mutex_unlock(&sep->sep_mutex); mutex_unlock(&sep->sep_mutex);
/* raise event for stuck contextes */ /* Raise event for stuck contextes */
wake_up(&sep->event); wake_up(&sep->event);
dev_dbg(&sep->pdev->dev, "waking up event\n"); dev_dbg(&sep->pdev->dev, "waking up event\n");
...@@ -2844,9 +2841,8 @@ static int sep_end_transaction_handler(struct sep_device *sep) ...@@ -2844,9 +2841,8 @@ static int sep_end_transaction_handler(struct sep_device *sep)
*/ */
static int sep_prepare_dcb_handler(struct sep_device *sep, unsigned long arg) static int sep_prepare_dcb_handler(struct sep_device *sep, unsigned long arg)
{ {
/* error */
int error; int error;
/* command arguments */ /* Command arguments */
struct build_dcb_struct command_args; struct build_dcb_struct command_args;
dev_dbg(&sep->pdev->dev, "sep_prepare_dcb_handler start\n"); dev_dbg(&sep->pdev->dev, "sep_prepare_dcb_handler start\n");
...@@ -2912,24 +2908,24 @@ static int sep_rar_prepare_output_msg_handler(struct sep_device *sep, ...@@ -2912,24 +2908,24 @@ static int sep_rar_prepare_output_msg_handler(struct sep_device *sep,
unsigned long arg) unsigned long arg)
{ {
int error = 0; int error = 0;
/* command args */ /* Command args */
struct rar_hndl_to_bus_struct command_args; struct rar_hndl_to_bus_struct command_args;
struct RAR_buffer rar_buf; struct RAR_buffer rar_buf;
/* bus address */ /* Bus address */
dma_addr_t rar_bus = 0; dma_addr_t rar_bus = 0;
/* holds the RAR address in the system memory offset */ /* Holds the RAR address in the system memory offset */
u32 *rar_addr; 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 */ /* Copy the data */
if (copy_from_user(&command_args, (void __user *)arg, if (copy_from_user(&command_args, (void __user *)arg,
sizeof(command_args))) { sizeof(command_args))) {
error = -EFAULT; error = -EFAULT;
goto end_function; goto end_function;
} }
/* call to translation function only if user handle is not NULL */ /* Call to translation function only if user handle is not NULL */
if (command_args.rar_handle) { if (command_args.rar_handle) {
memset(&rar_buf, 0, sizeof(rar_buf)); memset(&rar_buf, 0, sizeof(rar_buf));
rar_buf.info.handle = (u32)command_args.rar_handle; rar_buf.info.handle = (u32)command_args.rar_handle;
...@@ -2943,11 +2939,11 @@ static int sep_rar_prepare_output_msg_handler(struct sep_device *sep, ...@@ -2943,11 +2939,11 @@ static int sep_rar_prepare_output_msg_handler(struct sep_device *sep,
} }
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 */ /* Set value in the SYSTEM MEMORY offset */
rar_addr = (u32 *)(sep->shared_addr + rar_addr = (u32 *)(sep->shared_addr +
SEP_DRIVER_SYSTEM_RAR_MEMORY_OFFSET_IN_BYTES); SEP_DRIVER_SYSTEM_RAR_MEMORY_OFFSET_IN_BYTES);
/* copy the physical address to the System Area for the sep */ /* Copy the physical address to the System Area for the SEP */
rar_addr[0] = SEP_RAR_VAL_TOKEN; rar_addr[0] = SEP_RAR_VAL_TOKEN;
rar_addr[1] = rar_bus; rar_addr[1] = rar_bus;
...@@ -2961,19 +2957,19 @@ static int sep_rar_prepare_output_msg_handler(struct sep_device *sep, ...@@ -2961,19 +2957,19 @@ static int sep_rar_prepare_output_msg_handler(struct sep_device *sep,
* @sep: pointer to struct sep_device * @sep: pointer to struct sep_device
* @arg: pointer to user parameters * @arg: pointer to user parameters
* *
* This function tells the sep where the extapp is located * This function tells the SEP where the extapp is located
*/ */
static int sep_realloc_ext_cache_handler(struct sep_device *sep, static int sep_realloc_ext_cache_handler(struct sep_device *sep,
unsigned long arg) unsigned long arg)
{ {
/* holds the new ext cache address in the system memory offset */ /* Holds the new ext cache address in the system memory offset */
u32 *system_addr; u32 *system_addr;
/* set value in the SYSTEM MEMORY offset */ /* Set value in the SYSTEM MEMORY offset */
system_addr = (u32 *)(sep->shared_addr + system_addr = (u32 *)(sep->shared_addr +
SEP_DRIVER_SYSTEM_EXT_CACHE_ADDR_OFFSET_IN_BYTES); SEP_DRIVER_SYSTEM_EXT_CACHE_ADDR_OFFSET_IN_BYTES);
/* copy the physical address to the System Area for the sep */ /* Copy the physical address to the System Area for the SEP */
system_addr[0] = SEP_EXT_CACHE_ADDR_VAL_TOKEN; system_addr[0] = SEP_EXT_CACHE_ADDR_VAL_TOKEN;
dev_dbg(&sep->pdev->dev, "ext cache init; system addr 0 is %x\n", dev_dbg(&sep->pdev->dev, "ext cache init; system addr 0 is %x\n",
system_addr[0]); system_addr[0]);
...@@ -3025,7 +3021,7 @@ static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ...@@ -3025,7 +3021,7 @@ static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
"SEP_IOCFREEDCB is %x\n", SEP_IOCFREEDCB); "SEP_IOCFREEDCB is %x\n", SEP_IOCFREEDCB);
/* make sure we own this device */ /* Make sure we own this device */
mutex_lock(&sep->sep_mutex); mutex_lock(&sep->sep_mutex);
if ((current->pid != sep->pid_doing_transaction) && if ((current->pid != sep->pid_doing_transaction) &&
(sep->pid_doing_transaction != 0)) { (sep->pid_doing_transaction != 0)) {
...@@ -3037,48 +3033,48 @@ static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ...@@ -3037,48 +3033,48 @@ static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
mutex_unlock(&sep->sep_mutex); mutex_unlock(&sep->sep_mutex);
/* check that the command is for sep device */ /* Check that the command is for SEP device */
if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) { if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) {
error = -ENOTTY; error = -ENOTTY;
goto end_function; goto end_function;
} }
/* lock to prevent the daemon to interfere with operation */ /* Lock to prevent the daemon to interfere with operation */
mutex_lock(&sep->ioctl_mutex); mutex_lock(&sep->ioctl_mutex);
switch (cmd) { switch (cmd) {
case SEP_IOCSENDSEPCOMMAND: case SEP_IOCSENDSEPCOMMAND:
/* send command to SEP */ /* Send command to SEP */
error = sep_send_command_handler(sep); error = sep_send_command_handler(sep);
break; break;
case SEP_IOCALLOCDATAPOLL: case SEP_IOCALLOCDATAPOLL:
/* allocate data pool */ /* Allocate data pool */
error = sep_allocate_data_pool_memory_handler(sep, arg); error = sep_allocate_data_pool_memory_handler(sep, arg);
break; break;
case SEP_IOCCREATESYMDMATABLE: case SEP_IOCCREATESYMDMATABLE:
/* create dma table for synhronic operation */ /* Create DMA table for synhronic operation */
error = sep_create_sync_dma_tables_handler(sep, arg); error = sep_create_sync_dma_tables_handler(sep, arg);
break; break;
case SEP_IOCFREEDMATABLEDATA: case SEP_IOCFREEDMATABLEDATA:
/* free the pages */ /* Free the pages */
error = sep_free_dma_table_data_handler(sep); error = sep_free_dma_table_data_handler(sep);
break; break;
case SEP_IOCSEPSTART: case SEP_IOCSEPSTART:
/* start command to sep */ /* Start command to SEP */
if (sep->pdev->revision == 0) /* only for old chip */ if (sep->pdev->revision == 0) /* Only for old chip */
error = sep_start_handler(sep); error = sep_start_handler(sep);
else else
error = -EPERM; /* not permitted on new chip */ error = -EPERM; /* Not permitted on new chip */
break; break;
case SEP_IOCSEPINIT: case SEP_IOCSEPINIT:
/* init command to sep */ /* Init command to SEP */
if (sep->pdev->revision == 0) /* only for old chip */ if (sep->pdev->revision == 0) /* Only for old chip */
error = sep_init_handler(sep, arg); error = sep_init_handler(sep, arg);
else else
error = -EPERM; /* not permitted on new chip */ error = -EPERM; /* Not permitted on new chip */
break; break;
case SEP_IOCGETSTATICPOOLADDR: case SEP_IOCGETSTATICPOOLADDR:
/* get the physical and virtual addresses of the static pool */ /* Get the physical and virtual addresses of the static pool */
error = sep_get_static_pool_addr_handler(sep, arg); error = sep_get_static_pool_addr_handler(sep, arg);
break; break;
case SEP_IOCENDTRANSACTION: case SEP_IOCENDTRANSACTION:
...@@ -3087,10 +3083,10 @@ static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ...@@ -3087,10 +3083,10 @@ static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
case SEP_IOCREALLOCEXTCACHE: case SEP_IOCREALLOCEXTCACHE:
if (sep->mrst) if (sep->mrst)
error = -ENODEV; error = -ENODEV;
if (sep->pdev->revision == 0) /* only for old chip */ if (sep->pdev->revision == 0) /* Only for old chip */
error = sep_realloc_ext_cache_handler(sep, arg); error = sep_realloc_ext_cache_handler(sep, arg);
else else
error = -EPERM; /* not permitted on new chip */ error = -EPERM; /* Not permitted on new chip */
break; break;
case SEP_IOCRARPREPAREMESSAGE: case SEP_IOCRARPREPAREMESSAGE:
error = sep_rar_prepare_output_msg_handler(sep, arg); error = sep_rar_prepare_output_msg_handler(sep, arg);
...@@ -3123,20 +3119,19 @@ static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ...@@ -3123,20 +3119,19 @@ static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
*/ */
static long sep_singleton_ioctl(struct file *filp, u32 cmd, unsigned long arg) static long sep_singleton_ioctl(struct file *filp, u32 cmd, unsigned long arg)
{ {
/* error */
long error = 0; long error = 0;
struct sep_device *sep = filp->private_data; struct sep_device *sep = filp->private_data;
dev_dbg(&sep->pdev->dev, "singleton_ioctl start\n"); dev_dbg(&sep->pdev->dev, "singleton_ioctl start\n");
dev_dbg(&sep->pdev->dev, "cmd is %x\n", cmd); dev_dbg(&sep->pdev->dev, "cmd is %x\n", cmd);
/* check that the command is for sep device */ /* Check that the command is for the SEP device */
if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) { if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) {
error = -ENOTTY; error = -ENOTTY;
goto end_function; goto end_function;
} }
/* make sure we own this device */ /* Make sure we own this device */
mutex_lock(&sep->sep_mutex); mutex_lock(&sep->sep_mutex);
if ((current->pid != sep->pid_doing_transaction) && if ((current->pid != sep->pid_doing_transaction) &&
(sep->pid_doing_transaction != 0)) { (sep->pid_doing_transaction != 0)) {
...@@ -3182,23 +3177,23 @@ static long sep_request_daemon_ioctl(struct file *filp, u32 cmd, ...@@ -3182,23 +3177,23 @@ static long sep_request_daemon_ioctl(struct file *filp, u32 cmd,
dev_dbg(&sep->pdev->dev, "daemon ioctl: start\n"); 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: cmd is %x\n", cmd);
/* check that the command is for sep device */ /* Check that the command is for SEP device */
if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) { if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) {
error = -ENOTTY; error = -ENOTTY;
goto end_function; goto end_function;
} }
/* only one process can access ioctl at any given time */ /* Only one process can access ioctl at any given time */
mutex_lock(&sep->ioctl_mutex); mutex_lock(&sep->ioctl_mutex);
switch (cmd) { switch (cmd) {
case SEP_IOCSENDSEPRPLYCOMMAND: case SEP_IOCSENDSEPRPLYCOMMAND:
/* send reply command to SEP */ /* Send reply command to SEP */
error = sep_req_daemon_send_reply_command_handler(sep); error = sep_req_daemon_send_reply_command_handler(sep);
break; break;
case SEP_IOCENDTRANSACTION: case SEP_IOCENDTRANSACTION:
/* /*
* end req daemon transaction, do nothing * End req daemon transaction, do nothing
* will be removed upon update in middleware * will be removed upon update in middleware
* API library * API library
*/ */
...@@ -3217,7 +3212,7 @@ static long sep_request_daemon_ioctl(struct file *filp, u32 cmd, ...@@ -3217,7 +3212,7 @@ static long sep_request_daemon_ioctl(struct file *filp, u32 cmd,
} }
/** /**
* sep_inthandler - Interrupt Handler * sep_inthandler - interrupt handler
* @irq: interrupt * @irq: interrupt
* @dev_id: device id * @dev_id: device id
*/ */
...@@ -3228,12 +3223,12 @@ static irqreturn_t sep_inthandler(int irq, void *dev_id) ...@@ -3228,12 +3223,12 @@ static irqreturn_t sep_inthandler(int irq, void *dev_id)
u32 reg_val, reg_val2 = 0; u32 reg_val, reg_val2 = 0;
struct sep_device *sep = dev_id; struct sep_device *sep = dev_id;
/* read the IRR register to check if this is SEP interrupt */ /* Read the IRR register to check if this is SEP interrupt */
reg_val = sep_read_reg(sep, HW_HOST_IRR_REG_ADDR); 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)) { if (reg_val & (0x1 << 13)) {
/* lock and update the counter of reply messages */ /* Lock and update the counter of reply messages */
spin_lock_irqsave(&sep->snd_rply_lck, lck_flags); spin_lock_irqsave(&sep->snd_rply_lck, lck_flags);
sep->reply_ct++; sep->reply_ct++;
spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags); spin_unlock_irqrestore(&sep->snd_rply_lck, lck_flags);
...@@ -3241,7 +3236,7 @@ static irqreturn_t sep_inthandler(int irq, void *dev_id) ...@@ -3241,7 +3236,7 @@ static irqreturn_t sep_inthandler(int irq, void *dev_id)
dev_dbg(&sep->pdev->dev, "sep int: send_ct %lx reply_ct %lx\n", 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? */ /* Is this printf or daemon request? */
reg_val2 = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR2_REG_ADDR); reg_val2 = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR2_REG_ADDR);
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
"SEP Interrupt - reg2 is %08x\n", reg_val2); "SEP Interrupt - reg2 is %08x\n", reg_val2);
...@@ -3253,11 +3248,11 @@ static irqreturn_t sep_inthandler(int irq, void *dev_id) ...@@ -3253,11 +3248,11 @@ static irqreturn_t sep_inthandler(int irq, void *dev_id)
dev_dbg(&sep->pdev->dev, "int: daemon request\n"); dev_dbg(&sep->pdev->dev, "int: daemon request\n");
wake_up(&sep->event_request_daemon); wake_up(&sep->event_request_daemon);
} else { } else {
dev_dbg(&sep->pdev->dev, "int: sep reply\n"); dev_dbg(&sep->pdev->dev, "int: SEP reply\n");
wake_up(&sep->event); wake_up(&sep->event);
} }
} else { } else {
dev_dbg(&sep->pdev->dev, "int: not sep interrupt\n"); dev_dbg(&sep->pdev->dev, "int: not SEP interrupt\n");
int_error = IRQ_NONE; int_error = IRQ_NONE;
} }
if (int_error == IRQ_HANDLED) if (int_error == IRQ_HANDLED)
...@@ -3329,20 +3324,20 @@ static int __devinit sep_probe(struct pci_dev *pdev, ...@@ -3329,20 +3324,20 @@ static int __devinit sep_probe(struct pci_dev *pdev,
int error = 0; int error = 0;
struct sep_device *sep; struct sep_device *sep;
pr_debug("Sep pci probe starting\n"); pr_debug("SEP pci probe starting\n");
if (sep_dev != NULL) { if (sep_dev != NULL) {
dev_warn(&pdev->dev, "only one SEP supported.\n"); dev_warn(&pdev->dev, "only one SEP supported.\n");
return -EBUSY; return -EBUSY;
} }
/* enable the device */ /* Enable the device */
error = pci_enable_device(pdev); error = pci_enable_device(pdev);
if (error) { if (error) {
dev_warn(&pdev->dev, "error enabling pci device\n"); dev_warn(&pdev->dev, "error enabling pci device\n");
goto end_function; goto end_function;
} }
/* allocate the sep_device structure for this device */ /* Allocate the sep_device structure for this device */
sep_dev = kzalloc(sizeof(struct sep_device), GFP_ATOMIC); sep_dev = kzalloc(sizeof(struct sep_device), GFP_ATOMIC);
if (sep_dev == NULL) { if (sep_dev == NULL) {
dev_warn(&pdev->dev, dev_warn(&pdev->dev,
...@@ -3351,7 +3346,7 @@ static int __devinit sep_probe(struct pci_dev *pdev, ...@@ -3351,7 +3346,7 @@ static int __devinit sep_probe(struct pci_dev *pdev,
} }
/* /*
* we're going to use another variable for actually * We're going to use another variable for actually
* working with the device; this way, if we have * working with the device; this way, if we have
* multiple devices in the future, it would be easier * multiple devices in the future, it would be easier
* to make appropriate changes * to make appropriate changes
...@@ -3366,7 +3361,7 @@ static int __devinit sep_probe(struct pci_dev *pdev, ...@@ -3366,7 +3361,7 @@ static int __devinit sep_probe(struct pci_dev *pdev,
dev_dbg(&sep->pdev->dev, "PCI obtained, device being prepared\n"); dev_dbg(&sep->pdev->dev, "PCI obtained, device being prepared\n");
dev_dbg(&sep->pdev->dev, "revision is %d\n", sep->pdev->revision); dev_dbg(&sep->pdev->dev, "revision is %d\n", sep->pdev->revision);
/* set up our register area */ /* Set up our register area */
sep->reg_physical_addr = pci_resource_start(sep->pdev, 0); sep->reg_physical_addr = pci_resource_start(sep->pdev, 0);
if (!sep->reg_physical_addr) { if (!sep->reg_physical_addr) {
dev_warn(&sep->pdev->dev, "Error getting register start\n"); dev_warn(&sep->pdev->dev, "Error getting register start\n");
...@@ -3395,7 +3390,7 @@ static int __devinit sep_probe(struct pci_dev *pdev, ...@@ -3395,7 +3390,7 @@ static int __devinit sep_probe(struct pci_dev *pdev,
(unsigned long long)sep->reg_physical_end, (unsigned long long)sep->reg_physical_end,
sep->reg_addr); sep->reg_addr);
/* allocate the shared area */ /* Allocate the shared area */
sep->shared_size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + sep->shared_size = SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES +
SYNCHRONIC_DMA_TABLES_AREA_SIZE_BYTES + SYNCHRONIC_DMA_TABLES_AREA_SIZE_BYTES +
SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES + SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES +
...@@ -3404,11 +3399,11 @@ static int __devinit sep_probe(struct pci_dev *pdev, ...@@ -3404,11 +3399,11 @@ static int __devinit sep_probe(struct pci_dev *pdev,
if (sep_map_and_alloc_shared_area(sep)) { if (sep_map_and_alloc_shared_area(sep)) {
error = -ENOMEM; error = -ENOMEM;
/* allocation failed */ /* Allocation failed */
goto end_function_error; goto end_function_error;
} }
/* the next section depends on type of unit */ /* The next section depends on type of unit */
if (sep->mrst) { if (sep->mrst) {
error = register_rar(RAR_TYPE_IMAGE, &sep_callback, error = register_rar(RAR_TYPE_IMAGE, &sep_callback,
(unsigned long)sep); (unsigned long)sep);
...@@ -3435,14 +3430,14 @@ static int __devinit sep_probe(struct pci_dev *pdev, ...@@ -3435,14 +3430,14 @@ static int __devinit sep_probe(struct pci_dev *pdev,
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 */ /* Clear ICR register */
sep_write_reg(sep, HW_HOST_ICR_REG_ADDR, 0xFFFFFFFF); sep_write_reg(sep, HW_HOST_ICR_REG_ADDR, 0xFFFFFFFF);
/* set the IMR register - open only GPR 2 */ /* Set the IMR register - open only GPR 2 */
sep_write_reg(sep, HW_HOST_IMR_REG_ADDR, (~(0x1 << 13))); 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 */ /* Get the interrupt line */
error = request_irq(pdev->irq, sep_inthandler, IRQF_SHARED, error = request_irq(pdev->irq, sep_inthandler, IRQF_SHARED,
"sep_driver", sep); "sep_driver", sep);
...@@ -3455,7 +3450,7 @@ static int __devinit sep_probe(struct pci_dev *pdev, ...@@ -3455,7 +3450,7 @@ static int __devinit sep_probe(struct pci_dev *pdev,
goto end_function; goto end_function;
end_function_deallocate_sep_shared_area: end_function_deallocate_sep_shared_area:
/* de-allocate shared area */ /* De-allocate shared area */
sep_unmap_and_free_shared_area(sep); sep_unmap_and_free_shared_area(sep);
end_function_error: end_function_error:
...@@ -3475,7 +3470,7 @@ static DEFINE_PCI_DEVICE_TABLE(sep_pci_id_tbl) = { ...@@ -3475,7 +3470,7 @@ static DEFINE_PCI_DEVICE_TABLE(sep_pci_id_tbl) = {
MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl); MODULE_DEVICE_TABLE(pci, sep_pci_id_tbl);
/* field for registering driver to PCI device */ /* Field for registering driver to PCI device */
static struct pci_driver sep_pci_driver = { static struct pci_driver sep_pci_driver = {
.name = "sep_sec_driver", .name = "sep_sec_driver",
.id_table = sep_pci_id_tbl, .id_table = sep_pci_id_tbl,
...@@ -3483,7 +3478,7 @@ static struct pci_driver sep_pci_driver = { ...@@ -3483,7 +3478,7 @@ static struct pci_driver sep_pci_driver = {
/* FIXME: remove handler */ /* FIXME: remove handler */
}; };
/* file operation for singleton sep operations */ /* File operation for singleton SEP operations */
static const struct file_operations singleton_file_operations = { static const struct file_operations singleton_file_operations = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.unlocked_ioctl = sep_singleton_ioctl, .unlocked_ioctl = sep_singleton_ioctl,
...@@ -3493,7 +3488,7 @@ static const struct file_operations singleton_file_operations = { ...@@ -3493,7 +3488,7 @@ static const struct file_operations singleton_file_operations = {
.mmap = sep_mmap, .mmap = sep_mmap,
}; };
/* file operation for daemon operations */ /* File operation for daemon operations */
static const struct file_operations daemon_file_operations = { static const struct file_operations daemon_file_operations = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.unlocked_ioctl = sep_request_daemon_ioctl, .unlocked_ioctl = sep_request_daemon_ioctl,
...@@ -3503,7 +3498,7 @@ static const struct file_operations daemon_file_operations = { ...@@ -3503,7 +3498,7 @@ static const struct file_operations daemon_file_operations = {
.mmap = sep_request_daemon_mmap, .mmap = sep_request_daemon_mmap,
}; };
/* the files operations structure of the driver */ /* The files operations structure of the driver */
static const struct file_operations sep_file_operations = { static const struct file_operations sep_file_operations = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.unlocked_ioctl = sep_ioctl, .unlocked_ioctl = sep_ioctl,
...@@ -3526,19 +3521,19 @@ static int sep_reconfig_shared_area(struct sep_device *sep) ...@@ -3526,19 +3521,19 @@ static int sep_reconfig_shared_area(struct sep_device *sep)
dev_dbg(&sep->pdev->dev, "reconfig shared area start\n"); dev_dbg(&sep->pdev->dev, "reconfig shared area start\n");
/* send the new SHARED MESSAGE AREA to the SEP */ /* Send the new SHARED MESSAGE AREA to the SEP */
dev_dbg(&sep->pdev->dev, "sending %08llx to sep\n", 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 */ /* Poll for SEP response */
ret_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR1_REG_ADDR); ret_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR1_REG_ADDR);
while (ret_val != 0xffffffff && ret_val != sep->shared_bus) while (ret_val != 0xffffffff && ret_val != sep->shared_bus)
ret_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR1_REG_ADDR); ret_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR1_REG_ADDR);
/* check the return value (register) */ /* Check the return value (register) */
if (ret_val != sep->shared_bus) { if (ret_val != sep->shared_bus) {
dev_warn(&sep->pdev->dev, "could not reconfig shared area\n"); dev_warn(&sep->pdev->dev, "could not reconfig shared area\n");
dev_warn(&sep->pdev->dev, "result was %x\n", ret_val); dev_warn(&sep->pdev->dev, "result was %x\n", ret_val);
...@@ -3574,7 +3569,7 @@ static int sep_register_driver_to_fs(struct sep_device *sep) ...@@ -3574,7 +3569,7 @@ static int sep_register_driver_to_fs(struct sep_device *sep)
ret_val = misc_register(&sep->miscdev_sep); ret_val = misc_register(&sep->miscdev_sep);
if (ret_val) { if (ret_val) {
dev_warn(&sep->pdev->dev, "misc reg fails for sep %x\n", dev_warn(&sep->pdev->dev, "misc reg fails for SEP %x\n",
ret_val); ret_val);
return ret_val; return ret_val;
} }
...@@ -3611,7 +3606,7 @@ static int __init sep_init(void) ...@@ -3611,7 +3606,7 @@ static int __init sep_init(void)
int ret_val = 0; int ret_val = 0;
struct sep_device *sep = NULL; struct sep_device *sep = NULL;
pr_debug("Sep driver: Init start\n"); pr_debug("SEP driver: Init start\n");
ret_val = pci_register_driver(&sep_pci_driver); ret_val = pci_register_driver(&sep_pci_driver);
if (ret_val) { if (ret_val) {
...@@ -3628,14 +3623,14 @@ static int __init sep_init(void) ...@@ -3628,14 +3623,14 @@ static int __init sep_init(void)
mutex_init(&sep->sep_mutex); mutex_init(&sep->sep_mutex);
mutex_init(&sep->ioctl_mutex); mutex_init(&sep->ioctl_mutex);
/* new chip requires share area reconfigure */ /* The new chip requires ashared area reconfigure */
if (sep->pdev->revision == 4) { /* only for new chip */ if (sep->pdev->revision == 4) { /* Only for new chip */
ret_val = sep_reconfig_shared_area(sep); ret_val = sep_reconfig_shared_area(sep);
if (ret_val) if (ret_val)
goto end_function_unregister_pci; goto end_function_unregister_pci;
} }
/* register driver to fs */ /* Register driver to fs */
ret_val = sep_register_driver_to_fs(sep); ret_val = sep_register_driver_to_fs(sep);
if (ret_val) { 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");
...@@ -3665,18 +3660,18 @@ static void __exit sep_exit(void) ...@@ -3665,18 +3660,18 @@ static void __exit sep_exit(void)
sep = sep_dev; sep = sep_dev;
pr_debug("Exit start\n"); pr_debug("Exit start\n");
/* unregister from fs */ /* Unregister from fs */
misc_deregister(&sep->miscdev_sep); misc_deregister(&sep->miscdev_sep);
misc_deregister(&sep->miscdev_singleton); misc_deregister(&sep->miscdev_singleton);
misc_deregister(&sep->miscdev_daemon); misc_deregister(&sep->miscdev_daemon);
/* free the irq */ /* Free the irq */
free_irq(sep->pdev->irq, sep); free_irq(sep->pdev->irq, sep);
/* unregister the driver */ /* Unregister the driver */
pci_unregister_driver(&sep_pci_driver); pci_unregister_driver(&sep_pci_driver);
/* free shared area */ /* Free the shared area */
if (sep_dev) { if (sep_dev) {
sep_unmap_and_free_shared_area(sep_dev); sep_unmap_and_free_shared_area(sep_dev);
dev_dbg(&sep->pdev->dev, dev_dbg(&sep->pdev->dev,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7