/*
*
* sep_crypto.c - Crypto interface structures
*
* Copyright(c) 2009-2011 Intel Corporation. All rights reserved.
* Contributions(c) 2009-2010 Discretix. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; version 2 of the License.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* CONTACTS:
*
* Mark Allyn mark.a.allyn@intel.com
* Jayant Mangalampalli jayant.mangalampalli@intel.com
*
* CHANGES:
*
* 2009.06.26 Initial publish
* 2010.09.14 Upgrade to Medfield
* 2011.02.22 Enable Kernel Crypto
*
*/
/* #define DEBUG */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/kdev_t.h>
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/poll.h>
#include <linux/wait.h>
#include <linux/pci.h>
#include <linux/pm_runtime.h>
#include <linux/err.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/clk.h>
#include <linux/irq.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/list.h>
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/jiffies.h>
#include <linux/workqueue.h>
#include <linux/crypto.h>
#include <crypto/internal/hash.h>
#include <crypto/scatterwalk.h>
#include <crypto/sha.h>
#include <crypto/md5.h>
#include <crypto/aes.h>
#include <crypto/des.h>
#include <crypto/hash.h>
#include "sep_driver_hw_defs.h"
#include "sep_driver_config.h"
#include "sep_driver_api.h"
#include "sep_dev.h"
#include "sep_crypto.h"
#if defined(CONFIG_CRYPTO) || defined(CONFIG_CRYPTO_MODULE)
/* Globals for queuing */
static spinlock_t queue_lock;
static struct crypto_queue sep_queue;
/* Declare of dequeuer */
static void sep_dequeuer(void *data);
/* TESTING */
/**
* sep_do_callback
* @work: pointer to work_struct
* This is what is called by the queue; it is generic so that it
* can be used by any type of operation as each different callback
* function can use the data parameter in its own way
*/
static void sep_do_callback(struct work_struct *work)
{
struct sep_work_struct *sep_work = container_of(work,
struct sep_work_struct, work);
if (sep_work != NULL) {
(sep_work->callback)(sep_work->data);
kfree(sep_work);
} else {
pr_debug("sep crypto: do callback - NULL container\n");
}
}
/**
* sep_submit_work
* @work_queue: pointer to struct_workqueue
* @funct: pointer to function to execute
* @data: pointer to data; function will know
* how to use it
* This is a generic API to submit something to
* the queue. The callback function will depend
* on what operation is to be done
*/
static int sep_submit_work(struct workqueue_struct *work_queue,
void(*funct)(void *),
void *data)
{
struct sep_work_struct *sep_work;
int result;
sep_work = kmalloc(sizeof(struct sep_work_struct), GFP_ATOMIC);
if (sep_work == NULL) {
pr_debug("sep crypto: cant allocate work structure\n");
return -ENOMEM;
}
sep_work->callback = funct;
sep_work->data = data;
INIT_WORK(&sep_work->work, sep_do_callback);
result = queue_work(work_queue, &sep_work->work);
if (!result) {
pr_debug("sep_crypto: queue_work failed\n");
return -EINVAL;
}
return 0;
}
/**
* sep_alloc_sg_buf -
* @sep: pointer to struct sep_device
* @size: total size of area
* @block_size: minimum size of chunks
* each page is minimum or modulo this size
* @returns: pointer to struct scatterlist for new
* buffer
**/
static struct scatterlist *sep_alloc_sg_buf(
struct sep_device *sep,
size_t size,
size_t block_size)
{
u32 nbr_pages;
u32 ct1;
void *buf;
size_t current_size;
size_t real_page_size;
struct scatterlist *sg, *sg_temp;
if (size == 0)
return NULL;
dev_dbg(&sep->pdev->dev, "sep alloc sg buf\n");
current_size = 0;
nbr_pages = 0;
real_page_size = PAGE_SIZE - (PAGE_SIZE % block_size);
/**
* The size of each page must be modulo of the operation
* block size; increment by the modified page size until
* the total size is reached, then you have the number of
* pages
*/
while (current_size < size) {
current_size += real_page_size;
nbr_pages += 1;
}
sg = kmalloc_array(nbr_pages, sizeof(struct scatterlist), GFP_ATOMIC);
if (!sg)
return NULL;
sg_init_table(sg, nbr_pages);
current_size = 0;
sg_temp = sg;
for (ct1 = 0; ct1 < nbr_pages; ct1 += 1) {
buf = (void *)get_zeroed_page(GFP_ATOMIC);
if (!buf) {
dev_warn(&sep->pdev->dev,
"Cannot allocate page for new buffer\n");
kfree(sg);
return NULL;
}
sg_set_buf(sg_temp, buf, real_page_size);
if ((size - current_size) > real_page_size) {
sg_temp->length = real_page_size;
current_size += real_page_size;
} else {
sg_temp->length = (size - current_size);
current_size = size;
}
sg_temp = sg_next(sg);
}
return sg;
}
/**
* sep_free_sg_buf -
* @sg: pointer to struct scatterlist; points to area to free
*/
static void sep_free_sg_buf(struct scatterlist *sg)
{
struct scatterlist *sg_temp = sg;
while (sg_temp) {
free_page((unsigned long)sg_virt(sg_temp));
sg_temp = sg_next(sg_temp);
}
kfree(sg);
}
/**
* sep_copy_sg -
* @sep: pointer to struct sep_device
* @sg_src: pointer to struct scatterlist for source
* @sg_dst: pointer to struct scatterlist for destination
* @size: size (in bytes) of data to copy
*
* Copy data from one scatterlist to another; both must
* be the same size
*/
static void sep_copy_sg(
struct sep_device *sep,
struct scatterlist *sg_src,
struct scatterlist *sg_dst,
size_t size)
{
u32 seg_size;
u32 in_offset, out_offset;
u32 count = 0;
struct scatterlist *sg_src_tmp = sg_src;
struct scatterlist *sg_dst_tmp = sg_dst;
in_offset = 0;
out_offset = 0;
dev_dbg(&sep->pdev->dev, "sep copy sg\n");
if ((sg_src == NULL) || (sg_dst == NULL) || (size == 0))
return;
dev_dbg(&sep->pdev->dev, "sep copy sg not null\n");
while (count < size) {
if ((sg_src_tmp->length - in_offset) >
(sg_dst_tmp->length - out_offset))
seg_size = sg_dst_tmp->length - out_offset;
else
seg_size = sg_src_tmp->length - in_offset;
if (seg_size > (size - count))
seg_size = (size = count);
memcpy(sg_virt(sg_dst_tmp) + out_offset,
sg_virt(sg_src_tmp) + in_offset,
seg_size);
in_offset += seg_size;
out_offset += seg_size;
count += seg_size;
if (in_offset >= sg_src_tmp->length) {
sg_src_tmp = sg_next(sg_src_tmp);
in_offset = 0;
}
if (out_offset >= sg_dst_tmp->length) {
sg_dst_tmp = sg_next(sg_dst_tmp);
out_offset = 0;
}
}
}
/**
* sep_oddball_pages -
* @sep: pointer to struct sep_device
* @sg: pointer to struct scatterlist - buffer to check
* @size: total data size
* @blocksize: minimum block size; must be multiples of this size
* @to_copy: 1 means do copy, 0 means do not copy
* @new_sg: pointer to location to put pointer to new sg area
* @returns: 1 if new scatterlist is needed; 0 if not needed;
* error value if operation failed
*
* The SEP device requires all pages to be multiples of the
* minimum block size appropriate for the operation
* This function check all pages; if any are oddball sizes
* (not multiple of block sizes), it creates a new scatterlist.
* If the to_copy parameter is set to 1, then a scatter list
* copy is performed. The pointer to the new scatterlist is
* put into the address supplied by the new_sg parameter; if
* no new scatterlist is needed, then a NULL is put into
* the location at new_sg.
*
*/
static int sep_oddball_pages(
struct sep_device *sep,
struct scatterlist *sg,
size_t data_size,
u32 block_size,
struct scatterlist **new_sg,
u32 do_copy)
{
struct scatterlist *sg_temp;
u32 flag;
u32 nbr_pages, page_count;
dev_dbg(&sep->pdev->dev, "sep oddball\n");
if ((sg == NULL) || (data_size == 0) || (data_size < block_size))
return 0;
dev_dbg(&sep->pdev->dev, "sep oddball not null\n");
flag = 0;
nbr_pages = 0;
page_count = 0;
sg_temp = sg;
while (sg_temp) {
nbr_pages += 1;
sg_temp = sg_next(sg_temp);
}
sg_temp = sg;
while ((sg_temp) && (flag == 0)) {
page_count += 1;
if (sg_temp->length % block_size)
flag = 1;
else
sg_temp = sg_next(sg_temp);
}
/* Do not process if last (or only) page is oddball */
if (nbr_pages == page_count)
flag = 0;
if (flag) {
dev_dbg(&sep->pdev->dev, "sep oddball processing\n");
*new_sg = sep_alloc_sg_buf(sep, data_size, block_size);
if (*new_sg == NULL) {
dev_warn(&sep->pdev->dev, "cannot allocate new sg\n");
return -ENOMEM;
}
if (do_copy)
sep_copy_sg(sep, sg, *new_sg, data_size);
return 1;
} else {
return 0;
}
}
/**
* sep_copy_offset_sg -
* @sep: pointer to struct sep_device;
* @sg: pointer to struct scatterlist
* @offset: offset into scatterlist memory
* @dst: place to put data
* @len: length of data
* @returns: number of bytes copies
*
* This copies data from scatterlist buffer
* offset from beginning - it is needed for
* handling tail data in hash
*/
static size_t sep_copy_offset_sg(
struct sep_device *sep,
struct scatterlist *sg,
u32 offset,
void *dst,
u32 len)
{
size_t page_start;
size_t page_end;
size_t offset_within_page;
size_t length_within_page;
size_t length_remaining;
size_t current_offset;
/* Find which page is beginning of segment */
page_start = 0;
page_end = sg->length;
while ((sg) && (offset > page_end)) {
page_start += sg->length;
sg = sg_next(sg);
if (sg)
page_end += sg->length;
}
if (sg == NULL)
return -ENOMEM;
offset_within_page = offset - page_start;
if ((sg->length - offset_within_page) >= len) {
/* All within this page */
memcpy(dst, sg_virt(sg) + offset_within_page, len);
return len;
} else {
/* Scattered multiple pages */
current_offset = 0;
length_remaining = len;
while ((sg) && (current_offset < len)) {
length_within_page = sg->length - offset_within_page;
if (length_within_page >= length_remaining) {
memcpy(dst+current_offset,
sg_virt(sg) + offset_within_page,
length_remaining);
length_remaining = 0;
current_offset = len;
} else {
memcpy(dst+current_offset,
sg_virt(sg) + offset_within_page,
length_within_page);
length_remaining -= length_within_page;
current_offset += length_within_page;
offset_within_page = 0;
sg = sg_next(sg);
}
}
if (sg == NULL)
return -ENOMEM;
}
return len;
}
/**
* partial_overlap -
* @src_ptr: source pointer
* @dst_ptr: destination pointer
* @nbytes: number of bytes
* @returns: 0 for success; -1 for failure
* We cannot have any partial overlap. Total overlap
* where src is the same as dst is okay
*/
static int partial_overlap(void *src_ptr, void *dst_ptr, u32 nbytes)
{
/* Check for partial overlap */
if (src_ptr != dst_ptr) {
if (src_ptr < dst_ptr) {
if ((src_ptr + nbytes) > dst_ptr)
return -EINVAL;
} else {
if ((dst_ptr + nbytes) > src_ptr)
return -EINVAL;
}
}
return 0;
}
/* Debug - prints only if DEBUG is defined */
static void sep_dump_ivs(struct ablkcipher_request *req, char *reason)
{
unsigned char *cptr;
struct sep_aes_internal_context *aes_internal;
struct sep_des_internal_context *des_internal;
int ct1;
struct this_task_ctx *ta_ctx;
struct crypto_ablkcipher *tfm;
struct sep_system_ctx *sctx;
ta_ctx = ablkcipher_request_ctx(req);
tfm = crypto_ablkcipher_reqtfm(req);
sctx = crypto_ablkcipher_ctx(tfm);
dev_dbg(&ta_ctx->sep_used->pdev->dev, "IV DUMP - %s\n", reason);
if ((ta_ctx->current_request == DES_CBC) &&
(ta_ctx->des_opmode == SEP_DES_CBC)) {
des_internal = (struct sep_des_internal_context *)
sctx->des_private_ctx.ctx_buf;
/* print vendor */
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"sep - vendor iv for DES\n");
cptr = (unsigned char *)des_internal->iv_context;
for (ct1 = 0; ct1 < crypto_ablkcipher_ivsize(tfm); ct1 += 1)
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"%02x\n", *(cptr + ct1));
/* print walk */
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"sep - walk from kernel crypto iv for DES\n");
cptr = (unsigned char *)ta_ctx->walk.iv;
for (ct1 = 0; ct1 < crypto_ablkcipher_ivsize(tfm); ct1 += 1)
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"%02x\n", *(cptr + ct1));
} else if ((ta_ctx->current_request == AES_CBC) &&
(ta_ctx->aes_opmode == SEP_AES_CBC)) {
aes_internal = (struct sep_aes_internal_context *)
sctx->aes_private_ctx.cbuff;
/* print vendor */
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"sep - vendor iv for AES\n");
cptr = (unsigned char *)aes_internal->aes_ctx_iv;
for (ct1 = 0; ct1 < crypto_ablkcipher_ivsize(tfm); ct1 += 1)
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"%02x\n", *(cptr + ct1));
/* print walk */
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"sep - walk from kernel crypto iv for AES\n");
cptr = (unsigned char *)ta_ctx->walk.iv;
for (ct1 = 0; ct1 < crypto_ablkcipher_ivsize(tfm); ct1 += 1)
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"%02x\n", *(cptr + ct1));
}
}
/**
* RFC2451: Weak key check
* Returns: 1 (weak), 0 (not weak)
*/
static int sep_weak_key(const u8 *key, unsigned int keylen)
{
static const u8 parity[] = {
8, 1, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 2, 8,
0, 8, 8, 0, 8, 0, 0, 8, 8,
0, 0, 8, 0, 8, 8, 3,
0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
8, 0, 0, 8, 0, 8, 8, 0, 0,
8, 8, 0, 8, 0, 0, 8,
0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
8, 0, 0, 8, 0, 8, 8, 0, 0,
8, 8, 0, 8, 0, 0, 8,
8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
0, 8, 8, 0, 8, 0, 0, 8, 8,
0, 0, 8, 0, 8, 8, 0,
0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
8, 0, 0, 8, 0, 8, 8, 0, 0,
8, 8, 0, 8, 0, 0, 8,
8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
0, 8, 8, 0, 8, 0, 0, 8, 8,
0, 0, 8, 0, 8, 8, 0,
8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
0, 8, 8, 0, 8, 0, 0, 8, 8,
0, 0, 8, 0, 8, 8, 0,
4, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
8, 5, 0, 8, 0, 8, 8, 0, 0,
8, 8, 0, 8, 0, 6, 8,
};
u32 n, w;
n = parity[key[0]]; n <<= 4;
n |= parity[key[1]]; n <<= 4;
n |= parity[key[2]]; n <<= 4;
n |= parity[key[3]]; n <<= 4;
n |= parity[key[4]]; n <<= 4;
n |= parity[key[5]]; n <<= 4;
n |= parity[key[6]]; n <<= 4;
n |= parity[key[7]];
w = 0x88888888L;
/* 1 in 10^10 keys passes this test */
if (!((n - (w >> 3)) & w)) {
if (n < 0x41415151) {
if (n < 0x31312121) {
if (n < 0x14141515) {
/* 01 01 01 01 01 01 01 01 */
if (n == 0x11111111)
goto weak;
/* 01 1F 01 1F 01 0E 01 0E */
if (n == 0x13131212)
goto weak;
} else {
/* 01 E0 01 E0 01 F1 01 F1 */
if (n == 0x14141515)
goto weak;
/* 01 FE 01 FE 01 FE 01 FE */
if (n == 0x16161616)
goto weak;
}
} else {
if (n < 0x34342525) {
/* 1F 01 1F 01 0E 01 0E 01 */
if (n == 0x31312121)
goto weak;
/* 1F 1F 1F 1F 0E 0E 0E 0E (?) */
if (n == 0x33332222)
goto weak;
} else {
/* 1F E0 1F E0 0E F1 0E F1 */
if (n == 0x34342525)
goto weak;
/* 1F FE 1F FE 0E FE 0E FE */
if (n == 0x36362626)
goto weak;
}
}
} else {
if (n < 0x61616161) {
if (n < 0x44445555) {
/* E0 01 E0 01 F1 01 F1 01 */
if (n == 0x41415151)
goto weak;
/* E0 1F E0 1F F1 0E F1 0E */
if (n == 0x43435252)
goto weak;
} else {
/* E0 E0 E0 E0 F1 F1 F1 F1 (?) */
if (n == 0x44445555)
goto weak;
/* E0 FE E0 FE F1 FE F1 FE */
if (n == 0x46465656)
goto weak;
}
} else {
if (n < 0x64646565) {
/* FE 01 FE 01 FE 01 FE 01 */
if (n == 0x61616161)
goto weak;
/* FE 1F FE 1F FE 0E FE 0E */
if (n == 0x63636262)
goto weak;
} else {
/* FE E0 FE E0 FE F1 FE F1 */
if (n == 0x64646565)
goto weak;
/* FE FE FE FE FE FE FE FE */
if (n == 0x66666666)
goto weak;
}
}
}
}
return 0;
weak:
return 1;
}
/**
* sep_sg_nents
*/
static u32 sep_sg_nents(struct scatterlist *sg)
{
u32 ct1 = 0;
while (sg) {
ct1 += 1;
sg = sg_next(sg);
}
return ct1;
}
/**
* sep_start_msg -
* @ta_ctx: pointer to struct this_task_ctx
* @returns: offset to place for the next word in the message
* Set up pointer in message pool for new message
*/
static u32 sep_start_msg(struct this_task_ctx *ta_ctx)
{
u32 *word_ptr;
ta_ctx->msg_len_words = 2;
ta_ctx->msgptr = ta_ctx->msg;
memset(ta_ctx->msg, 0, SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
ta_ctx->msgptr += sizeof(u32) * 2;
word_ptr = (u32 *)ta_ctx->msgptr;
*word_ptr = SEP_START_MSG_TOKEN;
return sizeof(u32) * 2;
}
/**
* sep_end_msg -
* @ta_ctx: pointer to struct this_task_ctx
* @messages_offset: current message offset
* Returns: 0 for success; <0 otherwise
* End message; set length and CRC; and
* send interrupt to the SEP
*/
static void sep_end_msg(struct this_task_ctx *ta_ctx, u32 msg_offset)
{
u32 *word_ptr;
/* Msg size goes into msg after token */
ta_ctx->msg_len_words = msg_offset / sizeof(u32) + 1;
word_ptr = (u32 *)ta_ctx->msgptr;
word_ptr += 1;
*word_ptr = ta_ctx->msg_len_words;
/* CRC (currently 0) goes at end of msg */
word_ptr = (u32 *)(ta_ctx->msgptr + msg_offset);
*word_ptr = 0;
}
/**
* sep_start_inbound_msg -
* @ta_ctx: pointer to struct this_task_ctx
* @msg_offset: offset to place for the next word in the message
* @returns: 0 for success; error value for failure
* Set up pointer in message pool for inbound message
*/
static u32 sep_start_inbound_msg(struct this_task_ctx *ta_ctx, u32 *msg_offset)
{
u32 *word_ptr;
u32 token;
u32 error = SEP_OK;
*msg_offset = sizeof(u32) * 2;
word_ptr = (u32 *)ta_ctx->msgptr;
token = *word_ptr;
ta_ctx->msg_len_words = *(word_ptr + 1);
if (token != SEP_START_MSG_TOKEN) {
error = SEP_INVALID_START;
goto end_function;
}
end_function:
return error;
}
/**
* sep_write_msg -
* @ta_ctx: pointer to struct this_task_ctx
* @in_addr: pointer to start of parameter
* @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 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,
u32 size, u32 max_size, u32 *msg_offset, u32 byte_array)
{
u32 *word_ptr;
void *void_ptr;
void_ptr = ta_ctx->msgptr + *msg_offset;
word_ptr = (u32 *)void_ptr;
memcpy(void_ptr, in_addr, size);
*msg_offset += max_size;
/* Do we need to manipulate endian? */
if (byte_array) {
u32 i;
for (i = 0; i < ((size + 3) / 4); i += 1)
*(word_ptr + i) = CHG_ENDIAN(*(word_ptr + i));
}
}
/**
* sep_make_header
* @ta_ctx: pointer to struct this_task_ctx
* @msg_offset: pointer to current offset (is updated)
* @op_code: op code to put into message
* Puts op code into message and updates offset
*/
static void sep_make_header(struct this_task_ctx *ta_ctx, u32 *msg_offset,
u32 op_code)
{
u32 *word_ptr;
*msg_offset = sep_start_msg(ta_ctx);
word_ptr = (u32 *)(ta_ctx->msgptr + *msg_offset);
*word_ptr = op_code;
*msg_offset += sizeof(u32);
}
/**
* sep_read_msg -
* @ta_ctx: pointer to struct this_task_ctx
* @in_addr: pointer to start of parameter
* @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 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,
u32 size, u32 max_size, u32 *msg_offset, u32 byte_array)
{
u32 *word_ptr;
void *void_ptr;
void_ptr = ta_ctx->msgptr + *msg_offset;
word_ptr = (u32 *)void_ptr;
/* Do we need to manipulate endian? */
if (byte_array) {
u32 i;
for (i = 0; i < ((size + 3) / 4); i += 1)
*(word_ptr + i) = CHG_ENDIAN(*(word_ptr + i));
}
memcpy(in_addr, void_ptr, size);
*msg_offset += max_size;
}
/**
* sep_verify_op -
* @ta_ctx: pointer to struct this_task_ctx
* @op_code: expected op_code
* @msg_offset: pointer to current offset (is updated)
* @returns: 0 for success; error for failure
*/
static u32 sep_verify_op(struct this_task_ctx *ta_ctx, u32 op_code,
u32 *msg_offset)
{
u32 error;
u32 in_ary[2];
struct sep_device *sep = ta_ctx->sep_used;
dev_dbg(&sep->pdev->dev, "dumping return message\n");
error = sep_start_inbound_msg(ta_ctx, msg_offset);
if (error) {
dev_warn(&sep->pdev->dev,
"sep_start_inbound_msg error\n");
return error;
}
sep_read_msg(ta_ctx, in_ary, sizeof(u32) * 2, sizeof(u32) * 2,
msg_offset, 0);
if (in_ary[0] != op_code) {
dev_warn(&sep->pdev->dev,
"sep got back wrong opcode\n");
dev_warn(&sep->pdev->dev,
"got back %x; expected %x\n",
in_ary[0], op_code);
return SEP_WRONG_OPCODE;
}
if (in_ary[1] != SEP_OK) {
dev_warn(&sep->pdev->dev,
"sep execution error\n");
dev_warn(&sep->pdev->dev,
"got back %x; expected %x\n",
in_ary[1], SEP_OK);
return in_ary[0];
}
return 0;
}
/**
* sep_read_context -
* @ta_ctx: pointer to struct this_task_ctx
* @msg_offset: point to current place in SEP msg; is updated
* @dst: pointer to place to put the context
* @len: size of the context structure (differs for crypro/hash)
* This function reads the context from the msg area
* There is a special way the vendor needs to have the maximum
* length calculated so that the msg_offset is updated properly;
* it skips over some words in the msg area depending on the size
* of the context
*/
static void sep_read_context(struct this_task_ctx *ta_ctx, u32 *msg_offset,
void *dst, u32 len)
{
u32 max_length = ((len + 3) / sizeof(u32)) * sizeof(u32);
sep_read_msg(ta_ctx, dst, len, max_length, msg_offset, 0);
}
/**
* sep_write_context -
* @ta_ctx: pointer to struct this_task_ctx
* @msg_offset: point to current place in SEP msg; is updated
* @src: pointer to the current context
* @len: size of the context structure (differs for crypro/hash)
* This function writes the context to the msg area
* There is a special way the vendor needs to have the maximum
* length calculated so that the msg_offset is updated properly;
* it skips over some words in the msg area depending on the size
* of the context
*/
static void sep_write_context(struct this_task_ctx *ta_ctx, u32 *msg_offset,
void *src, u32 len)
{
u32 max_length = ((len + 3) / sizeof(u32)) * sizeof(u32);
sep_write_msg(ta_ctx, src, len, max_length, msg_offset, 0);
}
/**
* sep_clear_out -
* @ta_ctx: pointer to struct this_task_ctx
* Clear out crypto related values in sep device structure
* to enable device to be used by anyone; either kernel
* crypto or userspace app via middleware
*/
static void sep_clear_out(struct this_task_ctx *ta_ctx)
{
if (ta_ctx->src_sg_hold) {
sep_free_sg_buf(ta_ctx->src_sg_hold);
ta_ctx->src_sg_hold = NULL;
}
if (ta_ctx->dst_sg_hold) {
sep_free_sg_buf(ta_ctx->dst_sg_hold);
ta_ctx->dst_sg_hold = NULL;
}
ta_ctx->src_sg = NULL;
ta_ctx->dst_sg = NULL;
sep_free_dma_table_data_handler(ta_ctx->sep_used, &ta_ctx->dma_ctx);
if (ta_ctx->i_own_sep) {
/**
* The following unlocks the sep and makes it available
* to any other application
* 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->sep_used->current_request = 0;
ta_ctx->sep_used->current_hash_stage = 0;
ta_ctx->sep_used->ta_ctx = NULL;
ta_ctx->sep_used->in_kernel = 0;
ta_ctx->call_status.status = 0;
/* Remove anything confidential */
memset(ta_ctx->sep_used->shared_addr, 0,
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
sep_queue_status_remove(ta_ctx->sep_used, &ta_ctx->queue_elem);
#ifdef SEP_ENABLE_RUNTIME_PM
ta_ctx->sep_used->in_use = 0;
pm_runtime_mark_last_busy(&ta_ctx->sep_used->pdev->dev);
pm_runtime_put_autosuspend(&ta_ctx->sep_used->pdev->dev);
#endif
clear_bit(SEP_WORKING_LOCK_BIT,
&ta_ctx->sep_used->in_use_flags);
ta_ctx->sep_used->pid_doing_transaction = 0;
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"[PID%d] waking up next transaction\n",
current->pid);
clear_bit(SEP_TRANSACTION_STARTED_LOCK_BIT,
&ta_ctx->sep_used->in_use_flags);
wake_up(&ta_ctx->sep_used->event_transactions);
ta_ctx->i_own_sep = 0;
}
}
/**
* Release crypto infrastructure from EINPROGRESS and
* clear sep_dev so that SEP is available to anyone
*/
static void sep_crypto_release(struct sep_system_ctx *sctx,
struct this_task_ctx *ta_ctx, u32 error)
{
struct ahash_request *hash_req = ta_ctx->current_hash_req;
struct ablkcipher_request *cypher_req =
ta_ctx->current_cypher_req;
struct sep_device *sep = ta_ctx->sep_used;
sep_clear_out(ta_ctx);
/**
* This may not yet exist depending when we
* chose to bail out. If it does exist, set
* it to 1
*/
if (ta_ctx->are_we_done_yet != NULL)
*ta_ctx->are_we_done_yet = 1;
if (cypher_req != NULL) {
if ((sctx->key_sent == 1) ||
((error != 0) && (error != -EINPROGRESS))) {
if (cypher_req->base.complete == NULL) {
dev_dbg(&sep->pdev->dev,
"release is null for cypher!");
} else {
cypher_req->base.complete(
&cypher_req->base, error);
}
}
}
if (hash_req != NULL) {
if (hash_req->base.complete == NULL) {
dev_dbg(&sep->pdev->dev,
"release is null for hash!");
} else {
hash_req->base.complete(
&hash_req->base, error);
}
}
}
/**
* This is where we grab the sep itself and tell it to do something.
* It will sleep if the sep is currently busy
* and it will return 0 if sep is now ours; error value if there
* were problems
*/
static int sep_crypto_take_sep(struct this_task_ctx *ta_ctx)
{
struct sep_device *sep = ta_ctx->sep_used;
int result;
struct sep_msgarea_hdr *my_msg_header;
my_msg_header = (struct sep_msgarea_hdr *)ta_ctx->msg;
/* add to status queue */
ta_ctx->queue_elem = sep_queue_status_add(sep, my_msg_header->opcode,
ta_ctx->nbytes, current->pid,
current->comm, sizeof(current->comm));
if (!ta_ctx->queue_elem) {
dev_dbg(&sep->pdev->dev,
"[PID%d] updating queue status error\n", current->pid);
return -EINVAL;
}
/* get the device; this can sleep */
result = sep_wait_transaction(sep);
if (result)
return result;
if (sep_dev->power_save_setup == 1)
pm_runtime_get_sync(&sep_dev->pdev->dev);
/* Copy in the message */
memcpy(sep->shared_addr, ta_ctx->msg,
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
/* Copy in the dcb information if there is any */
if (ta_ctx->dcb_region) {
result = sep_activate_dcb_dmatables_context(sep,
&ta_ctx->dcb_region, &ta_ctx->dmatables_region,
ta_ctx->dma_ctx);
if (result)
return result;
}
/* Mark the device so we know how to finish the job in the tasklet */
if (ta_ctx->current_hash_req)
sep->current_hash_req = ta_ctx->current_hash_req;
else
sep->current_cypher_req = ta_ctx->current_cypher_req;
sep->current_request = ta_ctx->current_request;
sep->current_hash_stage = ta_ctx->current_hash_stage;
sep->ta_ctx = ta_ctx;
sep->in_kernel = 1;
ta_ctx->i_own_sep = 1;
/* need to set bit first to avoid race condition with interrupt */
set_bit(SEP_LEGACY_SENDMSG_DONE_OFFSET, &ta_ctx->call_status.status);
result = sep_send_command_handler(sep);
dev_dbg(&sep->pdev->dev, "[PID%d]: sending command to the sep\n",
current->pid);
if (!result)
dev_dbg(&sep->pdev->dev, "[PID%d]: command sent okay\n",
current->pid);
else {
dev_dbg(&sep->pdev->dev, "[PID%d]: cant send command\n",
current->pid);
clear_bit(SEP_LEGACY_SENDMSG_DONE_OFFSET,
&ta_ctx->call_status.status);
}
return result;
}
/**
* This function sets things up for a crypto data block process
* This does all preparation, but does not try to grab the
* sep
* @req: pointer to struct ablkcipher_request
* returns: 0 if all went well, non zero if error
*/
static int sep_crypto_block_data(struct ablkcipher_request *req)
{
int int_error;
u32 msg_offset;
static u32 msg[10];
void *src_ptr;
void *dst_ptr;
static char small_buf[100];
ssize_t copy_result;
int result;
struct scatterlist *new_sg;
struct this_task_ctx *ta_ctx;
struct crypto_ablkcipher *tfm;
struct sep_system_ctx *sctx;
struct sep_des_internal_context *des_internal;
struct sep_aes_internal_context *aes_internal;
ta_ctx = ablkcipher_request_ctx(req);
tfm = crypto_ablkcipher_reqtfm(req);
sctx = crypto_ablkcipher_ctx(tfm);
/* start the walk on scatterlists */
ablkcipher_walk_init(&ta_ctx->walk, req->src, req->dst, req->nbytes);
dev_dbg(&ta_ctx->sep_used->pdev->dev, "sep crypto block data size of %x\n",
req->nbytes);
int_error = ablkcipher_walk_phys(req, &ta_ctx->walk);
if (int_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev, "walk phys error %x\n",
int_error);
return -ENOMEM;
}
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"crypto block: src is %lx dst is %lx\n",
(unsigned long)req->src, (unsigned long)req->dst);
/* Make sure all pages are even block */
int_error = sep_oddball_pages(ta_ctx->sep_used, req->src,
req->nbytes, ta_ctx->walk.blocksize, &new_sg, 1);
if (int_error < 0) {
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;
ta_ctx->src_sg_hold = new_sg;
} else {
ta_ctx->src_sg = req->src;
ta_ctx->src_sg_hold = NULL;
}
int_error = sep_oddball_pages(ta_ctx->sep_used, req->dst,
req->nbytes, ta_ctx->walk.blocksize, &new_sg, 0);
if (int_error < 0) {
dev_warn(&ta_ctx->sep_used->pdev->dev, "walk phys error %x\n",
int_error);
return -ENOMEM;
} else if (int_error == 1) {
ta_ctx->dst_sg = new_sg;
ta_ctx->dst_sg_hold = new_sg;
} else {
ta_ctx->dst_sg = req->dst;
ta_ctx->dst_sg_hold = NULL;
}
/* set nbytes for queue status */
ta_ctx->nbytes = req->nbytes;
/* Key already done; this is for data */
dev_dbg(&ta_ctx->sep_used->pdev->dev, "sending data\n");
/* check for valid data and proper spacing */
src_ptr = sg_virt(ta_ctx->src_sg);
dst_ptr = sg_virt(ta_ctx->dst_sg);
if (!src_ptr || !dst_ptr ||
(ta_ctx->current_cypher_req->nbytes %
crypto_ablkcipher_blocksize(tfm))) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"cipher block size odd\n");
dev_warn(&ta_ctx->sep_used->pdev->dev,
"cipher block size is %x\n",
crypto_ablkcipher_blocksize(tfm));
dev_warn(&ta_ctx->sep_used->pdev->dev,
"cipher data size is %x\n",
ta_ctx->current_cypher_req->nbytes);
return -EINVAL;
}
if (partial_overlap(src_ptr, dst_ptr,
ta_ctx->current_cypher_req->nbytes)) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"block partial overlap\n");
return -EINVAL;
}
/* Put together the message */
sep_make_header(ta_ctx, &msg_offset, ta_ctx->block_opcode);
/* If des, and size is 1 block, put directly in msg */
if ((ta_ctx->block_opcode == SEP_DES_BLOCK_OPCODE) &&
(req->nbytes == crypto_ablkcipher_blocksize(tfm))) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"writing out one block des\n");
copy_result = sg_copy_to_buffer(
ta_ctx->src_sg, sep_sg_nents(ta_ctx->src_sg),
small_buf, crypto_ablkcipher_blocksize(tfm));
if (copy_result != crypto_ablkcipher_blocksize(tfm)) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"des block copy failed\n");
return -ENOMEM;
}
/* Put data into message */
sep_write_msg(ta_ctx, small_buf,
crypto_ablkcipher_blocksize(tfm),
crypto_ablkcipher_blocksize(tfm) * 2,
&msg_offset, 1);
/* Put size into message */
sep_write_msg(ta_ctx, &req->nbytes,
sizeof(u32), sizeof(u32), &msg_offset, 0);
} else {
/* Otherwise, fill out dma tables */
ta_ctx->dcb_input_data.app_in_address = src_ptr;
ta_ctx->dcb_input_data.data_in_size = req->nbytes;
ta_ctx->dcb_input_data.app_out_address = dst_ptr;
ta_ctx->dcb_input_data.block_size =
crypto_ablkcipher_blocksize(tfm);
ta_ctx->dcb_input_data.tail_block_size = 0;
ta_ctx->dcb_input_data.is_applet = 0;
ta_ctx->dcb_input_data.src_sg = ta_ctx->src_sg;
ta_ctx->dcb_input_data.dst_sg = ta_ctx->dst_sg;
result = sep_create_dcb_dmatables_context_kernel(
ta_ctx->sep_used,
&ta_ctx->dcb_region,
&ta_ctx->dmatables_region,
&ta_ctx->dma_ctx,
&ta_ctx->dcb_input_data,
1);
if (result) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"crypto dma table create failed\n");
return -EINVAL;
}
/* Portion of msg is nulled (no data) */
msg[0] = (u32)0;
msg[1] = (u32)0;
msg[2] = (u32)0;
msg[3] = (u32)0;
msg[4] = (u32)0;
sep_write_msg(ta_ctx, (void *)msg, sizeof(u32) * 5,
sizeof(u32) * 5, &msg_offset, 0);
}
/**
* Before we write the message, we need to overwrite the
* vendor's IV with the one from our own ablkcipher walk
* iv because this is needed for dm-crypt
*/
sep_dump_ivs(req, "sending data block to sep\n");
if ((ta_ctx->current_request == DES_CBC) &&
(ta_ctx->des_opmode == SEP_DES_CBC)) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"overwrite vendor iv on DES\n");
des_internal = (struct sep_des_internal_context *)
sctx->des_private_ctx.ctx_buf;
memcpy((void *)des_internal->iv_context,
ta_ctx->walk.iv, crypto_ablkcipher_ivsize(tfm));
} else if ((ta_ctx->current_request == AES_CBC) &&
(ta_ctx->aes_opmode == SEP_AES_CBC)) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"overwrite vendor iv on AES\n");
aes_internal = (struct sep_aes_internal_context *)
sctx->aes_private_ctx.cbuff;
memcpy((void *)aes_internal->aes_ctx_iv,
ta_ctx->walk.iv, crypto_ablkcipher_ivsize(tfm));
}
/* Write context into message */
if (ta_ctx->block_opcode == SEP_DES_BLOCK_OPCODE) {
sep_write_context(ta_ctx, &msg_offset,
&sctx->des_private_ctx,
sizeof(struct sep_des_private_context));
} else {
sep_write_context(ta_ctx, &msg_offset,
&sctx->aes_private_ctx,
sizeof(struct sep_aes_private_context));
}
/* conclude message */
sep_end_msg(ta_ctx, msg_offset);
/* Parent (caller) is now ready to tell the sep to do ahead */
return 0;
}
/**
* This function sets things up for a crypto key submit process
* This does all preparation, but does not try to grab the
* sep
* @req: pointer to struct ablkcipher_request
* returns: 0 if all went well, non zero if error
*/
static int sep_crypto_send_key(struct ablkcipher_request *req)
{
int int_error;
u32 msg_offset;
static u32 msg[10];
u32 max_length;
struct this_task_ctx *ta_ctx;
struct crypto_ablkcipher *tfm;
struct sep_system_ctx *sctx;
ta_ctx = ablkcipher_request_ctx(req);
tfm = crypto_ablkcipher_reqtfm(req);
sctx = crypto_ablkcipher_ctx(tfm);
dev_dbg(&ta_ctx->sep_used->pdev->dev, "sending key\n");
/* start the walk on scatterlists */
ablkcipher_walk_init(&ta_ctx->walk, req->src, req->dst, req->nbytes);
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"sep crypto block data size of %x\n", req->nbytes);
int_error = ablkcipher_walk_phys(req, &ta_ctx->walk);
if (int_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev, "walk phys error %x\n",
int_error);
return -ENOMEM;
}
/* check iv */
if ((ta_ctx->current_request == DES_CBC) &&
(ta_ctx->des_opmode == SEP_DES_CBC)) {
if (!ta_ctx->walk.iv) {
dev_warn(&ta_ctx->sep_used->pdev->dev, "no iv found\n");
return -EINVAL;
}
memcpy(ta_ctx->iv, ta_ctx->walk.iv, SEP_DES_IV_SIZE_BYTES);
}
if ((ta_ctx->current_request == AES_CBC) &&
(ta_ctx->aes_opmode == SEP_AES_CBC)) {
if (!ta_ctx->walk.iv) {
dev_warn(&ta_ctx->sep_used->pdev->dev, "no iv found\n");
return -EINVAL;
}
memcpy(ta_ctx->iv, ta_ctx->walk.iv, SEP_AES_IV_SIZE_BYTES);
}
/* put together message to SEP */
/* Start with op code */
sep_make_header(ta_ctx, &msg_offset, ta_ctx->init_opcode);
/* now deal with IV */
if (ta_ctx->init_opcode == SEP_DES_INIT_OPCODE) {
if (ta_ctx->des_opmode == SEP_DES_CBC) {
sep_write_msg(ta_ctx, ta_ctx->iv,
SEP_DES_IV_SIZE_BYTES, sizeof(u32) * 4,
&msg_offset, 1);
} else {
/* Skip if ECB */
msg_offset += 4 * sizeof(u32);
}
} else {
max_length = ((SEP_AES_IV_SIZE_BYTES + 3) /
sizeof(u32)) * sizeof(u32);
if (ta_ctx->aes_opmode == SEP_AES_CBC) {
sep_write_msg(ta_ctx, ta_ctx->iv,
SEP_AES_IV_SIZE_BYTES, max_length,
&msg_offset, 1);
} else {
/* Skip if ECB */
msg_offset += max_length;
}
}
/* load the key */
if (ta_ctx->init_opcode == SEP_DES_INIT_OPCODE) {
sep_write_msg(ta_ctx, (void *)&sctx->key.des.key1,
sizeof(u32) * 8, sizeof(u32) * 8,
&msg_offset, 1);
msg[0] = (u32)sctx->des_nbr_keys;
msg[1] = (u32)ta_ctx->des_encmode;
msg[2] = (u32)ta_ctx->des_opmode;
sep_write_msg(ta_ctx, (void *)msg,
sizeof(u32) * 3, sizeof(u32) * 3,
&msg_offset, 0);
} else {
sep_write_msg(ta_ctx, (void *)&sctx->key.aes,
sctx->keylen,
SEP_AES_MAX_KEY_SIZE_BYTES,
&msg_offset, 1);
msg[0] = (u32)sctx->aes_key_size;
msg[1] = (u32)ta_ctx->aes_encmode;
msg[2] = (u32)ta_ctx->aes_opmode;
msg[3] = (u32)0; /* Secret key is not used */
sep_write_msg(ta_ctx, (void *)msg,
sizeof(u32) * 4, sizeof(u32) * 4,
&msg_offset, 0);
}
/* conclude message */
sep_end_msg(ta_ctx, msg_offset);
/* Parent (caller) is now ready to tell the sep to do ahead */
return 0;
}
/* This needs to be run as a work queue as it can be put asleep */
static void sep_crypto_block(void *data)
{
unsigned long end_time;
int result;
struct ablkcipher_request *req;
struct this_task_ctx *ta_ctx;
struct crypto_ablkcipher *tfm;
struct sep_system_ctx *sctx;
int are_we_done_yet;
req = (struct ablkcipher_request *)data;
ta_ctx = ablkcipher_request_ctx(req);
tfm = crypto_ablkcipher_reqtfm(req);
sctx = crypto_ablkcipher_ctx(tfm);
ta_ctx->are_we_done_yet = &are_we_done_yet;
pr_debug("sep_crypto_block\n");
pr_debug("tfm is %p sctx is %p ta_ctx is %p\n",
tfm, sctx, ta_ctx);
pr_debug("key_sent is %d\n", sctx->key_sent);
/* do we need to send the key */
if (sctx->key_sent == 0) {
are_we_done_yet = 0;
result = sep_crypto_send_key(req); /* prep to send key */
if (result != 0) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"could not prep key %x\n", result);
sep_crypto_release(sctx, ta_ctx, result);
return;
}
result = sep_crypto_take_sep(ta_ctx);
if (result) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"sep_crypto_take_sep for key send failed\n");
sep_crypto_release(sctx, ta_ctx, result);
return;
}
/* now we sit and wait up to a fixed time for completion */
end_time = jiffies + (WAIT_TIME * HZ);
while ((time_before(jiffies, end_time)) &&
(are_we_done_yet == 0))
schedule();
/* Done waiting; still not done yet? */
if (are_we_done_yet == 0) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"Send key job never got done\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
return;
}
/* Set the key sent variable so this can be skipped later */
sctx->key_sent = 1;
}
/* Key sent (or maybe not if we did not have to), now send block */
are_we_done_yet = 0;
result = sep_crypto_block_data(req);
if (result != 0) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"could prep not send block %x\n", result);
sep_crypto_release(sctx, ta_ctx, result);
return;
}
result = sep_crypto_take_sep(ta_ctx);
if (result) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"sep_crypto_take_sep for block send failed\n");
sep_crypto_release(sctx, ta_ctx, result);
return;
}
/* now we sit and wait up to a fixed time for completion */
end_time = jiffies + (WAIT_TIME * HZ);
while ((time_before(jiffies, end_time)) && (are_we_done_yet == 0))
schedule();
/* Done waiting; still not done yet? */
if (are_we_done_yet == 0) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"Send block job never got done\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
return;
}
/* That's it; entire thing done, get out of queue */
pr_debug("crypto_block leaving\n");
pr_debug("tfm is %p sctx is %p ta_ctx is %p\n", tfm, sctx, ta_ctx);
}
/**
* Post operation (after interrupt) for crypto block
*/
static u32 crypto_post_op(struct sep_device *sep)
{
/* HERE */
u32 u32_error;
u32 msg_offset;
ssize_t copy_result;
static char small_buf[100];
struct ablkcipher_request *req;
struct this_task_ctx *ta_ctx;
struct sep_system_ctx *sctx;
struct crypto_ablkcipher *tfm;
struct sep_des_internal_context *des_internal;
struct sep_aes_internal_context *aes_internal;
if (!sep->current_cypher_req)
return -EINVAL;
/* hold req since we need to submit work after clearing sep */
req = sep->current_cypher_req;
ta_ctx = ablkcipher_request_ctx(sep->current_cypher_req);
tfm = crypto_ablkcipher_reqtfm(sep->current_cypher_req);
sctx = crypto_ablkcipher_ctx(tfm);
pr_debug("crypto_post op\n");
pr_debug("key_sent is %d tfm is %p sctx is %p ta_ctx is %p\n",
sctx->key_sent, tfm, sctx, ta_ctx);
dev_dbg(&ta_ctx->sep_used->pdev->dev, "crypto post_op\n");
dev_dbg(&ta_ctx->sep_used->pdev->dev, "crypto post_op message dump\n");
/* first bring msg from shared area to local area */
memcpy(ta_ctx->msg, sep->shared_addr,
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
/* Is this the result of performing init (key to SEP */
if (sctx->key_sent == 0) {
/* Did SEP do it okay */
u32_error = sep_verify_op(ta_ctx, ta_ctx->init_opcode,
&msg_offset);
if (u32_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"aes init error %x\n", u32_error);
sep_crypto_release(sctx, ta_ctx, u32_error);
return u32_error;
}
/* Read Context */
if (ta_ctx->init_opcode == SEP_DES_INIT_OPCODE) {
sep_read_context(ta_ctx, &msg_offset,
&sctx->des_private_ctx,
sizeof(struct sep_des_private_context));
} else {
sep_read_context(ta_ctx, &msg_offset,
&sctx->aes_private_ctx,
sizeof(struct sep_aes_private_context));
}
sep_dump_ivs(req, "after sending key to sep\n");
/* key sent went okay; release sep, and set are_we_done_yet */
sctx->key_sent = 1;
sep_crypto_release(sctx, ta_ctx, -EINPROGRESS);
} else {
/**
* This is the result of a block request
*/
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"crypto_post_op block response\n");
u32_error = sep_verify_op(ta_ctx, ta_ctx->block_opcode,
&msg_offset);
if (u32_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"sep block error %x\n", u32_error);
sep_crypto_release(sctx, ta_ctx, u32_error);
return -EINVAL;
}
if (ta_ctx->block_opcode == SEP_DES_BLOCK_OPCODE) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"post op for DES\n");
/* special case for 1 block des */
if (sep->current_cypher_req->nbytes ==
crypto_ablkcipher_blocksize(tfm)) {
sep_read_msg(ta_ctx, small_buf,
crypto_ablkcipher_blocksize(tfm),
crypto_ablkcipher_blocksize(tfm) * 2,
&msg_offset, 1);
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"reading in block des\n");
copy_result = sg_copy_from_buffer(
ta_ctx->dst_sg,
sep_sg_nents(ta_ctx->dst_sg),
small_buf,
crypto_ablkcipher_blocksize(tfm));
if (copy_result !=
crypto_ablkcipher_blocksize(tfm)) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"des block copy failed\n");
sep_crypto_release(sctx, ta_ctx,
-ENOMEM);
return -ENOMEM;
}
}
/* Read Context */
sep_read_context(ta_ctx, &msg_offset,
&sctx->des_private_ctx,
sizeof(struct sep_des_private_context));
} else {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"post op for AES\n");
/* Skip the MAC Output */
msg_offset += (sizeof(u32) * 4);
/* Read Context */
sep_read_context(ta_ctx, &msg_offset,
&sctx->aes_private_ctx,
sizeof(struct sep_aes_private_context));
}
/* Copy to correct sg if this block had oddball pages */
if (ta_ctx->dst_sg_hold)
sep_copy_sg(ta_ctx->sep_used,
ta_ctx->dst_sg,
ta_ctx->current_cypher_req->dst,
ta_ctx->current_cypher_req->nbytes);
/**
* Copy the iv's back to the walk.iv
* This is required for dm_crypt
*/
sep_dump_ivs(req, "got data block from sep\n");
if ((ta_ctx->current_request == DES_CBC) &&
(ta_ctx->des_opmode == SEP_DES_CBC)) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"returning result iv to walk on DES\n");
des_internal = (struct sep_des_internal_context *)
sctx->des_private_ctx.ctx_buf;
memcpy(ta_ctx->walk.iv,
(void *)des_internal->iv_context,
crypto_ablkcipher_ivsize(tfm));
} else if ((ta_ctx->current_request == AES_CBC) &&
(ta_ctx->aes_opmode == SEP_AES_CBC)) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"returning result iv to walk on AES\n");
aes_internal = (struct sep_aes_internal_context *)
sctx->aes_private_ctx.cbuff;
memcpy(ta_ctx->walk.iv,
(void *)aes_internal->aes_ctx_iv,
crypto_ablkcipher_ivsize(tfm));
}
/* finished, release everything */
sep_crypto_release(sctx, ta_ctx, 0);
}
pr_debug("crypto_post_op done\n");
pr_debug("key_sent is %d tfm is %p sctx is %p ta_ctx is %p\n",
sctx->key_sent, tfm, sctx, ta_ctx);
return 0;
}
static u32 hash_init_post_op(struct sep_device *sep)
{
u32 u32_error;
u32 msg_offset;
struct crypto_ahash *tfm = crypto_ahash_reqtfm(sep->current_hash_req);
struct this_task_ctx *ta_ctx = ahash_request_ctx(sep->current_hash_req);
struct sep_system_ctx *sctx = crypto_ahash_ctx(tfm);
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"hash init post op\n");
/* first bring msg from shared area to local area */
memcpy(ta_ctx->msg, sep->shared_addr,
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
u32_error = sep_verify_op(ta_ctx, SEP_HASH_INIT_OPCODE,
&msg_offset);
if (u32_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev, "hash init error %x\n",
u32_error);
sep_crypto_release(sctx, ta_ctx, u32_error);
return u32_error;
}
/* Read Context */
sep_read_context(ta_ctx, &msg_offset,
&sctx->hash_private_ctx,
sizeof(struct sep_hash_private_context));
/* Signal to crypto infrastructure and clear out */
dev_dbg(&ta_ctx->sep_used->pdev->dev, "hash init post op done\n");
sep_crypto_release(sctx, ta_ctx, 0);
return 0;
}
static u32 hash_update_post_op(struct sep_device *sep)
{
u32 u32_error;
u32 msg_offset;
struct crypto_ahash *tfm = crypto_ahash_reqtfm(sep->current_hash_req);
struct this_task_ctx *ta_ctx = ahash_request_ctx(sep->current_hash_req);
struct sep_system_ctx *sctx = crypto_ahash_ctx(tfm);
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"hash update post op\n");
/* first bring msg from shared area to local area */
memcpy(ta_ctx->msg, sep->shared_addr,
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
u32_error = sep_verify_op(ta_ctx, SEP_HASH_UPDATE_OPCODE,
&msg_offset);
if (u32_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev, "hash init error %x\n",
u32_error);
sep_crypto_release(sctx, ta_ctx, u32_error);
return u32_error;
}
/* Read Context */
sep_read_context(ta_ctx, &msg_offset,
&sctx->hash_private_ctx,
sizeof(struct sep_hash_private_context));
/**
* 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.
*/
if (ta_ctx->sep_used->current_hash_stage == HASH_FINUP_DATA) {
/* first reset stage to HASH_FINUP_FINISH */
ta_ctx->sep_used->current_hash_stage = HASH_FINUP_FINISH;
/* now enqueue the finish operation */
spin_lock_irq(&queue_lock);
u32_error = crypto_enqueue_request(&sep_queue,
&ta_ctx->sep_used->current_hash_req->base);
spin_unlock_irq(&queue_lock);
if ((u32_error != 0) && (u32_error != -EINPROGRESS)) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"spe cypher post op cant queue\n");
sep_crypto_release(sctx, ta_ctx, u32_error);
return u32_error;
}
/* schedule the data send */
u32_error = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (u32_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"cant submit work sep_crypto_block\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
return -EINVAL;
}
}
/* Signal to crypto infrastructure and clear out */
dev_dbg(&ta_ctx->sep_used->pdev->dev, "hash update post op done\n");
sep_crypto_release(sctx, ta_ctx, 0);
return 0;
}
static u32 hash_final_post_op(struct sep_device *sep)
{
int max_length;
u32 u32_error;
u32 msg_offset;
struct crypto_ahash *tfm = crypto_ahash_reqtfm(sep->current_hash_req);
struct sep_system_ctx *sctx = crypto_ahash_ctx(tfm);
struct this_task_ctx *ta_ctx = ahash_request_ctx(sep->current_hash_req);
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"hash final post op\n");
/* first bring msg from shared area to local area */
memcpy(ta_ctx->msg, sep->shared_addr,
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
u32_error = sep_verify_op(ta_ctx, SEP_HASH_FINISH_OPCODE,
&msg_offset);
if (u32_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev, "hash finish error %x\n",
u32_error);
sep_crypto_release(sctx, ta_ctx, u32_error);
return u32_error;
}
/* Grab the result */
if (ta_ctx->current_hash_req->result == NULL) {
/* Oops, null buffer; error out here */
dev_warn(&ta_ctx->sep_used->pdev->dev,
"hash finish null buffer\n");
sep_crypto_release(sctx, ta_ctx, (u32)-ENOMEM);
return -ENOMEM;
}
max_length = (((SEP_HASH_RESULT_SIZE_WORDS * sizeof(u32)) + 3) /
sizeof(u32)) * sizeof(u32);
sep_read_msg(ta_ctx,
ta_ctx->current_hash_req->result,
crypto_ahash_digestsize(tfm), max_length,
&msg_offset, 0);
/* Signal to crypto infrastructure and clear out */
dev_dbg(&ta_ctx->sep_used->pdev->dev, "hash finish post op done\n");
sep_crypto_release(sctx, ta_ctx, 0);
return 0;
}
static u32 hash_digest_post_op(struct sep_device *sep)
{
int max_length;
u32 u32_error;
u32 msg_offset;
struct crypto_ahash *tfm = crypto_ahash_reqtfm(sep->current_hash_req);
struct sep_system_ctx *sctx = crypto_ahash_ctx(tfm);
struct this_task_ctx *ta_ctx = ahash_request_ctx(sep->current_hash_req);
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"hash digest post op\n");
/* first bring msg from shared area to local area */
memcpy(ta_ctx->msg, sep->shared_addr,
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
u32_error = sep_verify_op(ta_ctx, SEP_HASH_SINGLE_OPCODE,
&msg_offset);
if (u32_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"hash digest finish error %x\n", u32_error);
sep_crypto_release(sctx, ta_ctx, u32_error);
return u32_error;
}
/* Grab the result */
if (ta_ctx->current_hash_req->result == NULL) {
/* Oops, null buffer; error out here */
dev_warn(&ta_ctx->sep_used->pdev->dev,
"hash digest finish null buffer\n");
sep_crypto_release(sctx, ta_ctx, (u32)-ENOMEM);
return -ENOMEM;
}
max_length = (((SEP_HASH_RESULT_SIZE_WORDS * sizeof(u32)) + 3) /
sizeof(u32)) * sizeof(u32);
sep_read_msg(ta_ctx,
ta_ctx->current_hash_req->result,
crypto_ahash_digestsize(tfm), max_length,
&msg_offset, 0);
/* Signal to crypto infrastructure and clear out */
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"hash digest finish post op done\n");
sep_crypto_release(sctx, ta_ctx, 0);
return 0;
}
/**
* 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.
*/
static void sep_finish(unsigned long data)
{
struct sep_device *sep_dev;
int res;
res = 0;
if (data == 0) {
pr_debug("sep_finish called with null data\n");
return;
}
sep_dev = (struct sep_device *)data;
if (sep_dev == NULL) {
pr_debug("sep_finish; sep_dev is NULL\n");
return;
}
if (sep_dev->in_kernel == (u32)0) {
dev_warn(&sep_dev->pdev->dev,
"sep_finish; not in kernel operation\n");
return;
}
/* Did we really do a sep command prior to this? */
if (0 == test_bit(SEP_LEGACY_SENDMSG_DONE_OFFSET,
&sep_dev->ta_ctx->call_status.status)) {
dev_warn(&sep_dev->pdev->dev, "[PID%d] sendmsg not called\n",
current->pid);
return;
}
if (sep_dev->send_ct != sep_dev->reply_ct) {
dev_warn(&sep_dev->pdev->dev,
"[PID%d] poll; no message came back\n",
current->pid);
return;
}
/* Check for error (In case time ran out) */
if ((res != 0x0) && (res != 0x8)) {
dev_warn(&sep_dev->pdev->dev,
"[PID%d] poll; poll error GPR3 is %x\n",
current->pid, res);
return;
}
/* What kind of interrupt from sep was this? */
res = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR2_REG_ADDR);
dev_dbg(&sep_dev->pdev->dev, "[PID%d] GPR2 at crypto finish is %x\n",
current->pid, res);
/* Print request? */
if ((res >> 30) & 0x1) {
dev_dbg(&sep_dev->pdev->dev, "[PID%d] sep print req\n",
current->pid);
dev_dbg(&sep_dev->pdev->dev, "[PID%d] contents: %s\n",
current->pid,
(char *)(sep_dev->shared_addr +
SEP_DRIVER_PRINTF_OFFSET_IN_BYTES));
return;
}
/* Request for daemon (not currently in POR)? */
if (res >> 31) {
dev_dbg(&sep_dev->pdev->dev,
"[PID%d] sep request; ignoring\n",
current->pid);
return;
}
/* If we got here, then we have a replay to a sep command */
dev_dbg(&sep_dev->pdev->dev,
"[PID%d] sep reply to command; processing request: %x\n",
current->pid, sep_dev->current_request);
switch (sep_dev->current_request) {
case AES_CBC:
case AES_ECB:
case DES_CBC:
case DES_ECB:
res = crypto_post_op(sep_dev);
break;
case SHA1:
case MD5:
case SHA224:
case SHA256:
switch (sep_dev->current_hash_stage) {
case HASH_INIT:
res = hash_init_post_op(sep_dev);
break;
case HASH_UPDATE:
case HASH_FINUP_DATA:
res = hash_update_post_op(sep_dev);
break;
case HASH_FINUP_FINISH:
case HASH_FINISH:
res = hash_final_post_op(sep_dev);
break;
case HASH_DIGEST:
res = hash_digest_post_op(sep_dev);
break;
default:
pr_debug("sep - invalid stage for hash finish\n");
}
break;
default:
pr_debug("sep - invalid request for finish\n");
}
if (res)
pr_debug("sep - finish returned error %x\n", res);
}
static int sep_hash_cra_init(struct crypto_tfm *tfm)
{
const char *alg_name = crypto_tfm_alg_name(tfm);
pr_debug("sep_hash_cra_init name is %s\n", alg_name);
crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
sizeof(struct this_task_ctx));
return 0;
}
static void sep_hash_cra_exit(struct crypto_tfm *tfm)
{
pr_debug("sep_hash_cra_exit\n");
}
static void sep_hash_init(void *data)
{
u32 msg_offset;
int result;
struct ahash_request *req;
struct crypto_ahash *tfm;
struct this_task_ctx *ta_ctx;
struct sep_system_ctx *sctx;
unsigned long end_time;
int are_we_done_yet;
req = (struct ahash_request *)data;
tfm = crypto_ahash_reqtfm(req);
sctx = crypto_ahash_ctx(tfm);
ta_ctx = ahash_request_ctx(req);
ta_ctx->sep_used = sep_dev;
ta_ctx->are_we_done_yet = &are_we_done_yet;
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"sep_hash_init\n");
ta_ctx->current_hash_stage = HASH_INIT;
/* opcode and mode */
sep_make_header(ta_ctx, &msg_offset, SEP_HASH_INIT_OPCODE);
sep_write_msg(ta_ctx, &ta_ctx->hash_opmode,
sizeof(u32), sizeof(u32), &msg_offset, 0);
sep_end_msg(ta_ctx, msg_offset);
are_we_done_yet = 0;
result = sep_crypto_take_sep(ta_ctx);
if (result) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"sep_hash_init take sep failed\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
}
/* now we sit and wait up to a fixed time for completion */
end_time = jiffies + (WAIT_TIME * HZ);
while ((time_before(jiffies, end_time)) && (are_we_done_yet == 0))
schedule();
/* Done waiting; still not done yet? */
if (are_we_done_yet == 0) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"hash init never got done\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
return;
}
}
static void sep_hash_update(void *data)
{
int int_error;
u32 msg_offset;
u32 len;
struct sep_hash_internal_context *int_ctx;
u32 block_size;
u32 head_len;
u32 tail_len;
int are_we_done_yet;
static u32 msg[10];
static char small_buf[100];
void *src_ptr;
struct scatterlist *new_sg;
ssize_t copy_result;
struct ahash_request *req;
struct crypto_ahash *tfm;
struct this_task_ctx *ta_ctx;
struct sep_system_ctx *sctx;
unsigned long end_time;
req = (struct ahash_request *)data;
tfm = crypto_ahash_reqtfm(req);
sctx = crypto_ahash_ctx(tfm);
ta_ctx = ahash_request_ctx(req);
ta_ctx->sep_used = sep_dev;
ta_ctx->are_we_done_yet = &are_we_done_yet;
/* length for queue status */
ta_ctx->nbytes = req->nbytes;
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"sep_hash_update\n");
ta_ctx->current_hash_stage = HASH_UPDATE;
len = req->nbytes;
block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));
tail_len = req->nbytes % block_size;
dev_dbg(&ta_ctx->sep_used->pdev->dev, "length is %x\n", len);
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);
/* Compute header/tail sizes */
int_ctx = (struct sep_hash_internal_context *)&sctx->
hash_private_ctx.internal_context;
head_len = (block_size - int_ctx->prev_update_bytes) % block_size;
tail_len = (req->nbytes - head_len) % block_size;
/* 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);
if (int_error < 0) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"oddball pages error in crash update\n");
sep_crypto_release(sctx, ta_ctx, -ENOMEM);
return;
} else if (int_error == 1) {
ta_ctx->src_sg = new_sg;
ta_ctx->src_sg_hold = new_sg;
} else {
ta_ctx->src_sg = req->src;
ta_ctx->src_sg_hold = NULL;
}
src_ptr = sg_virt(ta_ctx->src_sg);
if ((!req->nbytes) || (!ta_ctx->src_sg)) {
/* null data */
src_ptr = NULL;
}
ta_ctx->dcb_input_data.app_in_address = src_ptr;
ta_ctx->dcb_input_data.data_in_size =
req->nbytes - (head_len + tail_len);
ta_ctx->dcb_input_data.app_out_address = NULL;
ta_ctx->dcb_input_data.block_size = block_size;
ta_ctx->dcb_input_data.tail_block_size = 0;
ta_ctx->dcb_input_data.is_applet = 0;
ta_ctx->dcb_input_data.src_sg = ta_ctx->src_sg;
ta_ctx->dcb_input_data.dst_sg = NULL;
int_error = sep_create_dcb_dmatables_context_kernel(
ta_ctx->sep_used,
&ta_ctx->dcb_region,
&ta_ctx->dmatables_region,
&ta_ctx->dma_ctx,
&ta_ctx->dcb_input_data,
1);
if (int_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"hash update dma table create failed\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
return;
}
/* Construct message to SEP */
sep_make_header(ta_ctx, &msg_offset, SEP_HASH_UPDATE_OPCODE);
msg[0] = (u32)0;
msg[1] = (u32)0;
msg[2] = (u32)0;
sep_write_msg(ta_ctx, msg, sizeof(u32) * 3, sizeof(u32) * 3,
&msg_offset, 0);
/* Handle remainders */
/* Head */
sep_write_msg(ta_ctx, &head_len, sizeof(u32),
sizeof(u32), &msg_offset, 0);
if (head_len) {
copy_result = sg_copy_to_buffer(
req->src,
sep_sg_nents(ta_ctx->src_sg),
small_buf, head_len);
if (copy_result != head_len) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"sg head copy failure in hash block\n");
sep_crypto_release(sctx, ta_ctx, -ENOMEM);
return;
}
sep_write_msg(ta_ctx, small_buf, head_len,
sizeof(u32) * 32, &msg_offset, 1);
} else {
msg_offset += sizeof(u32) * 32;
}
/* Tail */
sep_write_msg(ta_ctx, &tail_len, sizeof(u32),
sizeof(u32), &msg_offset, 0);
if (tail_len) {
copy_result = sep_copy_offset_sg(
ta_ctx->sep_used,
ta_ctx->src_sg,
req->nbytes - tail_len,
small_buf, tail_len);
if (copy_result != tail_len) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"sg tail copy failure in hash block\n");
sep_crypto_release(sctx, ta_ctx, -ENOMEM);
return;
}
sep_write_msg(ta_ctx, small_buf, tail_len,
sizeof(u32) * 32, &msg_offset, 1);
} else {
msg_offset += sizeof(u32) * 32;
}
/* Context */
sep_write_context(ta_ctx, &msg_offset, &sctx->hash_private_ctx,
sizeof(struct sep_hash_private_context));
sep_end_msg(ta_ctx, msg_offset);
are_we_done_yet = 0;
int_error = sep_crypto_take_sep(ta_ctx);
if (int_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"sep_hash_update take sep failed\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
}
/* now we sit and wait up to a fixed time for completion */
end_time = jiffies + (WAIT_TIME * HZ);
while ((time_before(jiffies, end_time)) && (are_we_done_yet == 0))
schedule();
/* Done waiting; still not done yet? */
if (are_we_done_yet == 0) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"hash update never got done\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
return;
}
}
static void sep_hash_final(void *data)
{
u32 msg_offset;
struct ahash_request *req;
struct crypto_ahash *tfm;
struct this_task_ctx *ta_ctx;
struct sep_system_ctx *sctx;
int result;
unsigned long end_time;
int are_we_done_yet;
req = (struct ahash_request *)data;
tfm = crypto_ahash_reqtfm(req);
sctx = crypto_ahash_ctx(tfm);
ta_ctx = ahash_request_ctx(req);
ta_ctx->sep_used = sep_dev;
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"sep_hash_final\n");
ta_ctx->current_hash_stage = HASH_FINISH;
ta_ctx->are_we_done_yet = &are_we_done_yet;
/* opcode and mode */
sep_make_header(ta_ctx, &msg_offset, SEP_HASH_FINISH_OPCODE);
/* Context */
sep_write_context(ta_ctx, &msg_offset, &sctx->hash_private_ctx,
sizeof(struct sep_hash_private_context));
sep_end_msg(ta_ctx, msg_offset);
are_we_done_yet = 0;
result = sep_crypto_take_sep(ta_ctx);
if (result) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"sep_hash_final take sep failed\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
}
/* now we sit and wait up to a fixed time for completion */
end_time = jiffies + (WAIT_TIME * HZ);
while ((time_before(jiffies, end_time)) && (are_we_done_yet == 0))
schedule();
/* Done waiting; still not done yet? */
if (are_we_done_yet == 0) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"hash final job never got done\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
return;
}
}
static void sep_hash_digest(void *data)
{
int int_error;
u32 msg_offset;
u32 block_size;
u32 msg[10];
size_t copy_result;
int result;
int are_we_done_yet;
u32 tail_len;
static char small_buf[100];
struct scatterlist *new_sg;
void *src_ptr;
struct ahash_request *req;
struct crypto_ahash *tfm;
struct this_task_ctx *ta_ctx;
struct sep_system_ctx *sctx;
unsigned long end_time;
req = (struct ahash_request *)data;
tfm = crypto_ahash_reqtfm(req);
sctx = crypto_ahash_ctx(tfm);
ta_ctx = ahash_request_ctx(req);
ta_ctx->sep_used = sep_dev;
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"sep_hash_digest\n");
ta_ctx->current_hash_stage = HASH_DIGEST;
ta_ctx->are_we_done_yet = &are_we_done_yet;
/* length for queue status */
ta_ctx->nbytes = req->nbytes;
block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));
tail_len = req->nbytes % block_size;
dev_dbg(&ta_ctx->sep_used->pdev->dev, "length is %x\n", req->nbytes);
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 an even block */
int_error = sep_oddball_pages(ta_ctx->sep_used, req->src,
req->nbytes,
block_size, &new_sg, 1);
if (int_error < 0) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"oddball pages error in crash update\n");
sep_crypto_release(sctx, ta_ctx, -ENOMEM);
return;
} else if (int_error == 1) {
ta_ctx->src_sg = new_sg;
ta_ctx->src_sg_hold = new_sg;
} else {
ta_ctx->src_sg = req->src;
ta_ctx->src_sg_hold = NULL;
}
src_ptr = sg_virt(ta_ctx->src_sg);
if ((!req->nbytes) || (!ta_ctx->src_sg)) {
/* null data */
src_ptr = NULL;
}
ta_ctx->dcb_input_data.app_in_address = src_ptr;
ta_ctx->dcb_input_data.data_in_size = req->nbytes - tail_len;
ta_ctx->dcb_input_data.app_out_address = NULL;
ta_ctx->dcb_input_data.block_size = block_size;
ta_ctx->dcb_input_data.tail_block_size = 0;
ta_ctx->dcb_input_data.is_applet = 0;
ta_ctx->dcb_input_data.src_sg = ta_ctx->src_sg;
ta_ctx->dcb_input_data.dst_sg = NULL;
int_error = sep_create_dcb_dmatables_context_kernel(
ta_ctx->sep_used,
&ta_ctx->dcb_region,
&ta_ctx->dmatables_region,
&ta_ctx->dma_ctx,
&ta_ctx->dcb_input_data,
1);
if (int_error) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"hash update dma table create failed\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
return;
}
/* Construct message to SEP */
sep_make_header(ta_ctx, &msg_offset, SEP_HASH_SINGLE_OPCODE);
sep_write_msg(ta_ctx, &ta_ctx->hash_opmode,
sizeof(u32), sizeof(u32), &msg_offset, 0);
msg[0] = (u32)0;
msg[1] = (u32)0;
msg[2] = (u32)0;
sep_write_msg(ta_ctx, msg, sizeof(u32) * 3, sizeof(u32) * 3,
&msg_offset, 0);
/* Tail */
sep_write_msg(ta_ctx, &tail_len, sizeof(u32),
sizeof(u32), &msg_offset, 0);
if (tail_len) {
copy_result = sep_copy_offset_sg(
ta_ctx->sep_used,
ta_ctx->src_sg,
req->nbytes - tail_len,
small_buf, tail_len);
if (copy_result != tail_len) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"sg tail copy failure in hash block\n");
sep_crypto_release(sctx, ta_ctx, -ENOMEM);
return;
}
sep_write_msg(ta_ctx, small_buf, tail_len,
sizeof(u32) * 32, &msg_offset, 1);
} else {
msg_offset += sizeof(u32) * 32;
}
sep_end_msg(ta_ctx, msg_offset);
are_we_done_yet = 0;
result = sep_crypto_take_sep(ta_ctx);
if (result) {
dev_warn(&ta_ctx->sep_used->pdev->dev,
"sep_hash_digest take sep failed\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
}
/* now we sit and wait up to a fixed time for completion */
end_time = jiffies + (WAIT_TIME * HZ);
while ((time_before(jiffies, end_time)) && (are_we_done_yet == 0))
schedule();
/* Done waiting; still not done yet? */
if (are_we_done_yet == 0) {
dev_dbg(&ta_ctx->sep_used->pdev->dev,
"hash digest job never got done\n");
sep_crypto_release(sctx, ta_ctx, -EINVAL);
return;
}
}
/**
* This is what is called by each of the API's provided
* in the kernel crypto descriptors. It is run in a process
* context using the kernel workqueues. Therefore it can
* be put to sleep.
*/
static void sep_dequeuer(void *data)
{
struct crypto_queue *this_queue;
struct crypto_async_request *async_req;
struct crypto_async_request *backlog;
struct ablkcipher_request *cypher_req;
struct ahash_request *hash_req;
struct sep_system_ctx *sctx;
struct crypto_ahash *hash_tfm;
struct this_task_ctx *ta_ctx;
this_queue = (struct crypto_queue *)data;
spin_lock_irq(&queue_lock);
backlog = crypto_get_backlog(this_queue);
async_req = crypto_dequeue_request(this_queue);
spin_unlock_irq(&queue_lock);
if (!async_req) {
pr_debug("sep crypto queue is empty\n");
return;
}
if (backlog) {
pr_debug("sep crypto backlog set\n");
if (backlog->complete)
backlog->complete(backlog, -EINPROGRESS);
backlog = NULL;
}
if (!async_req->tfm) {
pr_debug("sep crypto queue null tfm\n");
return;
}
if (!async_req->tfm->__crt_alg) {
pr_debug("sep crypto queue null __crt_alg\n");
return;
}
if (!async_req->tfm->__crt_alg->cra_type) {
pr_debug("sep crypto queue null cra_type\n");
return;
}
/* we have stuff in the queue */
if (async_req->tfm->__crt_alg->cra_type !=
&crypto_ahash_type) {
/* This is for a cypher */
pr_debug("sep crypto queue doing cipher\n");
cypher_req = container_of(async_req,
struct ablkcipher_request,
base);
if (!cypher_req) {
pr_debug("sep crypto queue null cypher_req\n");
return;
}
sep_crypto_block((void *)cypher_req);
return;
} else {
/* This is a hash */
pr_debug("sep crypto queue doing hash\n");
/**
* This is a bit more complex than cipher; we
* need to figure out what type of operation
*/
hash_req = ahash_request_cast(async_req);
if (!hash_req) {
pr_debug("sep crypto queue null hash_req\n");
return;
}
hash_tfm = crypto_ahash_reqtfm(hash_req);
if (!hash_tfm) {
pr_debug("sep crypto queue null hash_tfm\n");
return;
}
sctx = crypto_ahash_ctx(hash_tfm);
if (!sctx) {
pr_debug("sep crypto queue null sctx\n");
return;
}
ta_ctx = ahash_request_ctx(hash_req);
if (ta_ctx->current_hash_stage == HASH_INIT) {
pr_debug("sep crypto queue hash init\n");
sep_hash_init((void *)hash_req);
return;
} else if (ta_ctx->current_hash_stage == HASH_UPDATE) {
pr_debug("sep crypto queue hash update\n");
sep_hash_update((void *)hash_req);
return;
} else if (ta_ctx->current_hash_stage == HASH_FINISH) {
pr_debug("sep crypto queue hash final\n");
sep_hash_final((void *)hash_req);
return;
} else if (ta_ctx->current_hash_stage == HASH_DIGEST) {
pr_debug("sep crypto queue hash digest\n");
sep_hash_digest((void *)hash_req);
return;
} else if (ta_ctx->current_hash_stage == HASH_FINUP_DATA) {
pr_debug("sep crypto queue hash digest\n");
sep_hash_update((void *)hash_req);
return;
} else if (ta_ctx->current_hash_stage == HASH_FINUP_FINISH) {
pr_debug("sep crypto queue hash digest\n");
sep_hash_final((void *)hash_req);
return;
} else {
pr_debug("sep crypto queue hash oops nothing\n");
return;
}
}
}
static int sep_sha1_init(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha1 init\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA1;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA1;
ta_ctx->current_hash_stage = HASH_INIT;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha1_update(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha1 update\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA1;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA1;
ta_ctx->current_hash_stage = HASH_UPDATE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha1_final(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha1 final\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA1;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA1;
ta_ctx->current_hash_stage = HASH_FINISH;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha1_digest(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha1 digest\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA1;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA1;
ta_ctx->current_hash_stage = HASH_DIGEST;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha1_finup(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha1 finup\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA1;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA1;
ta_ctx->current_hash_stage = HASH_FINUP_DATA;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_md5_init(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing md5 init\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = MD5;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_MD5;
ta_ctx->current_hash_stage = HASH_INIT;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_md5_update(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing md5 update\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = MD5;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_MD5;
ta_ctx->current_hash_stage = HASH_UPDATE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_md5_final(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing md5 final\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = MD5;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_MD5;
ta_ctx->current_hash_stage = HASH_FINISH;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_md5_digest(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing md5 digest\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = MD5;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_MD5;
ta_ctx->current_hash_stage = HASH_DIGEST;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_md5_finup(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing md5 finup\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = MD5;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_MD5;
ta_ctx->current_hash_stage = HASH_FINUP_DATA;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha224_init(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha224 init\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA224;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA224;
ta_ctx->current_hash_stage = HASH_INIT;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha224_update(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha224 update\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA224;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA224;
ta_ctx->current_hash_stage = HASH_UPDATE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha224_final(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha224 final\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA224;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA224;
ta_ctx->current_hash_stage = HASH_FINISH;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha224_digest(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha224 digest\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA224;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA224;
ta_ctx->current_hash_stage = HASH_DIGEST;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha224_finup(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha224 finup\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA224;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA224;
ta_ctx->current_hash_stage = HASH_FINUP_DATA;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha256_init(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha256 init\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA256;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA256;
ta_ctx->current_hash_stage = HASH_INIT;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha256_update(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha256 update\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA256;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA256;
ta_ctx->current_hash_stage = HASH_UPDATE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha256_final(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha256 final\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA256;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA256;
ta_ctx->current_hash_stage = HASH_FINISH;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha256_digest(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha256 digest\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA256;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA256;
ta_ctx->current_hash_stage = HASH_DIGEST;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_sha256_finup(struct ahash_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
pr_debug("sep - doing sha256 finup\n");
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = SHA256;
ta_ctx->current_hash_req = req;
ta_ctx->current_cypher_req = NULL;
ta_ctx->hash_opmode = SEP_HASH_SHA256;
ta_ctx->current_hash_stage = HASH_FINUP_DATA;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_crypto_init(struct crypto_tfm *tfm)
{
const char *alg_name = crypto_tfm_alg_name(tfm);
if (alg_name == NULL)
pr_debug("sep_crypto_init alg is NULL\n");
else
pr_debug("sep_crypto_init alg is %s\n", alg_name);
tfm->crt_ablkcipher.reqsize = sizeof(struct this_task_ctx);
return 0;
}
static void sep_crypto_exit(struct crypto_tfm *tfm)
{
pr_debug("sep_crypto_exit\n");
}
static int sep_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
unsigned int keylen)
{
struct sep_system_ctx *sctx = crypto_ablkcipher_ctx(tfm);
pr_debug("sep aes setkey\n");
pr_debug("tfm is %p sctx is %p\n", tfm, sctx);
switch (keylen) {
case SEP_AES_KEY_128_SIZE:
sctx->aes_key_size = AES_128;
break;
case SEP_AES_KEY_192_SIZE:
sctx->aes_key_size = AES_192;
break;
case SEP_AES_KEY_256_SIZE:
sctx->aes_key_size = AES_256;
break;
case SEP_AES_KEY_512_SIZE:
sctx->aes_key_size = AES_512;
break;
default:
pr_debug("invalid sep aes key size %x\n",
keylen);
return -EINVAL;
}
memset(&sctx->key.aes, 0, sizeof(u32) *
SEP_AES_MAX_KEY_SIZE_WORDS);
memcpy(&sctx->key.aes, key, keylen);
sctx->keylen = keylen;
/* Indicate to encrypt/decrypt function to send key to SEP */
sctx->key_sent = 0;
return 0;
}
static int sep_aes_ecb_encrypt(struct ablkcipher_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
pr_debug("sep - doing aes ecb encrypt\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = AES_ECB;
ta_ctx->current_hash_req = NULL;
ta_ctx->current_cypher_req = req;
ta_ctx->aes_encmode = SEP_AES_ENCRYPT;
ta_ctx->aes_opmode = SEP_AES_ECB;
ta_ctx->init_opcode = SEP_AES_INIT_OPCODE;
ta_ctx->block_opcode = SEP_AES_BLOCK_OPCODE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_aes_ecb_decrypt(struct ablkcipher_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
pr_debug("sep - doing aes ecb decrypt\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = AES_ECB;
ta_ctx->current_hash_req = NULL;
ta_ctx->current_cypher_req = req;
ta_ctx->aes_encmode = SEP_AES_DECRYPT;
ta_ctx->aes_opmode = SEP_AES_ECB;
ta_ctx->init_opcode = SEP_AES_INIT_OPCODE;
ta_ctx->block_opcode = SEP_AES_BLOCK_OPCODE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_aes_cbc_encrypt(struct ablkcipher_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
struct sep_system_ctx *sctx = crypto_ablkcipher_ctx(
crypto_ablkcipher_reqtfm(req));
pr_debug("sep - doing aes cbc encrypt\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
pr_debug("tfm is %p sctx is %p and ta_ctx is %p\n",
crypto_ablkcipher_reqtfm(req), sctx, ta_ctx);
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = AES_CBC;
ta_ctx->current_hash_req = NULL;
ta_ctx->current_cypher_req = req;
ta_ctx->aes_encmode = SEP_AES_ENCRYPT;
ta_ctx->aes_opmode = SEP_AES_CBC;
ta_ctx->init_opcode = SEP_AES_INIT_OPCODE;
ta_ctx->block_opcode = SEP_AES_BLOCK_OPCODE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_aes_cbc_decrypt(struct ablkcipher_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
struct sep_system_ctx *sctx = crypto_ablkcipher_ctx(
crypto_ablkcipher_reqtfm(req));
pr_debug("sep - doing aes cbc decrypt\n");
pr_debug("tfm is %p sctx is %p and ta_ctx is %p\n",
crypto_ablkcipher_reqtfm(req), sctx, ta_ctx);
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = AES_CBC;
ta_ctx->current_hash_req = NULL;
ta_ctx->current_cypher_req = req;
ta_ctx->aes_encmode = SEP_AES_DECRYPT;
ta_ctx->aes_opmode = SEP_AES_CBC;
ta_ctx->init_opcode = SEP_AES_INIT_OPCODE;
ta_ctx->block_opcode = SEP_AES_BLOCK_OPCODE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_des_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
unsigned int keylen)
{
struct sep_system_ctx *sctx = crypto_ablkcipher_ctx(tfm);
struct crypto_tfm *ctfm = crypto_ablkcipher_tfm(tfm);
u32 *flags = &ctfm->crt_flags;
pr_debug("sep des setkey\n");
switch (keylen) {
case DES_KEY_SIZE:
sctx->des_nbr_keys = DES_KEY_1;
break;
case DES_KEY_SIZE * 2:
sctx->des_nbr_keys = DES_KEY_2;
break;
case DES_KEY_SIZE * 3:
sctx->des_nbr_keys = DES_KEY_3;
break;
default:
pr_debug("invalid key size %x\n",
keylen);
return -EINVAL;
}
if ((*flags & CRYPTO_TFM_REQ_WEAK_KEY) &&
(sep_weak_key(key, keylen))) {
*flags |= CRYPTO_TFM_RES_WEAK_KEY;
pr_debug("weak key\n");
return -EINVAL;
}
memset(&sctx->key.des, 0, sizeof(struct sep_des_key));
memcpy(&sctx->key.des.key1, key, keylen);
sctx->keylen = keylen;
/* Indicate to encrypt/decrypt function to send key to SEP */
sctx->key_sent = 0;
return 0;
}
static int sep_des_ebc_encrypt(struct ablkcipher_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
pr_debug("sep - doing des ecb encrypt\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = DES_ECB;
ta_ctx->current_hash_req = NULL;
ta_ctx->current_cypher_req = req;
ta_ctx->des_encmode = SEP_DES_ENCRYPT;
ta_ctx->des_opmode = SEP_DES_ECB;
ta_ctx->init_opcode = SEP_DES_INIT_OPCODE;
ta_ctx->block_opcode = SEP_DES_BLOCK_OPCODE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_des_ebc_decrypt(struct ablkcipher_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
pr_debug("sep - doing des ecb decrypt\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = DES_ECB;
ta_ctx->current_hash_req = NULL;
ta_ctx->current_cypher_req = req;
ta_ctx->des_encmode = SEP_DES_DECRYPT;
ta_ctx->des_opmode = SEP_DES_ECB;
ta_ctx->init_opcode = SEP_DES_INIT_OPCODE;
ta_ctx->block_opcode = SEP_DES_BLOCK_OPCODE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_des_cbc_encrypt(struct ablkcipher_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
pr_debug("sep - doing des cbc encrypt\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = DES_CBC;
ta_ctx->current_hash_req = NULL;
ta_ctx->current_cypher_req = req;
ta_ctx->des_encmode = SEP_DES_ENCRYPT;
ta_ctx->des_opmode = SEP_DES_CBC;
ta_ctx->init_opcode = SEP_DES_INIT_OPCODE;
ta_ctx->block_opcode = SEP_DES_BLOCK_OPCODE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static int sep_des_cbc_decrypt(struct ablkcipher_request *req)
{
int error;
int error1;
struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
pr_debug("sep - doing des ecb decrypt\n");
/* Clear out task context */
memset(ta_ctx, 0, sizeof(struct this_task_ctx));
ta_ctx->sep_used = sep_dev;
ta_ctx->current_request = DES_CBC;
ta_ctx->current_hash_req = NULL;
ta_ctx->current_cypher_req = req;
ta_ctx->des_encmode = SEP_DES_DECRYPT;
ta_ctx->des_opmode = SEP_DES_CBC;
ta_ctx->init_opcode = SEP_DES_INIT_OPCODE;
ta_ctx->block_opcode = SEP_DES_BLOCK_OPCODE;
/* lock necessary so that only one entity touches the queues */
spin_lock_irq(&queue_lock);
error = crypto_enqueue_request(&sep_queue, &req->base);
if ((error != 0) && (error != -EINPROGRESS))
pr_debug(" sep - crypto enqueue failed: %x\n",
error);
error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
sep_dequeuer, (void *)&sep_queue);
if (error1)
pr_debug(" sep - workqueue submit failed: %x\n",
error1);
spin_unlock_irq(&queue_lock);
/* We return result of crypto enqueue */
return error;
}
static struct ahash_alg hash_algs[] = {
{
.init = sep_sha1_init,
.update = sep_sha1_update,
.final = sep_sha1_final,
.digest = sep_sha1_digest,
.finup = sep_sha1_finup,
.halg = {
.digestsize = SHA1_DIGEST_SIZE,
.base = {
.cra_name = "sha1",
.cra_driver_name = "sha1-sep",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_AHASH |
CRYPTO_ALG_ASYNC,
.cra_blocksize = SHA1_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct sep_system_ctx),
.cra_alignmask = 0,
.cra_module = THIS_MODULE,
.cra_init = sep_hash_cra_init,
.cra_exit = sep_hash_cra_exit,
}
}
},
{
.init = sep_md5_init,
.update = sep_md5_update,
.final = sep_md5_final,
.digest = sep_md5_digest,
.finup = sep_md5_finup,
.halg = {
.digestsize = MD5_DIGEST_SIZE,
.base = {
.cra_name = "md5",
.cra_driver_name = "md5-sep",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_AHASH |
CRYPTO_ALG_ASYNC,
.cra_blocksize = SHA1_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct sep_system_ctx),
.cra_alignmask = 0,
.cra_module = THIS_MODULE,
.cra_init = sep_hash_cra_init,
.cra_exit = sep_hash_cra_exit,
}
}
},
{
.init = sep_sha224_init,
.update = sep_sha224_update,
.final = sep_sha224_final,
.digest = sep_sha224_digest,
.finup = sep_sha224_finup,
.halg = {
.digestsize = SHA224_DIGEST_SIZE,
.base = {
.cra_name = "sha224",
.cra_driver_name = "sha224-sep",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_AHASH |
CRYPTO_ALG_ASYNC,
.cra_blocksize = SHA224_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct sep_system_ctx),
.cra_alignmask = 0,
.cra_module = THIS_MODULE,
.cra_init = sep_hash_cra_init,
.cra_exit = sep_hash_cra_exit,
}
}
},
{
.init = sep_sha256_init,
.update = sep_sha256_update,
.final = sep_sha256_final,
.digest = sep_sha256_digest,
.finup = sep_sha256_finup,
.halg = {
.digestsize = SHA256_DIGEST_SIZE,
.base = {
.cra_name = "sha256",
.cra_driver_name = "sha256-sep",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_AHASH |
CRYPTO_ALG_ASYNC,
.cra_blocksize = SHA256_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct sep_system_ctx),
.cra_alignmask = 0,
.cra_module = THIS_MODULE,
.cra_init = sep_hash_cra_init,
.cra_exit = sep_hash_cra_exit,
}
}
}
};
static struct crypto_alg crypto_algs[] = {
{
.cra_name = "ecb(aes)",
.cra_driver_name = "ecb-aes-sep",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct sep_system_ctx),
.cra_alignmask = 0,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE,
.cra_init = sep_crypto_init,
.cra_exit = sep_crypto_exit,
.cra_u.ablkcipher = {
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.setkey = sep_aes_setkey,
.encrypt = sep_aes_ecb_encrypt,
.decrypt = sep_aes_ecb_decrypt,
}
},
{
.cra_name = "cbc(aes)",
.cra_driver_name = "cbc-aes-sep",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct sep_system_ctx),
.cra_alignmask = 0,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE,
.cra_init = sep_crypto_init,
.cra_exit = sep_crypto_exit,
.cra_u.ablkcipher = {
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.setkey = sep_aes_setkey,
.encrypt = sep_aes_cbc_encrypt,
.ivsize = AES_BLOCK_SIZE,
.decrypt = sep_aes_cbc_decrypt,
}
},
{
.cra_name = "ebc(des)",
.cra_driver_name = "ebc-des-sep",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct sep_system_ctx),
.cra_alignmask = 0,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE,
.cra_init = sep_crypto_init,
.cra_exit = sep_crypto_exit,
.cra_u.ablkcipher = {
.min_keysize = DES_KEY_SIZE,
.max_keysize = DES_KEY_SIZE,
.setkey = sep_des_setkey,
.encrypt = sep_des_ebc_encrypt,
.decrypt = sep_des_ebc_decrypt,
}
},
{
.cra_name = "cbc(des)",
.cra_driver_name = "cbc-des-sep",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct sep_system_ctx),
.cra_alignmask = 0,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE,
.cra_init = sep_crypto_init,
.cra_exit = sep_crypto_exit,
.cra_u.ablkcipher = {
.min_keysize = DES_KEY_SIZE,
.max_keysize = DES_KEY_SIZE,
.setkey = sep_des_setkey,
.encrypt = sep_des_cbc_encrypt,
.ivsize = DES_BLOCK_SIZE,
.decrypt = sep_des_cbc_decrypt,
}
},
{
.cra_name = "ebc(des3-ede)",
.cra_driver_name = "ebc-des3-ede-sep",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct sep_system_ctx),
.cra_alignmask = 0,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE,
.cra_init = sep_crypto_init,
.cra_exit = sep_crypto_exit,
.cra_u.ablkcipher = {
.min_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE,
.setkey = sep_des_setkey,
.encrypt = sep_des_ebc_encrypt,
.decrypt = sep_des_ebc_decrypt,
}
},
{
.cra_name = "cbc(des3-ede)",
.cra_driver_name = "cbc-des3--ede-sep",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct sep_system_ctx),
.cra_alignmask = 0,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE,
.cra_init = sep_crypto_init,
.cra_exit = sep_crypto_exit,
.cra_u.ablkcipher = {
.min_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE,
.setkey = sep_des_setkey,
.encrypt = sep_des_cbc_encrypt,
.decrypt = sep_des_cbc_decrypt,
}
}
};
int sep_crypto_setup(void)
{
int err, i, j, k;
tasklet_init(&sep_dev->finish_tasklet, sep_finish,
(unsigned long)sep_dev);
crypto_init_queue(&sep_queue, SEP_QUEUE_LENGTH);
sep_dev->workqueue = create_singlethread_workqueue(
"sep_crypto_workqueue");
if (!sep_dev->workqueue) {
dev_warn(&sep_dev->pdev->dev, "cant create workqueue\n");
return -ENOMEM;
}
spin_lock_init(&queue_lock);
err = 0;
for (i = 0; i < ARRAY_SIZE(hash_algs); i++) {
err = crypto_register_ahash(&hash_algs[i]);
if (err)
goto err_algs;
}
err = 0;
for (j = 0; j < ARRAY_SIZE(crypto_algs); j++) {
err = crypto_register_alg(&crypto_algs[j]);
if (err)
goto err_crypto_algs;
}
return err;
err_algs:
for (k = 0; k < i; k++)
crypto_unregister_ahash(&hash_algs[k]);
return err;
err_crypto_algs:
for (k = 0; k < j; k++)
crypto_unregister_alg(&crypto_algs[k]);
goto err_algs;
}
void sep_crypto_takedown(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(hash_algs); i++)
crypto_unregister_ahash(&hash_algs[i]);
for (i = 0; i < ARRAY_SIZE(crypto_algs); i++)
crypto_unregister_alg(&crypto_algs[i]);
tasklet_kill(&sep_dev->finish_tasklet);
}
#endif