dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

staging "sep" Fix typos found while reading. 

Signed-off-by: Justin P. Mattock <justinmattock@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Justin P. Mattock 2012-06-11 07:48:46 -07:00 committed by Greg Kroah-Hartman
parent 7a2ea600fc
commit e34995148a
4 changed files with 33 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
drivers/staging/sep/sep_crypto.c
View File

@ -807,7 +807,7 @@ end_function:
* @size: size of parameter to copy (in bytes) * @size: size of parameter to copy (in bytes)
* @max_size: size to move up offset; SEP mesg is in word sizes * @max_size: size to move up offset; SEP mesg is in word sizes
* @msg_offset: pointer to current offset (is updated) * @msg_offset: pointer to current offset (is updated)
* @byte_array: flag ti indicate wheter endian must be changed * @byte_array: flag ti indicate whether endian must be changed
* Copies data into the message area from caller * Copies data into the message area from caller
*/ */
static void sep_write_msg(struct this_task_ctx *ta_ctx, void *in_addr, static void sep_write_msg(struct this_task_ctx *ta_ctx, void *in_addr,
@ -855,7 +855,7 @@ static void sep_make_header(struct this_task_ctx *ta_ctx, u32 *msg_offset,
* @size: size of parameter to copy (in bytes) * @size: size of parameter to copy (in bytes)
* @max_size: size to move up offset; SEP mesg is in word sizes * @max_size: size to move up offset; SEP mesg is in word sizes
* @msg_offset: pointer to current offset (is updated) * @msg_offset: pointer to current offset (is updated)
* @byte_array: flag ti indicate wheter endian must be changed * @byte_array: flag ti indicate whether endian must be changed
* Copies data out of the message area to caller * Copies data out of the message area to caller
*/ */
static void sep_read_msg(struct this_task_ctx *ta_ctx, void *in_addr, static void sep_read_msg(struct this_task_ctx *ta_ctx, void *in_addr,
@ -990,7 +990,7 @@ static void sep_clear_out(struct this_task_ctx *ta_ctx)
/** /**
* The following unlocks the sep and makes it available * The following unlocks the sep and makes it available
* to any other application * to any other application
* First, null out crypto entries in sep before relesing it * First, null out crypto entries in sep before releasing it
*/ */
ta_ctx->sep_used->current_hash_req = NULL; ta_ctx->sep_used->current_hash_req = NULL;
ta_ctx->sep_used->current_cypher_req = NULL; ta_ctx->sep_used->current_cypher_req = NULL;
@ -1001,7 +1001,7 @@ static void sep_clear_out(struct this_task_ctx *ta_ctx)
ta_ctx->call_status.status = 0; ta_ctx->call_status.status = 0;
/* Remove anything confidentail */ /* Remove anything confidential */
memset(ta_ctx->sep_used->shared_addr, 0, memset(ta_ctx->sep_used->shared_addr, 0,
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES); SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
@ -1207,7 +1207,7 @@ static int sep_crypto_block_data(struct ablkcipher_request *req)
req->nbytes, ta_ctx->walk.blocksize, &new_sg, 1); req->nbytes, ta_ctx->walk.blocksize, &new_sg, 1);
if (int_error < 0) { if (int_error < 0) {
dev_warn(&ta_ctx->sep_used->pdev->dev, "oddball page eerror\n"); dev_warn(&ta_ctx->sep_used->pdev->dev, "oddball page error\n");
return -ENOMEM; return -ENOMEM;
} else if (int_error == 1) { } else if (int_error == 1) {
ta_ctx->src_sg = new_sg; ta_ctx->src_sg = new_sg;
@ -1870,7 +1870,7 @@ static u32 hash_update_post_op(struct sep_device *sep)
sizeof(struct sep_hash_private_context)); sizeof(struct sep_hash_private_context));
/** /**
* Following is only for finup; if we just completd the * Following is only for finup; if we just completed the
* data portion of finup, we now need to kick off the * data portion of finup, we now need to kick off the
* finish portion of finup. * finish portion of finup.
*/ */
@ -2011,7 +2011,7 @@ static u32 hash_digest_post_op(struct sep_device *sep)
} }
/** /**
* The sep_finish function is the function that is schedule (via tasket) * The sep_finish function is the function that is scheduled (via tasklet)
* by the interrupt service routine when the SEP sends and interrupt * by the interrupt service routine when the SEP sends and interrupt
* This is only called by the interrupt handler as a tasklet. * This is only called by the interrupt handler as a tasklet.
*/ */
@ -2249,7 +2249,7 @@ static void sep_hash_update(void *data)
head_len = (block_size - int_ctx->prev_update_bytes) % block_size; head_len = (block_size - int_ctx->prev_update_bytes) % block_size;
tail_len = (req->nbytes - head_len) % block_size; tail_len = (req->nbytes - head_len) % block_size;
/* Make sure all pages are even block */ /* Make sure all pages are an even block */
int_error = sep_oddball_pages(ta_ctx->sep_used, req->src, int_error = sep_oddball_pages(ta_ctx->sep_used, req->src,
req->nbytes, req->nbytes,
block_size, &new_sg, 1); block_size, &new_sg, 1);
@ -2482,7 +2482,7 @@ static void sep_hash_digest(void *data)
dev_dbg(&ta_ctx->sep_used->pdev->dev, "block_size is %x\n", block_size); dev_dbg(&ta_ctx->sep_used->pdev->dev, "block_size is %x\n", block_size);
dev_dbg(&ta_ctx->sep_used->pdev->dev, "tail len is %x\n", tail_len); dev_dbg(&ta_ctx->sep_used->pdev->dev, "tail len is %x\n", tail_len);
/* Make sure all pages are even block */ /* Make sure all pages are an even block */
int_error = sep_oddball_pages(ta_ctx->sep_used, req->src, int_error = sep_oddball_pages(ta_ctx->sep_used, req->src,
req->nbytes, req->nbytes,
block_size, &new_sg, 1); block_size, &new_sg, 1);

8
drivers/staging/sep/sep_driver_api.h
View File

@ -91,7 +91,7 @@ struct sep_dcblock {
}; };
/* /*
command structure for building dcb block (currently for ext app only command structure for building dcb block (currently for ext app only)
*/ */
struct build_dcb_struct { struct build_dcb_struct {
/* address value of the data in */ /* address value of the data in */
@ -234,7 +234,7 @@ struct sep_dma_context {
u32 dmatables_len; u32 dmatables_len;
/* size of input data */ /* size of input data */
u32 input_data_len; u32 input_data_len;
/* secure dma use (for imr memory restriced area in output */ /* secure dma use (for imr memory restricted area in output) */
bool secure_dma; bool secure_dma;
struct sep_dma_resource dma_res_arr[SEP_MAX_NUM_SYNC_DMA_OPS]; struct sep_dma_resource dma_res_arr[SEP_MAX_NUM_SYNC_DMA_OPS];
/* Scatter gather for kernel crypto */ /* Scatter gather for kernel crypto */
@ -347,10 +347,10 @@ int sep_prepare_input_output_dma_table_in_dcb(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: pointer to struct sep_device
* @dma_ctx: dma context * @dma_ctx: dma context
* *
* Handles the request to free DMA table for synchronic actions * Handles the request to free DMA table for synchronic actions
*/ */
int sep_free_dma_table_data_handler(struct sep_device *sep, int sep_free_dma_table_data_handler(struct sep_device *sep,
struct sep_dma_context **dma_ctx); struct sep_dma_context **dma_ctx);

4
drivers/staging/sep/sep_driver_config.h
View File

@ -43,7 +43,7 @@
#define SEP_DRIVER_POLLING_MODE 0 #define SEP_DRIVER_POLLING_MODE 0
/* flag which defines if the shared area address should be /* flag which defines if the shared area address should be
reconfiged (send to SEP anew) during init of the driver */ reconfigured (send to SEP anew) during init of the driver */
#define SEP_DRIVER_RECONFIG_MESSAGE_AREA 0 #define SEP_DRIVER_RECONFIG_MESSAGE_AREA 0
/* the mode for running on the ARM1172 Evaluation platform (flag is 1) */ /* the mode for running on the ARM1172 Evaluation platform (flag is 1) */
@ -166,7 +166,7 @@ held by the process (struct file) */
(SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES + \ (SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES + \
SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES) SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES)
/* synhronic dma tables area offset */ /* synchronic dma tables area offset */
#define SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES \ #define SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES \
(SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + \ (SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + \
SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES) SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES)

36
drivers/staging/sep/sep_main.c
View File

@ -94,7 +94,7 @@
#endif #endif
/** /**
* Currenlty, there is only one SEP device per platform; * Currently, there is only one SEP device per platform;
* In event platforms in the future have more than one SEP * In event platforms in the future have more than one SEP
* device, this will be a linked list * device, this will be a linked list
*/ */
@ -106,7 +106,7 @@ struct sep_device *sep_dev;
* @sep: SEP device * @sep: SEP device
* @sep_queue_info: pointer to status queue * @sep_queue_info: pointer to status queue
* *
* This function will removes information about transaction from the queue. * This function will remove information about transaction from the queue.
*/ */
void sep_queue_status_remove(struct sep_device *sep, void sep_queue_status_remove(struct sep_device *sep,
struct sep_queue_info **queue_elem) struct sep_queue_info **queue_elem)
@ -294,7 +294,7 @@ int sep_wait_transaction(struct sep_device *sep)
end_function_setpid: end_function_setpid:
/* /*
* 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 perform 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
@ -447,10 +447,10 @@ static int sep_open(struct inode *inode, struct file *filp)
/** /**
* 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: pointer to struct sep_device
* @dma_ctx: dma context * @dma_ctx: dma context
* *
* Handles the request to free DMA table for synchronic actions * Handles the request to free DMA table for synchronic actions
*/ */
int sep_free_dma_table_data_handler(struct sep_device *sep, int sep_free_dma_table_data_handler(struct sep_device *sep,
struct sep_dma_context **dma_ctx) struct sep_dma_context **dma_ctx)
@ -540,7 +540,7 @@ int sep_free_dma_table_data_handler(struct sep_device *sep,
* don't have a page array; the page array is generated * don't have a page array; the page array is generated
* only in the lock_user_pages, which is not called * only in the lock_user_pages, which is not called
* for kernel crypto, which is what the sg (scatter gather * for kernel crypto, which is what the sg (scatter gather
* is used for exclusively * is used for exclusively)
*/ */
if (dma->src_sg) { if (dma->src_sg) {
dma_unmap_sg(&sep->pdev->dev, dma->src_sg, dma_unmap_sg(&sep->pdev->dev, dma->src_sg,
@ -1227,7 +1227,7 @@ static int sep_lock_user_pages(struct sep_device *sep,
/* Map array */ /* Map array */
struct sep_dma_map *map_array; struct sep_dma_map *map_array;
/* 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;
@ -1431,7 +1431,7 @@ static int sep_lli_table_secure_dma(struct sep_device *sep,
/* Array of lli */ /* Array of lli */
struct sep_lli_entry *lli_array; struct sep_lli_entry *lli_array;
/* 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;
@ -1602,7 +1602,7 @@ end_function:
* @num_table_entries_ptr: pointer to number of tables * @num_table_entries_ptr: pointer to number of tables
* @table_data_size: total data size * @table_data_size: total data size
* *
* Builds ant lli table from the lli_array according to * Builds an lli table from the lli_array according to
* the given size of data * the given size of data
*/ */
static void sep_build_lli_table(struct sep_device *sep, static void sep_build_lli_table(struct sep_device *sep,
@ -1701,7 +1701,7 @@ static void sep_build_lli_table(struct sep_device *sep,
* @virt_address: virtual address to convert * @virt_address: virtual address to convert
* *
* This functions returns the physical address inside shared area according * This functions returns the physical address inside shared area according
* to the virtual address. It can be either on the externa RAM device * to the virtual address. It can be either on the external RAM device
* (ioremapped), or on the system RAM * (ioremapped), or on the system RAM
* This implementation is for the external RAM * This implementation is for the external RAM
*/ */
@ -1725,7 +1725,7 @@ static dma_addr_t sep_shared_area_virt_to_bus(struct sep_device *sep,
* *
* This functions returns the virtual address inside shared area * This functions returns the virtual address inside shared area
* according to the physical address. It can be either on the * according to the physical address. It can be either on the
* externa RAM device (ioremapped), or on the system RAM * external RAM device (ioremapped), or on the system RAM
* This implementation is for the external RAM * This implementation is for the external RAM
*/ */
static void *sep_shared_area_bus_to_virt(struct sep_device *sep, static void *sep_shared_area_bus_to_virt(struct sep_device *sep,
@ -1891,9 +1891,9 @@ static void sep_prepare_empty_lli_table(struct sep_device *sep,
* @lli_table_ptr: * @lli_table_ptr:
* @num_entries_ptr: * @num_entries_ptr:
* @table_data_size_ptr: * @table_data_size_ptr:
* @is_kva: set for kernel data (kernel cryptio call) * @is_kva: set for kernel data (kernel crypt io call)
* *
* This function prepares only input DMA table for synhronic symmetric * This function prepares only input DMA table for synchronic 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
@ -2174,9 +2174,9 @@ static int sep_construct_dma_tables_from_lli(
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 entries 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 entries in the output table */
u32 num_entries_out_table = 0; u32 num_entries_out_table = 0;
if (!dma_ctx) { if (!dma_ctx) {
@ -2401,7 +2401,7 @@ static int sep_construct_dma_tables_from_lli(
* @table_data_size_ptr: * @table_data_size_ptr:
* @is_kva: set for kernel data; used only for kernel crypto module * @is_kva: set for kernel data; used only for kernel crypto module
* *
* This function builds input and output DMA tables for synhronic * This function builds input and output DMA tables for synchronic
* 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
@ -2556,7 +2556,7 @@ static int sep_prepare_input_output_dma_table(struct sep_device *sep,
"[PID%d] SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is (hex) %x\n", "[PID%d] SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is (hex) %x\n",
current->pid, SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP); current->pid, 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 */
dev_dbg(&sep->pdev->dev, "[PID%d] calling create table from lli\n", dev_dbg(&sep->pdev->dev, "[PID%d] calling create table from lli\n",
current->pid); current->pid);
error = sep_construct_dma_tables_from_lli( error = sep_construct_dma_tables_from_lli(
@ -3663,7 +3663,7 @@ static ssize_t sep_read(struct file *filp,
goto end_function; goto end_function;
} }
/* Checks that user has called necessarry apis */ /* Checks that user has called necessary apis */
if (0 == test_bit(SEP_FASTCALL_WRITE_DONE_OFFSET, if (0 == test_bit(SEP_FASTCALL_WRITE_DONE_OFFSET,
&call_status->status)) { &call_status->status)) {
dev_warn(&sep->pdev->dev, dev_warn(&sep->pdev->dev,