* 2010.09.14 Upgrade to Medfield
*
*/
-#define DEBUG
#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
static struct sep_device *sep_dev;
-/**
- * sep_load_firmware - copy firmware cache/resident
- * @sep: pointer to struct sep_device we are loading
- *
- * This functions copies the cache and resident from their source
- * location into destination shared memory.
- */
-static int sep_load_firmware(struct sep_device *sep)
-{
- const struct firmware *fw;
- char *cache_name = "cache.image.bin";
- char *res_name = "resident.image.bin";
- char *extapp_name = "extapp.image.bin";
- int error ;
- unsigned long work1, work2, work3;
-
- /* Set addresses and load resident */
- sep->resident_bus = sep->rar_bus;
- sep->resident_addr = sep->rar_addr;
-
- error = request_firmware(&fw, res_name, &sep->pdev->dev);
- if (error) {
- dev_warn(&sep->pdev->dev, "can't request resident fw\n");
- return error;
- }
-
- memcpy(sep->resident_addr, (void *)fw->data, fw->size);
- sep->resident_size = fw->size;
- release_firmware(fw);
-
- dev_dbg(&sep->pdev->dev, "resident virtual is %p\n",
- sep->resident_addr);
- dev_dbg(&sep->pdev->dev, "resident bus is %lx\n",
- (unsigned long)sep->resident_bus);
- dev_dbg(&sep->pdev->dev, "resident size is %08zx\n",
- sep->resident_size);
-
- /* Set addresses for dcache (no loading needed) */
- work1 = (unsigned long)sep->resident_bus;
- work2 = (unsigned long)sep->resident_size;
- work3 = (work1 + work2 + (1024 * 4)) & 0xfffff000;
- sep->dcache_bus = (dma_addr_t)work3;
-
- work1 = (unsigned long)sep->resident_addr;
- work2 = (unsigned long)sep->resident_size;
- work3 = (work1 + work2 + (1024 * 4)) & 0xfffff000;
- sep->dcache_addr = (void *)work3;
-
- sep->dcache_size = 1024 * 128;
-
- /* Set addresses and load cache */
- sep->cache_bus = sep->dcache_bus + sep->dcache_size;
- sep->cache_addr = sep->dcache_addr + sep->dcache_size;
-
- error = request_firmware(&fw, cache_name, &sep->pdev->dev);
- if (error) {
- dev_warn(&sep->pdev->dev, "Unable to request cache firmware\n");
- return error;
- }
-
- memcpy(sep->cache_addr, (void *)fw->data, fw->size);
- sep->cache_size = fw->size;
- release_firmware(fw);
-
- dev_dbg(&sep->pdev->dev, "cache virtual is %p\n",
- sep->cache_addr);
- dev_dbg(&sep->pdev->dev, "cache bus is %08lx\n",
- (unsigned long)sep->cache_bus);
- dev_dbg(&sep->pdev->dev, "cache size is %08zx\n",
- sep->cache_size);
-
- /* Set addresses and load extapp */
- sep->extapp_bus = sep->cache_bus + (1024 * 370);
- sep->extapp_addr = sep->cache_addr + (1024 * 370);
-
- error = request_firmware(&fw, extapp_name, &sep->pdev->dev);
- if (error) {
- dev_warn(&sep->pdev->dev, "Unable to request extapp firmware\n");
- return error;
- }
-
- memcpy(sep->extapp_addr, (void *)fw->data, fw->size);
- sep->extapp_size = fw->size;
- release_firmware(fw);
-
- dev_dbg(&sep->pdev->dev, "extapp virtual is %p\n",
- sep->extapp_addr);
- dev_dbg(&sep->pdev->dev, "extapp bus is %08llx\n",
- (unsigned long long)sep->extapp_bus);
- dev_dbg(&sep->pdev->dev, "extapp size is %08zx\n",
- sep->extapp_size);
-
- return error;
-}
-
-MODULE_FIRMWARE("sep/cache.image.bin");
-MODULE_FIRMWARE("sep/resident.image.bin");
-MODULE_FIRMWARE("sep/extapp.image.bin");
-
/**
* sep_dump_message - dump the message that is pending
* @sep: SEP device
*/
static void sep_unmap_and_free_shared_area(struct sep_device *sep)
{
- dev_dbg(&sep->pdev->dev, "shared area unmap and free\n");
dma_free_coherent(&sep->pdev->dev, sep->shared_size,
sep->shared_addr, sep->shared_bus);
}
*/
static int sep_singleton_open(struct inode *inode_ptr, struct file *file_ptr)
{
- int error = 0;
struct sep_device *sep;
/*
file_ptr->private_data = sep;
- dev_dbg(&sep->pdev->dev, "Singleton open for pid %d\n", current->pid);
-
- dev_dbg(&sep->pdev->dev, "calling test and set for singleton 0\n");
- if (test_and_set_bit(0, &sep->singleton_access_flag)) {
- error = -EBUSY;
- goto end_function;
- }
-
- dev_dbg(&sep->pdev->dev, "sep_singleton_open end\n");
-end_function:
- return error;
+ if (test_and_set_bit(0, &sep->singleton_access_flag))
+ return -EBUSY;
+ return 0;
}
/**
sep = sep_dev;
filp->private_data = sep;
- dev_dbg(&sep->pdev->dev, "Open for pid %d\n", current->pid);
-
/* Anyone can open; locking takes place at transaction level */
return 0;
}
{
struct sep_device *sep = filp->private_data;
- dev_dbg(&sep->pdev->dev, "Singleton release for pid %d\n",
- current->pid);
clear_bit(0, &sep->singleton_access_flag);
return 0;
}
filp->private_data = sep;
- dev_dbg(&sep->pdev->dev, "Request daemon open for pid %d\n",
- current->pid);
-
/* There is supposed to be only one request daemon */
- dev_dbg(&sep->pdev->dev, "calling test and set for req_dmon open 0\n");
if (test_and_set_bit(0, &sep->request_daemon_open))
error = -EBUSY;
return error;
{
struct sep_device *sep = filp->private_data;
- dev_dbg(&sep->pdev->dev, "Reques daemon release for pid %d\n",
+ dev_dbg(&sep->pdev->dev, "Request daemon release for pid %d\n",
current->pid);
/* Clear the request_daemon_open flag */
{
unsigned long lck_flags;
- dev_dbg(&sep->pdev->dev,
- "sep_req_daemon_send_reply_command_handler start\n");
-
sep_dump_message(sep);
/* Counters are lockable region */
"sep_req_daemon_send_reply send_ct %lx reply_ct %lx\n",
sep->send_ct, sep->reply_ct);
- dev_dbg(&sep->pdev->dev,
- "sep_req_daemon_send_reply_command_handler end\n");
-
return 0;
}
/* Pointer to the current dma_resource struct */
struct sep_dma_resource *dma;
- dev_dbg(&sep->pdev->dev, "sep_free_dma_table_data_handler start\n");
-
for (dcb_counter = 0; dcb_counter < sep->nr_dcb_creat; dcb_counter++) {
dma = &sep->dma_res_arr[dcb_counter];
sep->nr_dcb_creat = 0;
sep->num_lli_tables_created = 0;
- dev_dbg(&sep->pdev->dev, "sep_free_dma_table_data_handler end\n");
return 0;
}
dma_addr_t bus_address;
int error = 0;
- dev_dbg(&sep->pdev->dev, "daemon mmap start\n");
-
if ((vma->vm_end - vma->vm_start) > SEP_DRIVER_MMMAP_AREA_SIZE) {
error = -EINVAL;
goto end_function;
/* Get physical address */
bus_address = sep->shared_bus;
- dev_dbg(&sep->pdev->dev, "bus_address is %08lx\n",
- (unsigned long)bus_address);
-
if (remap_pfn_range(vma, vma->vm_start, bus_address >> PAGE_SHIFT,
vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
}
end_function:
- dev_dbg(&sep->pdev->dev, "daemon mmap end\n");
return error;
}
unsigned long lck_flags;
struct sep_device *sep = filp->private_data;
- dev_dbg(&sep->pdev->dev, "daemon poll: start\n");
-
poll_wait(filp, &sep->event_request_daemon, wait);
dev_dbg(&sep->pdev->dev, "daemon poll: send_ct is %lx reply ct is %lx\n",
mask = 0;
}
end_function:
- dev_dbg(&sep->pdev->dev, "daemon poll: exit\n");
return mask;
}
* clear the in use flags, and then wake up sep_event
* so that other processes can do transactions
*/
- dev_dbg(&sep->pdev->dev, "waking up event and mmap_event\n");
if (sep->pid_doing_transaction == current->pid) {
clear_bit(SEP_MMAP_LOCK_BIT, &sep->in_use_flags);
clear_bit(SEP_SEND_MSG_LOCK_BIT, &sep->in_use_flags);
struct sep_device *sep = filp->private_data;
unsigned long error = 0;
- dev_dbg(&sep->pdev->dev, "mmap start\n");
-
/* Set the transaction busy (own the device) */
wait_event_interruptible(sep->event,
test_and_set_bit(SEP_MMAP_LOCK_BIT,
/* Get bus address */
bus_addr = sep->shared_bus;
- dev_dbg(&sep->pdev->dev,
- "bus_address is %lx\n", (unsigned long)bus_addr);
-
if (remap_pfn_range(vma, vma->vm_start, bus_addr >> PAGE_SHIFT,
vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
dev_warn(&sep->pdev->dev, "remap_page_range failed\n");
error = -EAGAIN;
goto end_function_with_error;
}
- dev_dbg(&sep->pdev->dev, "mmap end\n");
goto end_function;
end_function_with_error:
/* Raise event for stuck contextes */
- dev_warn(&sep->pdev->dev, "mmap error - waking up event\n");
wake_up(&sep->event);
end_function:
struct sep_device *sep = filp->private_data;
- dev_dbg(&sep->pdev->dev, "poll: start\n");
-
/* Am I the process that owns the transaction? */
mutex_lock(&sep->sep_mutex);
if (current->pid != sep->pid_doing_transaction) {
- dev_warn(&sep->pdev->dev, "poll; wrong pid\n");
+ dev_dbg(&sep->pdev->dev, "poll; wrong pid\n");
mask = POLLERR;
mutex_unlock(&sep->sep_mutex);
goto end_function;
/* Check if send command or send_reply were activated previously */
if (!test_bit(SEP_SEND_MSG_LOCK_BIT, &sep->in_use_flags)) {
- dev_warn(&sep->pdev->dev, "poll; lock bit set\n");
mask = POLLERR;
goto end_function;
}
dev_dbg(&sep->pdev->dev, "poll: send_ct is %lx reply ct is %lx\n",
sep->send_ct, sep->reply_ct);
- /* Check if error occured during poll */
+ /* Check if error occurred during poll */
retval2 = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
if (retval2 != 0x0) {
dev_warn(&sep->pdev->dev, "poll; poll error %x\n", retval2);
}
end_function:
- dev_dbg(&sep->pdev->dev, "poll: end\n");
return mask;
}
u32 *time_addr; /* Address of time as seen by the kernel */
- dev_dbg(&sep->pdev->dev, "sep_set_time start\n");
-
do_gettimeofday(&time);
/* Set value in the SYSTEM MEMORY offset */
int i;
struct caller_id_struct command_args;
- dev_dbg(&sep->pdev->dev, "sep_set_caller_id_handler start\n");
-
for (i = 0; i < SEP_CALLER_ID_TABLE_NUM_ENTRIES; i++) {
if (sep->caller_id_table[i].pid == 0)
break;
}
if (i == SEP_CALLER_ID_TABLE_NUM_ENTRIES) {
- dev_warn(&sep->pdev->dev, "no more caller id entries left\n");
- dev_warn(&sep->pdev->dev, "maximum number is %d\n",
+ dev_dbg(&sep->pdev->dev, "no more caller id entries left\n");
+ dev_dbg(&sep->pdev->dev, "maximum number is %d\n",
SEP_CALLER_ID_TABLE_NUM_ENTRIES);
error = -EUSERS;
goto end_function;
hash, command_args.callerIdSizeInBytes))
error = -EFAULT;
end_function:
- dev_dbg(&sep->pdev->dev, "sep_set_caller_id_handler end\n");
return error;
}
int i;
u32 *hash_buf_ptr;
- dev_dbg(&sep->pdev->dev, "sep_set_current_caller_id start\n");
- dev_dbg(&sep->pdev->dev, "current process is %d\n", current->pid);
-
/* Zero the previous value */
memset(sep->shared_addr + SEP_CALLER_ID_OFFSET_BYTES,
0, SEP_CALLER_ID_HASH_SIZE_IN_BYTES);
for (i = 0; i < SEP_CALLER_ID_HASH_SIZE_IN_WORDS; i++)
hash_buf_ptr[i] = cpu_to_le32(hash_buf_ptr[i]);
- dev_dbg(&sep->pdev->dev, "sep_set_current_caller_id end\n");
return 0;
}
unsigned long lck_flags;
int error = 0;
- dev_dbg(&sep->pdev->dev, "sep_send_command_handler start\n");
-
if (test_and_set_bit(SEP_SEND_MSG_LOCK_BIT, &sep->in_use_flags)) {
error = -EPROTO;
goto end_function;
sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x2);
end_function:
- dev_dbg(&sep->pdev->dev, "sep_send_command_handler end\n");
return error;
}
/* Holds the allocated buffer address in the system memory pool */
u32 *token_addr;
- dev_dbg(&sep->pdev->dev,
- "sep_allocate_data_pool_memory_handler start\n");
-
if (copy_from_user(&command_args, (void __user *)arg,
sizeof(struct alloc_struct))) {
error = -EFAULT;
}
dev_dbg(&sep->pdev->dev,
- "bytes_allocated: %x\n", (int)sep->data_pool_bytes_allocated);
+ "data pool bytes_allocated: %x\n", (int)sep->data_pool_bytes_allocated);
dev_dbg(&sep->pdev->dev,
"offset: %x\n", SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES);
/* Set the virtual and bus address */
command_args.offset = SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES +
sep->data_pool_bytes_allocated;
- dev_dbg(&sep->pdev->dev,
- "command_args.offset: %x\n", command_args.offset);
-
/* Place in the shared area that is known by the SEP */
token_addr = (u32 *)(sep->shared_addr +
SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES +
(sep->num_of_data_allocations)*2*sizeof(u32));
- dev_dbg(&sep->pdev->dev, "allocation offset: %x\n",
- SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES);
- dev_dbg(&sep->pdev->dev, "data pool token addr is %p\n", token_addr);
-
token_addr[0] = SEP_DATA_POOL_POINTERS_VAL_TOKEN;
token_addr[1] = (u32)sep->shared_bus +
SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES +
sep->data_pool_bytes_allocated;
- dev_dbg(&sep->pdev->dev, "data pool token [0] %x\n", token_addr[0]);
- dev_dbg(&sep->pdev->dev, "data pool token [1] %x\n", token_addr[1]);
-
/* Write the memory back to the user space */
error = copy_to_user((void *)arg, (void *)&command_args,
sizeof(struct alloc_struct));
sep->data_pool_bytes_allocated += command_args.num_bytes;
sep->num_of_data_allocations += 1;
- dev_dbg(&sep->pdev->dev, "data_allocations %d\n",
- sep->num_of_data_allocations);
- dev_dbg(&sep->pdev->dev, "bytes allocated %d\n",
- (int)sep->data_pool_bytes_allocated);
-
end_function:
- dev_dbg(&sep->pdev->dev, "sep_allocate_data_pool_memory_handler end\n");
return error;
}
/* Map array */
struct sep_dma_map *map_array;
- dev_dbg(&sep->pdev->dev, "sep_lock_kernel_pages start\n");
- dev_dbg(&sep->pdev->dev, "kernel_virt_addr is %08lx\n",
+ dev_dbg(&sep->pdev->dev, "lock kernel pages kernel_virt_addr is %08lx\n",
(unsigned long)kernel_virt_addr);
dev_dbg(&sep->pdev->dev, "data_size is %x\n", data_size);
kfree(lli_array);
end_function:
- dev_dbg(&sep->pdev->dev, "sep_lock_kernel_pages end\n");
return error;
}
/* Direction of the DMA mapping for locked pages */
enum dma_data_direction dir;
- dev_dbg(&sep->pdev->dev, "sep_lock_user_pages start\n");
-
/* Set start and end pages and num pages */
end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT;
start_page = app_virt_addr >> PAGE_SHIFT;
num_pages = end_page - start_page + 1;
- dev_dbg(&sep->pdev->dev, "app_virt_addr is %x\n", app_virt_addr);
+ dev_dbg(&sep->pdev->dev, "lock user pages app_virt_addr is %x\n", app_virt_addr);
dev_dbg(&sep->pdev->dev, "data_size is %x\n", data_size);
dev_dbg(&sep->pdev->dev, "start_page is %x\n", start_page);
dev_dbg(&sep->pdev->dev, "end_page is %x\n", end_page);
dev_dbg(&sep->pdev->dev, "num_pages is %x\n", num_pages);
- dev_dbg(&sep->pdev->dev, "starting page_array malloc\n");
-
/* Allocate array of pages structure pointers */
page_array = kmalloc(sizeof(struct page *) * num_pages, GFP_ATOMIC);
if (!page_array) {
goto end_function_with_error2;
}
- dev_dbg(&sep->pdev->dev, "starting get_user_pages\n");
-
/* Convert the application virtual address into a set of physical */
down_read(¤t->mm->mmap_sem);
result = get_user_pages(current, current->mm, app_virt_addr,
lli_array[count].block_size);
}
- /* Set output params acording to the in_out flag */
+ /* Set output params according to the in_out flag */
if (in_out_flag == SEP_DRIVER_IN_FLAG) {
*lli_array_ptr = lli_array;
sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages = num_pages;
kfree(page_array);
end_function:
- dev_dbg(&sep->pdev->dev, "sep_lock_user_pages end\n");
return error;
}
table_data_size -= (SEP_DRIVER_MIN_DATA_SIZE_PER_TABLE -
next_table_data_size);
- dev_dbg(&sep->pdev->dev, "table data size is %x\n",
- table_data_size);
end_function:
return table_data_size;
}
/* Counter of lli array entry */
u32 array_counter;
- dev_dbg(&sep->pdev->dev, "sep_build_lli_table start\n");
-
/* Init currrent table data size and lli array entry counter */
curr_table_data_size = 0;
array_counter = 0;
*num_table_entries_ptr = 1;
- dev_dbg(&sep->pdev->dev, "table_data_size is %x\n", table_data_size);
+ dev_dbg(&sep->pdev->dev, "build lli table table_data_size is %x\n", table_data_size);
/* Fill the table till table size reaches the needed amount */
while (curr_table_data_size < table_data_size) {
lli_table_ptr->bus_address = 0xffffffff;
lli_table_ptr->block_size = 0;
- dev_dbg(&sep->pdev->dev, "lli_table_ptr is %p\n", lli_table_ptr);
- dev_dbg(&sep->pdev->dev, "lli_table_ptr->bus_address is %08lx\n",
- (unsigned long)lli_table_ptr->bus_address);
- dev_dbg(&sep->pdev->dev, "lli_table_ptr->block_size is %x\n",
- lli_table_ptr->block_size);
-
/* Set the output parameter */
*num_processed_entries_ptr += array_counter;
- dev_dbg(&sep->pdev->dev, "num_processed_entries_ptr is %x\n",
- *num_processed_entries_ptr);
-
- dev_dbg(&sep->pdev->dev, "sep_build_lli_table end\n");
}
/**
{
struct sep_lli_entry *lli_table_ptr;
- dev_dbg(&sep->pdev->dev, "sep_prepare_empty_lli_table start\n");
-
/* Find the area for new table */
lli_table_ptr =
(struct sep_lli_entry *)(sep->shared_addr +
/* Update the number of created tables */
sep->num_lli_tables_created++;
-
- dev_dbg(&sep->pdev->dev, "sep_prepare_empty_lli_table start\n");
-
}
/**
/* Next table address */
void *lli_table_alloc_addr = 0;
- dev_dbg(&sep->pdev->dev, "sep_prepare_input_dma_table start\n");
- dev_dbg(&sep->pdev->dev, "data_size is %x\n", data_size);
+ dev_dbg(&sep->pdev->dev, "prepare intput dma table data_size is %x\n", data_size);
dev_dbg(&sep->pdev->dev, "block_size is %x\n", block_size);
/* Initialize the pages pointers */
/*
* If this is not the last table -
- * then allign it to the block size
+ * then align it to the block size
*/
if (!last_table_flag)
table_data_size =
kfree(sep->dma_res_arr[sep->nr_dcb_creat].in_page_array);
end_function:
- dev_dbg(&sep->pdev->dev, "sep_prepare_input_dma_table end\n");
return error;
}
/* Number of etnries in the output table */
u32 num_entries_out_table = 0;
- dev_dbg(&sep->pdev->dev, "sep_construct_dma_tables_from_lli start\n");
-
/* Initiate to point after the message area */
lli_table_alloc_addr = (void *)(sep->shared_addr +
SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES +
&last_table_flag);
dev_dbg(&sep->pdev->dev,
- "in_table_data_size is %x\n",
+ "construct tables from lli in_table_data_size is %x\n",
in_table_data_size);
dev_dbg(&sep->pdev->dev,
- "out_table_data_size is %x\n",
+ "construct tables from lli out_table_data_size is %x\n",
out_table_data_size);
table_data_size = in_table_data_size;
block_size;
}
- dev_dbg(&sep->pdev->dev, "table_data_size is %x\n",
- table_data_size);
-
/* Construct input lli table */
sep_build_lli_table(sep, &lli_in_array[current_in_entry],
in_lli_table_ptr,
*out_num_entries_ptr,
*table_data_size_ptr);
- dev_dbg(&sep->pdev->dev, "sep_construct_dma_tables_from_lli end\n");
return 0;
}
/* Array of pointers of page */
struct sep_lli_entry *lli_out_array;
- dev_dbg(&sep->pdev->dev, "sep_prepare_input_output_dma_table start\n");
-
if (data_size == 0) {
/* Prepare empty table for input and output */
sep_prepare_empty_lli_table(sep, lli_table_in_ptr,
}
}
- dev_dbg(&sep->pdev->dev, "sep_in_num_pages is %x\n",
+ dev_dbg(&sep->pdev->dev, "prep input output dma table sep_in_num_pages is %x\n",
sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages);
dev_dbg(&sep->pdev->dev, "sep_out_num_pages is %x\n",
sep->dma_res_arr[sep->nr_dcb_creat].out_num_pages);
dev_dbg(&sep->pdev->dev, "SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n",
SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
- /* Call the fucntion that creates table from the lli arrays */
+ /* Call the function that creates table from the lli arrays */
error = sep_construct_dma_tables_from_lli(sep, lli_in_array,
sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages,
lli_out_array,
update_dcb_counter:
/* Update DCB counter */
sep->nr_dcb_creat++;
- /* Fall through - free the lli entry arrays */
- dev_dbg(&sep->pdev->dev, "in_num_entries_ptr is %08x\n",
- *in_num_entries_ptr);
- dev_dbg(&sep->pdev->dev, "out_num_entries_ptr is %08x\n",
- *out_num_entries_ptr);
- dev_dbg(&sep->pdev->dev, "table_data_size_ptr is %08x\n",
- *table_data_size_ptr);
goto end_function;
kfree(lli_in_array);
end_function:
- dev_dbg(&sep->pdev->dev,
- "sep_prepare_input_output_dma_table end result = %d\n", error);
return error;
/* Data in the first input/output table */
u32 first_data_size = 0;
- dev_dbg(&sep->pdev->dev, "prepare_input_output_dma_table_in_dcb start\n");
-
if (sep->nr_dcb_creat == SEP_MAX_NUM_SYNC_DMA_OPS) {
/* No more DCBs to allocate */
dev_warn(&sep->pdev->dev, "no more DCBs available\n");
dcb_table_ptr->out_vr_tail_pt = 0;
if (isapplet == true) {
- tail_size = data_in_size % block_size;
- if (tail_size) {
- if (data_in_size < tail_block_size) {
- dev_warn(&sep->pdev->dev, "data in size smaller than tail block size\n");
- error = -ENOSPC;
- goto end_function;
- }
- if (tail_block_size)
- /*
- * Case the tail size should be
- * bigger than the real block size
- */
- tail_size = tail_block_size +
- ((data_in_size -
- tail_block_size) % block_size);
- }
/* Check if there is enough data for DMA operation */
if (data_in_size < SEP_DRIVER_MIN_DATA_SIZE_PER_TABLE) {
/* Set the output user-space address for mem2mem op */
if (app_out_address)
dcb_table_ptr->out_vr_tail_pt =
- (u32)app_out_address;
+ (aligned_u64)app_out_address;
/*
* Update both data length parameters in order to avoid
*/
tail_size = 0x0;
data_in_size = 0x0;
+
+ } else {
+ if (!app_out_address) {
+ tail_size = data_in_size % block_size;
+ if (!tail_size) {
+ if (tail_block_size == block_size)
+ tail_size = block_size;
+ }
+ } else {
+ tail_size = 0;
+ }
}
if (tail_size) {
if (is_kva == true) {
* according to tail data size
*/
dcb_table_ptr->out_vr_tail_pt =
- (u32)app_out_address + data_in_size
+ (aligned_u64)app_out_address + data_in_size
- tail_size;
/* Save the real tail data size */
dcb_table_ptr->output_mlli_data_size = first_data_size;
end_function:
- dev_dbg(&sep->pdev->dev,
- "sep_prepare_input_output_dma_table_in_dcb end\n");
return error;
}
-
-/**
- * sep_create_sync_dma_tables_handler - create sync DMA tables
- * @sep: pointer to struct sep_device
- * @arg: pointer to struct bld_syn_tab_struct
- *
- * Handle the request for creation of the DMA tables for the synchronic
- * symmetric operations (AES,DES). Note that all bus addresses that are
- * passed to the SEP are in 32 bit format; the SEP is a 32 bit device
- */
-static int sep_create_sync_dma_tables_handler(struct sep_device *sep,
- unsigned long arg)
-{
- int error = 0;
-
- /* Command arguments */
- struct bld_syn_tab_struct command_args;
-
- dev_dbg(&sep->pdev->dev,
- "sep_create_sync_dma_tables_handler start\n");
-
- if (copy_from_user(&command_args, (void __user *)arg,
- sizeof(struct bld_syn_tab_struct))) {
- error = -EFAULT;
- goto end_function;
- }
-
- dev_dbg(&sep->pdev->dev, "app_in_address is %08llx\n",
- command_args.app_in_address);
- dev_dbg(&sep->pdev->dev, "app_out_address is %08llx\n",
- command_args.app_out_address);
- dev_dbg(&sep->pdev->dev, "data_size is %u\n",
- command_args.data_in_size);
- dev_dbg(&sep->pdev->dev, "block_size is %u\n",
- command_args.block_size);
-
- /* Validate user parameters */
- if (!command_args.app_in_address) {
- error = -EINVAL;
- goto end_function;
- }
-
- error = sep_prepare_input_output_dma_table_in_dcb(sep,
- (unsigned long)command_args.app_in_address,
- (unsigned long)command_args.app_out_address,
- command_args.data_in_size,
- command_args.block_size,
- 0x0,
- false,
- false);
-
-end_function:
- dev_dbg(&sep->pdev->dev, "sep_create_sync_dma_tables_handler end\n");
- return error;
-}
-
/**
* sep_free_dma_tables_and_dcb - free DMA tables and DCBs
* @sep: pointer to struct sep_device
unsigned long pt_hold;
void *tail_pt;
- dev_dbg(&sep->pdev->dev, "sep_free_dma_tables_and_dcb start\n");
-
if (isapplet == true) {
/* Set pointer to first DCB table */
dcb_table_ptr = (struct sep_dcblock *)
/* Free the output pages, if any */
sep_free_dma_table_data_handler(sep);
- dev_dbg(&sep->pdev->dev, "sep_free_dma_tables_and_dcb end\n");
return error;
}
{
u32 *static_pool_addr = NULL;
- dev_dbg(&sep->pdev->dev, "sep_get_static_pool_addr_handler start\n");
-
static_pool_addr = (u32 *)(sep->shared_addr +
SEP_DRIVER_SYSTEM_RAR_MEMORY_OFFSET_IN_BYTES);
static_pool_addr[1] = (u32)sep->shared_bus +
SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES;
- dev_dbg(&sep->pdev->dev, "static pool: physical %x\n",
+ dev_dbg(&sep->pdev->dev, "static pool segment: physical %x\n",
(u32)static_pool_addr[1]);
- dev_dbg(&sep->pdev->dev, "sep_get_static_pool_addr_handler end\n");
-
return 0;
}
-/**
- * sep_start_handler - start device
- * @sep: pointer to struct sep_device
- */
-static int sep_start_handler(struct sep_device *sep)
-{
- unsigned long reg_val;
- unsigned long error = 0;
-
- dev_dbg(&sep->pdev->dev, "sep_start_handler start\n");
-
- /* Wait in polling for message from SEP */
- do {
- reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
- } while (!reg_val);
-
- /* Check the value */
- if (reg_val == 0x1)
- /* Fatal error - read error status from GPRO */
- error = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
- dev_dbg(&sep->pdev->dev, "sep_start_handler end\n");
- return error;
-}
-
-/**
- * ep_check_sum_calc - checksum messages
- * @data: buffer to checksum
- * @length: buffer size
- *
- * This function performs a checksum for messages that are sent
- * to the SEP.
- */
-static u32 sep_check_sum_calc(u8 *data, u32 length)
-{
- u32 sum = 0;
- u16 *Tdata = (u16 *)data;
-
- while (length > 1) {
- /* This is the inner loop */
- sum += *Tdata++;
- length -= 2;
- }
-
- /* Add left-over byte, if any */
- if (length > 0)
- sum += *(u8 *)Tdata;
-
- /* Fold 32-bit sum to 16 bits */
- while (sum>>16)
- sum = (sum & 0xffff) + (sum >> 16);
-
- return ~sum & 0xFFFF;
-}
-
-/**
- * sep_init_handler -
- * @sep: pointer to struct sep_device
- * @arg: parameters from user space application
- *
- * Handles the request for SEP initialization
- * Note that this will go away for Medfield once the SCU
- * SEP initialization is complete
- * Also note that the message to the SEP has components
- * from user space as well as components written by the driver
- * This is becuase the portions of the message that pertain to
- * physical addresses must be set by the driver after the message
- * leaves custody of the user space application for security
- * reasons.
- */
-static int sep_init_handler(struct sep_device *sep, unsigned long arg)
-{
- u32 message_buff[14];
- u32 counter;
- int error = 0;
- u32 reg_val;
- dma_addr_t new_base_addr;
- unsigned long addr_hold;
- struct init_struct command_args;
-
- dev_dbg(&sep->pdev->dev, "sep_init_handler start\n");
-
- /* Make sure that we have not initialized already */
- reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
-
- if (reg_val != 0x2) {
- error = SEP_ALREADY_INITIALIZED_ERR;
- dev_warn(&sep->pdev->dev, "init; device already initialized\n");
- goto end_function;
- }
-
- /* Only root can initialize */
- if (!capable(CAP_SYS_ADMIN)) {
- error = -EACCES;
- goto end_function;
- }
-
- /* Copy in the parameters */
- error = copy_from_user(&command_args, (void __user *)arg,
- sizeof(struct init_struct));
-
- if (error) {
- error = -EFAULT;
- goto end_function;
- }
-
- /* Validate parameters */
- if (!command_args.message_addr || !command_args.sep_sram_addr ||
- command_args.message_size_in_words > 14) {
- error = -EINVAL;
- goto end_function;
- }
-
- /* Copy in the SEP init message */
- addr_hold = (unsigned long)command_args.message_addr;
- error = copy_from_user(message_buff,
- (void __user *)addr_hold,
- command_args.message_size_in_words*sizeof(u32));
-
- if (error) {
- error = -EFAULT;
- goto end_function;
- }
-
- /* Load resident, cache, and extapp firmware */
- error = sep_load_firmware(sep);
-
- if (error) {
- dev_warn(&sep->pdev->dev,
- "init; copy SEP init message failed %x\n", error);
- goto end_function;
- }
-
- /* Compute the base address */
- new_base_addr = sep->shared_bus;
-
- if (sep->resident_bus < new_base_addr)
- new_base_addr = sep->resident_bus;
-
- if (sep->cache_bus < new_base_addr)
- new_base_addr = sep->cache_bus;
-
- if (sep->dcache_bus < new_base_addr)
- new_base_addr = sep->dcache_bus;
-
- /* Put physical addresses in SEP message */
- message_buff[3] = (u32)new_base_addr;
- message_buff[4] = (u32)sep->shared_bus;
- message_buff[6] = (u32)sep->resident_bus;
- message_buff[7] = (u32)sep->cache_bus;
- message_buff[8] = (u32)sep->dcache_bus;
-
- message_buff[command_args.message_size_in_words - 1] = 0x0;
- message_buff[command_args.message_size_in_words - 1] =
- sep_check_sum_calc((u8 *)message_buff,
- command_args.message_size_in_words*sizeof(u32));
-
- /* Debug print of message */
- for (counter = 0; counter < command_args.message_size_in_words;
- counter++)
- dev_dbg(&sep->pdev->dev, "init; SEP message word %d is %x\n",
- counter, message_buff[counter]);
-
- /* Tell the SEP the sram address */
- sep_write_reg(sep, HW_SRAM_ADDR_REG_ADDR, command_args.sep_sram_addr);
-
- /* Push the message to the SEP */
- for (counter = 0; counter < command_args.message_size_in_words;
- counter++) {
- sep_write_reg(sep, HW_SRAM_DATA_REG_ADDR,
- message_buff[counter]);
- sep_wait_sram_write(sep);
- }
-
- /* Signal SEP that message is ready and to init */
- sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x1);
-
- /* Wait for acknowledge */
- dev_dbg(&sep->pdev->dev, "init; waiting for msg response\n");
-
- do {
- reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
- } while (!(reg_val & 0xFFFFFFFD));
-
- if (reg_val == 0x1) {
- dev_warn(&sep->pdev->dev, "init; device int failed\n");
- error = sep_read_reg(sep, 0x8060);
- dev_warn(&sep->pdev->dev, "init; sw monitor is %x\n", error);
- error = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR0_REG_ADDR);
- dev_warn(&sep->pdev->dev, "init; error is %x\n", error);
- goto end_function;
- }
- dev_dbg(&sep->pdev->dev, "init; end CC INIT, reg_val is %x\n", reg_val);
-
- /* Signal SEP to zero the GPR3 */
- sep_write_reg(sep, HW_HOST_HOST_SEP_GPR0_REG_ADDR, 0x10);
-
- /* Wait for response */
- dev_dbg(&sep->pdev->dev, "init; waiting for zero set response\n");
-
- do {
- reg_val = sep_read_reg(sep, HW_HOST_SEP_HOST_GPR3_REG_ADDR);
- } while (reg_val != 0);
-
-end_function:
- dev_dbg(&sep->pdev->dev, "init is done\n");
- return error;
-}
-
/**
* sep_end_transaction_handler - end transaction
* @sep: pointer to struct sep_device
*/
static int sep_end_transaction_handler(struct sep_device *sep)
{
- dev_dbg(&sep->pdev->dev, "sep_end_transaction_handler start\n");
-
/* Clear the data pool pointers Token */
memset((void *)(sep->shared_addr +
SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES),
/* Raise event for stuck contextes */
wake_up(&sep->event);
- dev_dbg(&sep->pdev->dev, "waking up event\n");
- dev_dbg(&sep->pdev->dev, "sep_end_transaction_handler end\n");
-
return 0;
}
/* Command arguments */
struct build_dcb_struct command_args;
- dev_dbg(&sep->pdev->dev, "sep_prepare_dcb_handler start\n");
-
/* Get the command arguments */
if (copy_from_user(&command_args, (void __user *)arg,
sizeof(struct build_dcb_struct))) {
goto end_function;
}
- dev_dbg(&sep->pdev->dev, "app_in_address is %08llx\n",
+ dev_dbg(&sep->pdev->dev, "prep dcb handler app_in_address is %08llx\n",
command_args.app_in_address);
dev_dbg(&sep->pdev->dev, "app_out_address is %08llx\n",
command_args.app_out_address);
command_args.tail_block_size, true, false);
end_function:
- dev_dbg(&sep->pdev->dev, "sep_prepare_dcb_handler end\n");
return error;
}
*/
static int sep_free_dcb_handler(struct sep_device *sep)
{
- int error ;
-
- dev_dbg(&sep->pdev->dev, "sep_prepare_dcb_handler start\n");
- dev_dbg(&sep->pdev->dev, "num of DCBs %x\n", sep->nr_dcb_creat);
-
- error = sep_free_dma_tables_and_dcb(sep, false, false);
-
- dev_dbg(&sep->pdev->dev, "sep_free_dcb_handler end\n");
- return error;
+ return sep_free_dma_tables_and_dcb(sep, false, false);
}
/**
/* Holds the RAR address in the system memory offset */
u32 *rar_addr;
- dev_dbg(&sep->pdev->dev, "sep_rar_prepare_output_msg_handler start\n");
-
/* Copy the data */
if (copy_from_user(&command_args, (void __user *)arg,
sizeof(command_args))) {
rar_buf.info.handle = (u32)command_args.rar_handle;
if (rar_handle_to_bus(&rar_buf, 1) != 1) {
- dev_dbg(&sep->pdev->dev, "rar_handle_to_bus failure\n");
error = -EFAULT;
goto end_function;
}
rar_addr[1] = rar_bus;
end_function:
- dev_dbg(&sep->pdev->dev, "sep_rar_prepare_output_msg_handler start\n");
return error;
}
-/**
- * sep_realloc_ext_cache_handler - report location of extcache
- * @sep: pointer to struct sep_device
- * @arg: pointer to user parameters
- *
- * This function tells the SEP where the extapp is located
- */
-static int sep_realloc_ext_cache_handler(struct sep_device *sep,
- unsigned long arg)
-{
- /* Holds the new ext cache address in the system memory offset */
- u32 *system_addr;
-
- /* Set value in the SYSTEM MEMORY offset */
- system_addr = (u32 *)(sep->shared_addr +
- SEP_DRIVER_SYSTEM_EXT_CACHE_ADDR_OFFSET_IN_BYTES);
-
- /* Copy the physical address to the System Area for the SEP */
- system_addr[0] = SEP_EXT_CACHE_ADDR_VAL_TOKEN;
- dev_dbg(&sep->pdev->dev, "ext cache init; system addr 0 is %x\n",
- system_addr[0]);
- system_addr[1] = sep->extapp_bus;
- dev_dbg(&sep->pdev->dev, "ext cache init; system addr 1 is %x\n",
- system_addr[1]);
-
- return 0;
-}
-
/**
* sep_ioctl - ioctl api
* @filp: pointer to struct file
* @cmd: command
* @arg: pointer to argument structure
*
- * Implement the ioctl methods availble on the SEP device.
+ * Implement the ioctl methods available on the SEP device.
*/
static long sep_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
int error = 0;
struct sep_device *sep = filp->private_data;
- dev_dbg(&sep->pdev->dev, "ioctl start\n");
-
- dev_dbg(&sep->pdev->dev, "cmd is %x\n", cmd);
-
/* Make sure we own this device */
mutex_lock(&sep->sep_mutex);
if ((current->pid != sep->pid_doing_transaction) &&
(sep->pid_doing_transaction != 0)) {
dev_dbg(&sep->pdev->dev, "ioctl pid is not owner\n");
- mutex_unlock(&sep->sep_mutex);
error = -EACCES;
goto end_function;
}
mutex_unlock(&sep->sep_mutex);
- /* Check that the command is for SEP device */
- if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) {
- error = -ENOTTY;
- goto end_function;
- }
+ if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER)
+ return -ENOTTY;
/* Lock to prevent the daemon to interfere with operation */
mutex_lock(&sep->ioctl_mutex);
/* Allocate data pool */
error = sep_allocate_data_pool_memory_handler(sep, arg);
break;
- case SEP_IOCCREATESYMDMATABLE:
- /* Create DMA table for synhronic operation */
- error = sep_create_sync_dma_tables_handler(sep, arg);
- break;
- case SEP_IOCFREEDMATABLEDATA:
- /* Free the pages */
- error = sep_free_dma_table_data_handler(sep);
- break;
- case SEP_IOCSEPSTART:
- /* Start command to SEP */
- if (sep->pdev->revision == 0) /* Only for old chip */
- error = sep_start_handler(sep);
- else
- error = -EPERM; /* Not permitted on new chip */
- break;
- case SEP_IOCSEPINIT:
- /* Init command to SEP */
- if (sep->pdev->revision == 0) /* Only for old chip */
- error = sep_init_handler(sep, arg);
- else
- error = -EPERM; /* Not permitted on new chip */
- break;
case SEP_IOCGETSTATICPOOLADDR:
/* Inform the SEP the bus address of the static pool */
error = sep_get_static_pool_addr_handler(sep);
case SEP_IOCENDTRANSACTION:
error = sep_end_transaction_handler(sep);
break;
- case SEP_IOCREALLOCEXTCACHE:
- if (sep->pdev->revision == 0) /* Only for old chip */
- error = sep_realloc_ext_cache_handler(sep, arg);
- else
- error = -EPERM; /* Not permitted on new chip */
- break;
case SEP_IOCRARPREPAREMESSAGE:
error = sep_rar_prepare_output_msg_handler(sep, arg);
break;
error = sep_free_dcb_handler(sep);
break;
default:
- dev_dbg(&sep->pdev->dev, "invalid ioctl %x\n", cmd);
error = -ENOTTY;
break;
}
- mutex_unlock(&sep->ioctl_mutex);
end_function:
- dev_dbg(&sep->pdev->dev, "ioctl end\n");
+ mutex_unlock(&sep->ioctl_mutex);
return error;
}
long error = 0;
struct sep_device *sep = filp->private_data;
- dev_dbg(&sep->pdev->dev, "singleton_ioctl start\n");
- dev_dbg(&sep->pdev->dev, "cmd is %x\n", cmd);
-
/* Check that the command is for the SEP device */
- if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) {
- error = -ENOTTY;
- goto end_function;
- }
+ if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER)
+ return -ENOTTY;
/* Make sure we own this device */
mutex_lock(&sep->sep_mutex);
(sep->pid_doing_transaction != 0)) {
dev_dbg(&sep->pdev->dev, "singleton ioctl pid is not owner\n");
mutex_unlock(&sep->sep_mutex);
- error = -EACCES;
- goto end_function;
+ return -EACCES;
}
mutex_unlock(&sep->sep_mutex);
error = sep_ioctl(filp, cmd, arg);
break;
}
-
-end_function:
- dev_dbg(&sep->pdev->dev, "singleton ioctl end\n");
return error;
}
long error;
struct sep_device *sep = filp->private_data;
- dev_dbg(&sep->pdev->dev, "daemon ioctl: start\n");
- dev_dbg(&sep->pdev->dev, "daemon ioctl: cmd is %x\n", cmd);
-
/* Check that the command is for SEP device */
- if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER) {
- error = -ENOTTY;
- goto end_function;
- }
+ if (_IOC_TYPE(cmd) != SEP_IOC_MAGIC_NUMBER)
+ return -ENOTTY;
/* Only one process can access ioctl at any given time */
mutex_lock(&sep->ioctl_mutex);
error = 0;
break;
default:
- dev_dbg(&sep->pdev->dev, "daemon ioctl: no such IOCTL\n");
error = -ENOTTY;
}
mutex_unlock(&sep->ioctl_mutex);
-
-end_function:
- dev_dbg(&sep->pdev->dev, "daemon ioctl: end\n");
return error;
-
}
/**
/* Read the IRR register to check if this is SEP interrupt */
reg_val = sep_read_reg(sep, HW_HOST_IRR_REG_ADDR);
- dev_dbg(&sep->pdev->dev, "SEP Interrupt - reg is %08x\n", reg_val);
if (reg_val & (0x1 << 13)) {
/* Lock and update the counter of reply messages */
/* use to limit waiting for SEP */
unsigned long end_time;
- dev_dbg(&sep->pdev->dev, "reconfig shared area start\n");
-
/* Send the new SHARED MESSAGE AREA to the SEP */
- dev_dbg(&sep->pdev->dev, "sending %08llx to sep\n",
+ dev_dbg(&sep->pdev->dev, "reconfig shared; sending %08llx to sep\n",
(unsigned long long)sep->shared_bus);
sep_write_reg(sep, HW_HOST_HOST_SEP_GPR1_REG_ADDR, sep->shared_bus);
int error = 0;
struct sep_device *sep;
- pr_debug("SEP pci probe starting\n");
if (sep_dev != NULL) {
dev_warn(&pdev->dev, "only one SEP supported.\n");
return -EBUSY;
mutex_init(&sep->sep_mutex);
mutex_init(&sep->ioctl_mutex);
- dev_dbg(&sep->pdev->dev, "PCI obtained, device being prepared\n");
+ dev_dbg(&sep->pdev->dev, "sep probe: PCI obtained, device being prepared\n");
dev_dbg(&sep->pdev->dev, "revision is %d\n", sep->pdev->revision);
/* Set up our register area */
goto end_function_error;
}
- sep->rar_size = FAKE_RAR_SIZE;
- sep->rar_addr = dma_alloc_coherent(&sep->pdev->dev,
- sep->rar_size, &sep->rar_bus, GFP_KERNEL);
- if (sep->rar_addr == NULL) {
- dev_warn(&sep->pdev->dev, "can't allocate mfld rar\n");
- error = -ENOMEM;
- goto end_function_deallocate_sep_shared_area;
- }
-
- dev_dbg(&sep->pdev->dev, "rar start is %p, phy is %llx,"
- " size is %zx\n", sep->rar_addr,
- (unsigned long long)sep->rar_bus,
- sep->rar_size);
-
- dev_dbg(&sep->pdev->dev, "about to write IMR and ICR REG_ADDR\n");
-
/* Clear ICR register */
sep_write_reg(sep, HW_HOST_ICR_REG_ADDR, 0xFFFFFFFF);
sep->reply_ct &= 0x3FFFFFFF;
sep->send_ct = sep->reply_ct;
- dev_dbg(&sep->pdev->dev, "about to call request_irq\n");
/* Get the interrupt line */
error = request_irq(pdev->irq, sep_inthandler, IRQF_SHARED,
"sep_driver", sep);
if (error)
- goto end_function_dealloc_rar;
+ goto end_function_deallocate_sep_shared_area;
- /* The new chip requires ashared area reconfigure */
+ /* The new chip requires a shared area reconfigure */
if (sep->pdev->revision == 4) { /* Only for new chip */
error = sep_reconfig_shared_area(sep);
if (error)
end_function_free_irq:
free_irq(pdev->irq, sep);
-end_function_dealloc_rar:
- if (sep->rar_addr)
- dma_free_coherent(&sep->pdev->dev, sep->rar_size,
- sep->rar_addr, sep->rar_bus);
- goto end_function;
-
end_function_deallocate_sep_shared_area:
/* De-allocate shared area */
sep_unmap_and_free_shared_area(sep);
projects / mirror_ubuntu-zesty-kernel.git / blobdiff