* @size: size of parameter to copy (in bytes)
* @max_size: size to move up offset; SEP mesg is in word sizes
* @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
*/
static void sep_write_msg(struct this_task_ctx *ta_ctx, void *in_addr,
* @size: size of parameter to copy (in bytes)
* @max_size: size to move up offset; SEP mesg is in word sizes
* @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
*/
static void sep_read_msg(struct this_task_ctx *ta_ctx, void *in_addr,
/**
* The following unlocks the sep and makes it available
* 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_cypher_req = NULL;
ta_ctx->call_status.status = 0;
- /* Remove anything confidentail */
+ /* Remove anything confidential */
memset(ta_ctx->sep_used->shared_addr, 0,
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
req->nbytes, ta_ctx->walk.blocksize, &new_sg, 1);
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;
} else if (int_error == 1) {
ta_ctx->src_sg = new_sg;
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
* finish portion of finup.
*/
}
/**
- * 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
* This is only called by the interrupt handler as a tasklet.
*/
head_len = (block_size - int_ctx->prev_update_bytes) % 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,
req->nbytes,
block_size, &new_sg, 1);
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);
- /* 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,
req->nbytes,
block_size, &new_sg, 1);
#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
* device, this will be a linked list
*/
* @sep: SEP device
* @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,
struct sep_queue_info **queue_elem)
end_function_setpid:
/*
* 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,
* no other process who has the SEP device open can perform
* any transactions. This method allows more than one process
/**
* 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
*
- * 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,
struct sep_dma_context **dma_ctx)
* don't have a page array; the page array is generated
* only in the lock_user_pages, which is not called
* for kernel crypto, which is what the sg (scatter gather
- * is used for exclusively
+ * is used for exclusively)
*/
if (dma->src_sg) {
dma_unmap_sg(&sep->pdev->dev, dma->src_sg,
/* 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;
start_page = app_virt_addr >> PAGE_SHIFT;
num_pages = end_page - start_page + 1;
/* Array of lli */
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;
start_page = app_virt_addr >> PAGE_SHIFT;
num_pages = end_page - start_page + 1;
* @num_table_entries_ptr: pointer to number of tables
* @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
*/
static void sep_build_lli_table(struct sep_device *sep,
* @virt_address: virtual address to convert
*
* 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
* This implementation is for the external RAM
*/
*
* This functions returns the virtual address inside shared area
* 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
*/
static void *sep_shared_area_bus_to_virt(struct sep_device *sep,
* @lli_table_ptr:
* @num_entries_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)
* Note that all bus addresses that are passed to the SEP
* are in 32 bit format; the SEP is a 32 bit device
u32 last_table_flag = 0;
/* The data size that should be in table */
u32 table_data_size = 0;
- /* Number of etnries in the input table */
+ /* Number of entries in the input table */
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;
if (!dma_ctx) {
* @table_data_size_ptr:
* @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
* is of the modular block size
* Note that all bus addresses that are passed to the SEP
"[PID%d] SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is (hex) %x\n",
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",
current->pid);
error = sep_construct_dma_tables_from_lli(
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,
&call_status->status)) {
dev_warn(&sep->pdev->dev,
projects / deliverable / linux.git / commitdiff
