?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Adding support for MOXA ART SoC. Testing port of linux-2.6.32.60-moxart.
[linux-3.6.7-moxart.git] / drivers / staging / sep / sep_crypto.c
blob34710ce560046f3034ec039d980ea33c0f6beb02
1 /*
2 *
3 * sep_crypto.c - Crypto interface structures
4 *
5 * Copyright(c) 2009-2011 Intel Corporation. All rights reserved.
6 * Contributions(c) 2009-2010 Discretix. All rights reserved.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the Free
10 * Software Foundation; version 2 of the License.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc., 59
19 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 *
21 * CONTACTS:
22 *
23 * Mark Allyn mark.a.allyn@intel.com
24 * Jayant Mangalampalli jayant.mangalampalli@intel.com
25 *
26 * CHANGES:
27 *
28 * 2009.06.26 Initial publish
29 * 2010.09.14 Upgrade to Medfield
30 * 2011.02.22 Enable Kernel Crypto
31 *
32 */
33
34 /* #define DEBUG */
35 #include <linux/init.h>
36 #include <linux/module.h>
37 #include <linux/miscdevice.h>
38 #include <linux/fs.h>
39 #include <linux/cdev.h>
40 #include <linux/kdev_t.h>
41 #include <linux/mutex.h>
42 #include <linux/sched.h>
43 #include <linux/mm.h>
44 #include <linux/poll.h>
45 #include <linux/wait.h>
46 #include <linux/pci.h>
47 #include <linux/pm_runtime.h>
48 #include <linux/err.h>
49 #include <linux/device.h>
50 #include <linux/errno.h>
51 #include <linux/interrupt.h>
52 #include <linux/kernel.h>
53 #include <linux/clk.h>
54 #include <linux/irq.h>
55 #include <linux/io.h>
56 #include <linux/platform_device.h>
57 #include <linux/list.h>
58 #include <linux/dma-mapping.h>
59 #include <linux/delay.h>
60 #include <linux/jiffies.h>
61 #include <linux/workqueue.h>
62 #include <linux/crypto.h>
63 #include <crypto/internal/hash.h>
64 #include <crypto/scatterwalk.h>
65 #include <crypto/sha.h>
66 #include <crypto/md5.h>
67 #include <crypto/aes.h>
68 #include <crypto/des.h>
69 #include <crypto/hash.h>
70 #include "sep_driver_hw_defs.h"
71 #include "sep_driver_config.h"
72 #include "sep_driver_api.h"
73 #include "sep_dev.h"
74 #include "sep_crypto.h"
75
76 #if defined(CONFIG_CRYPTO) || defined(CONFIG_CRYPTO_MODULE)
77
78 /* Globals for queuing */
79 static spinlock_t queue_lock;
80 static struct crypto_queue sep_queue;
81
82 /* Declare of dequeuer */
83 static void sep_dequeuer(void *data);
84
85 /* TESTING */
86 /**
87 * sep_do_callback
88 * @work: pointer to work_struct
89 * This is what is called by the queue; it is generic so that it
90 * can be used by any type of operation as each different callback
91 * function can use the data parameter in its own way
92 */
93 static void sep_do_callback(struct work_struct *work)
94 {
95 struct sep_work_struct *sep_work = container_of(work,
96 struct sep_work_struct, work);
97 if (sep_work != NULL) {
98 (sep_work->callback)(sep_work->data);
99 kfree(sep_work);
100 } else {
101 pr_debug("sep crypto: do callback - NULL container\n");
102 }
103 }
104
105 /**
106 * sep_submit_work
107 * @work_queue: pointer to struct_workqueue
108 * @funct: pointer to function to execute
109 * @data: pointer to data; function will know
110 * how to use it
111 * This is a generic API to submit something to
112 * the queue. The callback function will depend
113 * on what operation is to be done
114 */
115 static int sep_submit_work(struct workqueue_struct *work_queue,
116 void(*funct)(void *),
117 void *data)
118 {
119 struct sep_work_struct *sep_work;
120 int result;
121
122 sep_work = kmalloc(sizeof(struct sep_work_struct), GFP_ATOMIC);
123
124 if (sep_work == NULL) {
125 pr_debug("sep crypto: cant allocate work structure\n");
126 return -ENOMEM;
127 }
128
129 sep_work->callback = funct;
130 sep_work->data = data;
131 INIT_WORK(&sep_work->work, sep_do_callback);
132 result = queue_work(work_queue, &sep_work->work);
133 if (!result) {
134 pr_debug("sep_crypto: queue_work failed\n");
135 return -EINVAL;
136 }
137 return 0;
138 }
139
140 /**
141 * sep_alloc_sg_buf -
142 * @sep: pointer to struct sep_device
143 * @size: total size of area
144 * @block_size: minimum size of chunks
145 * each page is minimum or modulo this size
146 * @returns: pointer to struct scatterlist for new
147 * buffer
148 **/
149 static struct scatterlist *sep_alloc_sg_buf(
150 struct sep_device *sep,
151 size_t size,
152 size_t block_size)
153 {
154 u32 nbr_pages;
155 u32 ct1;
156 void *buf;
157 size_t current_size;
158 size_t real_page_size;
159
160 struct scatterlist *sg, *sg_temp;
161
162 if (size == 0)
163 return NULL;
164
165 dev_dbg(&sep->pdev->dev, "sep alloc sg buf\n");
166
167 current_size = 0;
168 nbr_pages = 0;
169 real_page_size = PAGE_SIZE - (PAGE_SIZE % block_size);
170 /**
171 * The size of each page must be modulo of the operation
172 * block size; increment by the modified page size until
173 * the total size is reached, then you have the number of
174 * pages
175 */
176 while (current_size < size) {
177 current_size += real_page_size;
178 nbr_pages += 1;
179 }
180
181 sg = kmalloc((sizeof(struct scatterlist) * nbr_pages), GFP_ATOMIC);
182 if (!sg) {
183 dev_warn(&sep->pdev->dev, "Cannot allocate page for new sg\n");
184 return NULL;
185 }
186
187 sg_init_table(sg, nbr_pages);
188
189 current_size = 0;
190 sg_temp = sg;
191 for (ct1 = 0; ct1 < nbr_pages; ct1 += 1) {
192 buf = (void *)get_zeroed_page(GFP_ATOMIC);
193 if (!buf) {
194 dev_warn(&sep->pdev->dev,
195 "Cannot allocate page for new buffer\n");
196 kfree(sg);
197 return NULL;
198 }
199
200 sg_set_buf(sg_temp, buf, real_page_size);
201 if ((size - current_size) > real_page_size) {
202 sg_temp->length = real_page_size;
203 current_size += real_page_size;
204 } else {
205 sg_temp->length = (size - current_size);
206 current_size = size;
207 }
208 sg_temp = sg_next(sg);
209 }
210 return sg;
211 }
212
213 /**
214 * sep_free_sg_buf -
215 * @sg: pointer to struct scatterlist; points to area to free
216 */
217 static void sep_free_sg_buf(struct scatterlist *sg)
218 {
219 struct scatterlist *sg_temp = sg;
220 while (sg_temp) {
221 free_page((unsigned long)sg_virt(sg_temp));
222 sg_temp = sg_next(sg_temp);
223 }
224 kfree(sg);
225 }
226
227 /**
228 * sep_copy_sg -
229 * @sep: pointer to struct sep_device
230 * @sg_src: pointer to struct scatterlist for source
231 * @sg_dst: pointer to struct scatterlist for destination
232 * @size: size (in bytes) of data to copy
233 *
234 * Copy data from one scatterlist to another; both must
235 * be the same size
236 */
237 static void sep_copy_sg(
238 struct sep_device *sep,
239 struct scatterlist *sg_src,
240 struct scatterlist *sg_dst,
241 size_t size)
242 {
243 u32 seg_size;
244 u32 in_offset, out_offset;
245
246 u32 count = 0;
247 struct scatterlist *sg_src_tmp = sg_src;
248 struct scatterlist *sg_dst_tmp = sg_dst;
249 in_offset = 0;
250 out_offset = 0;
251
252 dev_dbg(&sep->pdev->dev, "sep copy sg\n");
253
254 if ((sg_src == NULL) || (sg_dst == NULL) || (size == 0))
255 return;
256
257 dev_dbg(&sep->pdev->dev, "sep copy sg not null\n");
258
259 while (count < size) {
260 if ((sg_src_tmp->length - in_offset) >
261 (sg_dst_tmp->length - out_offset))
262 seg_size = sg_dst_tmp->length - out_offset;
263 else
264 seg_size = sg_src_tmp->length - in_offset;
265
266 if (seg_size > (size - count))
267 seg_size = (size = count);
268
269 memcpy(sg_virt(sg_dst_tmp) + out_offset,
270 sg_virt(sg_src_tmp) + in_offset,
271 seg_size);
272
273 in_offset += seg_size;
274 out_offset += seg_size;
275 count += seg_size;
276
277 if (in_offset >= sg_src_tmp->length) {
278 sg_src_tmp = sg_next(sg_src_tmp);
279 in_offset = 0;
280 }
281
282 if (out_offset >= sg_dst_tmp->length) {
283 sg_dst_tmp = sg_next(sg_dst_tmp);
284 out_offset = 0;
285 }
286 }
287 }
288
289 /**
290 * sep_oddball_pages -
291 * @sep: pointer to struct sep_device
292 * @sg: pointer to struct scatterlist - buffer to check
293 * @size: total data size
294 * @blocksize: minimum block size; must be multiples of this size
295 * @to_copy: 1 means do copy, 0 means do not copy
296 * @new_sg: pointer to location to put pointer to new sg area
297 * @returns: 1 if new scatterlist is needed; 0 if not needed;
298 * error value if operation failed
299 *
300 * The SEP device requires all pages to be multiples of the
301 * minimum block size appropriate for the operation
302 * This function check all pages; if any are oddball sizes
303 * (not multiple of block sizes), it creates a new scatterlist.
304 * If the to_copy parameter is set to 1, then a scatter list
305 * copy is performed. The pointer to the new scatterlist is
306 * put into the address supplied by the new_sg parameter; if
307 * no new scatterlist is needed, then a NULL is put into
308 * the location at new_sg.
309 *
310 */
311 static int sep_oddball_pages(
312 struct sep_device *sep,
313 struct scatterlist *sg,
314 size_t data_size,
315 u32 block_size,
316 struct scatterlist **new_sg,
317 u32 do_copy)
318 {
319 struct scatterlist *sg_temp;
320 u32 flag;
321 u32 nbr_pages, page_count;
322
323 dev_dbg(&sep->pdev->dev, "sep oddball\n");
324 if ((sg == NULL) || (data_size == 0) || (data_size < block_size))
325 return 0;
326
327 dev_dbg(&sep->pdev->dev, "sep oddball not null\n");
328 flag = 0;
329 nbr_pages = 0;
330 page_count = 0;
331 sg_temp = sg;
332
333 while (sg_temp) {
334 nbr_pages += 1;
335 sg_temp = sg_next(sg_temp);
336 }
337
338 sg_temp = sg;
339 while ((sg_temp) && (flag == 0)) {
340 page_count += 1;
341 if (sg_temp->length % block_size)
342 flag = 1;
343 else
344 sg_temp = sg_next(sg_temp);
345 }
346
347 /* Do not process if last (or only) page is oddball */
348 if (nbr_pages == page_count)
349 flag = 0;
350
351 if (flag) {
352 dev_dbg(&sep->pdev->dev, "sep oddball processing\n");
353 *new_sg = sep_alloc_sg_buf(sep, data_size, block_size);
354 if (*new_sg == NULL) {
355 dev_warn(&sep->pdev->dev, "cannot allocate new sg\n");
356 return -ENOMEM;
357 }
358
359 if (do_copy)
360 sep_copy_sg(sep, sg, *new_sg, data_size);
361
362 return 1;
363 } else {
364 return 0;
365 }
366 }
367
368 /**
369 * sep_copy_offset_sg -
370 * @sep: pointer to struct sep_device;
371 * @sg: pointer to struct scatterlist
372 * @offset: offset into scatterlist memory
373 * @dst: place to put data
374 * @len: length of data
375 * @returns: number of bytes copies
376 *
377 * This copies data from scatterlist buffer
378 * offset from beginning - it is needed for
379 * handling tail data in hash
380 */
381 static size_t sep_copy_offset_sg(
382 struct sep_device *sep,
383 struct scatterlist *sg,
384 u32 offset,
385 void *dst,
386 u32 len)
387 {
388 size_t page_start;
389 size_t page_end;
390 size_t offset_within_page;
391 size_t length_within_page;
392 size_t length_remaining;
393 size_t current_offset;
394
395 /* Find which page is beginning of segment */
396 page_start = 0;
397 page_end = sg->length;
398 while ((sg) && (offset > page_end)) {
399 page_start += sg->length;
400 sg = sg_next(sg);
401 if (sg)
402 page_end += sg->length;
403 }
404
405 if (sg == NULL)
406 return -ENOMEM;
407
408 offset_within_page = offset - page_start;
409 if ((sg->length - offset_within_page) >= len) {
410 /* All within this page */
411 memcpy(dst, sg_virt(sg) + offset_within_page, len);
412 return len;
413 } else {
414 /* Scattered multiple pages */
415 current_offset = 0;
416 length_remaining = len;
417 while ((sg) && (current_offset < len)) {
418 length_within_page = sg->length - offset_within_page;
419 if (length_within_page >= length_remaining) {
420 memcpy(dst+current_offset,
421 sg_virt(sg) + offset_within_page,
422 length_remaining);
423 length_remaining = 0;
424 current_offset = len;
425 } else {
426 memcpy(dst+current_offset,
427 sg_virt(sg) + offset_within_page,
428 length_within_page);
429 length_remaining -= length_within_page;
430 current_offset += length_within_page;
431 offset_within_page = 0;
432 sg = sg_next(sg);
433 }
434 }
435
436 if (sg == NULL)
437 return -ENOMEM;
438 }
439 return len;
440 }
441
442 /**
443 * partial_overlap -
444 * @src_ptr: source pointer
445 * @dst_ptr: destination pointer
446 * @nbytes: number of bytes
447 * @returns: 0 for success; -1 for failure
448 * We cannot have any partial overlap. Total overlap
449 * where src is the same as dst is okay
450 */
451 static int partial_overlap(void *src_ptr, void *dst_ptr, u32 nbytes)
452 {
453 /* Check for partial overlap */
454 if (src_ptr != dst_ptr) {
455 if (src_ptr < dst_ptr) {
456 if ((src_ptr + nbytes) > dst_ptr)
457 return -EINVAL;
458 } else {
459 if ((dst_ptr + nbytes) > src_ptr)
460 return -EINVAL;
461 }
462 }
463
464 return 0;
465 }
466
467 /* Debug - prints only if DEBUG is defined */
468 static void sep_dump_ivs(struct ablkcipher_request *req, char *reason)
469
470 {
471 unsigned char *cptr;
472 struct sep_aes_internal_context *aes_internal;
473 struct sep_des_internal_context *des_internal;
474 int ct1;
475
476 struct this_task_ctx *ta_ctx;
477 struct crypto_ablkcipher *tfm;
478 struct sep_system_ctx *sctx;
479
480 ta_ctx = ablkcipher_request_ctx(req);
481 tfm = crypto_ablkcipher_reqtfm(req);
482 sctx = crypto_ablkcipher_ctx(tfm);
483
484 dev_dbg(&ta_ctx->sep_used->pdev->dev, "IV DUMP - %s\n", reason);
485 if ((ta_ctx->current_request == DES_CBC) &&
486 (ta_ctx->des_opmode == SEP_DES_CBC)) {
487
488 des_internal = (struct sep_des_internal_context *)
489 sctx->des_private_ctx.ctx_buf;
490 /* print vendor */
491 dev_dbg(&ta_ctx->sep_used->pdev->dev,
492 "sep - vendor iv for DES\n");
493 cptr = (unsigned char *)des_internal->iv_context;
494 for (ct1 = 0; ct1 < crypto_ablkcipher_ivsize(tfm); ct1 += 1)
495 dev_dbg(&ta_ctx->sep_used->pdev->dev,
496 "%02x\n", *(cptr + ct1));
497
498 /* print walk */
499 dev_dbg(&ta_ctx->sep_used->pdev->dev,
500 "sep - walk from kernel crypto iv for DES\n");
501 cptr = (unsigned char *)ta_ctx->walk.iv;
502 for (ct1 = 0; ct1 < crypto_ablkcipher_ivsize(tfm); ct1 += 1)
503 dev_dbg(&ta_ctx->sep_used->pdev->dev,
504 "%02x\n", *(cptr + ct1));
505 } else if ((ta_ctx->current_request == AES_CBC) &&
506 (ta_ctx->aes_opmode == SEP_AES_CBC)) {
507
508 aes_internal = (struct sep_aes_internal_context *)
509 sctx->aes_private_ctx.cbuff;
510 /* print vendor */
511 dev_dbg(&ta_ctx->sep_used->pdev->dev,
512 "sep - vendor iv for AES\n");
513 cptr = (unsigned char *)aes_internal->aes_ctx_iv;
514 for (ct1 = 0; ct1 < crypto_ablkcipher_ivsize(tfm); ct1 += 1)
515 dev_dbg(&ta_ctx->sep_used->pdev->dev,
516 "%02x\n", *(cptr + ct1));
517
518 /* print walk */
519 dev_dbg(&ta_ctx->sep_used->pdev->dev,
520 "sep - walk from kernel crypto iv for AES\n");
521 cptr = (unsigned char *)ta_ctx->walk.iv;
522 for (ct1 = 0; ct1 < crypto_ablkcipher_ivsize(tfm); ct1 += 1)
523 dev_dbg(&ta_ctx->sep_used->pdev->dev,
524 "%02x\n", *(cptr + ct1));
525 }
526 }
527
528 /**
529 * RFC2451: Weak key check
530 * Returns: 1 (weak), 0 (not weak)
531 */
532 static int sep_weak_key(const u8 *key, unsigned int keylen)
533 {
534 static const u8 parity[] = {
535 8, 1, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 2, 8,
536 0, 8, 8, 0, 8, 0, 0, 8, 8,
537 0, 0, 8, 0, 8, 8, 3,
538 0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
539 8, 0, 0, 8, 0, 8, 8, 0, 0,
540 8, 8, 0, 8, 0, 0, 8,
541 0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
542 8, 0, 0, 8, 0, 8, 8, 0, 0,
543 8, 8, 0, 8, 0, 0, 8,
544 8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
545 0, 8, 8, 0, 8, 0, 0, 8, 8,
546 0, 0, 8, 0, 8, 8, 0,
547 0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
548 8, 0, 0, 8, 0, 8, 8, 0, 0,
549 8, 8, 0, 8, 0, 0, 8,
550 8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
551 0, 8, 8, 0, 8, 0, 0, 8, 8,
552 0, 0, 8, 0, 8, 8, 0,
553 8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
554 0, 8, 8, 0, 8, 0, 0, 8, 8,
555 0, 0, 8, 0, 8, 8, 0,
556 4, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
557 8, 5, 0, 8, 0, 8, 8, 0, 0,
558 8, 8, 0, 8, 0, 6, 8,
559 };
560
561 u32 n, w;
562
563 n = parity[key[0]]; n <<= 4;
564 n |= parity[key[1]]; n <<= 4;
565 n |= parity[key[2]]; n <<= 4;
566 n |= parity[key[3]]; n <<= 4;
567 n |= parity[key[4]]; n <<= 4;
568 n |= parity[key[5]]; n <<= 4;
569 n |= parity[key[6]]; n <<= 4;
570 n |= parity[key[7]];
571 w = 0x88888888L;
572
573 /* 1 in 10^10 keys passes this test */
574 if (!((n - (w >> 3)) & w)) {
575 if (n < 0x41415151) {
576 if (n < 0x31312121) {
577 if (n < 0x14141515) {
578 /* 01 01 01 01 01 01 01 01 */
579 if (n == 0x11111111)
580 goto weak;
581 /* 01 1F 01 1F 01 0E 01 0E */
582 if (n == 0x13131212)
583 goto weak;
584 } else {
585 /* 01 E0 01 E0 01 F1 01 F1 */
586 if (n == 0x14141515)
587 goto weak;
588 /* 01 FE 01 FE 01 FE 01 FE */
589 if (n == 0x16161616)
590 goto weak;
591 }
592 } else {
593 if (n < 0x34342525) {
594 /* 1F 01 1F 01 0E 01 0E 01 */
595 if (n == 0x31312121)
596 goto weak;
597 /* 1F 1F 1F 1F 0E 0E 0E 0E (?) */
598 if (n == 0x33332222)
599 goto weak;
600 } else {
601 /* 1F E0 1F E0 0E F1 0E F1 */
602 if (n == 0x34342525)
603 goto weak;
604 /* 1F FE 1F FE 0E FE 0E FE */
605 if (n == 0x36362626)
606 goto weak;
607 }
608 }
609 } else {
610 if (n < 0x61616161) {
611 if (n < 0x44445555) {
612 /* E0 01 E0 01 F1 01 F1 01 */
613 if (n == 0x41415151)
614 goto weak;
615 /* E0 1F E0 1F F1 0E F1 0E */
616 if (n == 0x43435252)
617 goto weak;
618 } else {
619 /* E0 E0 E0 E0 F1 F1 F1 F1 (?) */
620 if (n == 0x44445555)
621 goto weak;
622 /* E0 FE E0 FE F1 FE F1 FE */
623 if (n == 0x46465656)
624 goto weak;
625 }
626 } else {
627 if (n < 0x64646565) {
628 /* FE 01 FE 01 FE 01 FE 01 */
629 if (n == 0x61616161)
630 goto weak;
631 /* FE 1F FE 1F FE 0E FE 0E */
632 if (n == 0x63636262)
633 goto weak;
634 } else {
635 /* FE E0 FE E0 FE F1 FE F1 */
636 if (n == 0x64646565)
637 goto weak;
638 /* FE FE FE FE FE FE FE FE */
639 if (n == 0x66666666)
640 goto weak;
641 }
642 }
643 }
644 }
645 return 0;
646 weak:
647 return 1;
648 }
649 /**
650 * sep_sg_nents
651 */
652 static u32 sep_sg_nents(struct scatterlist *sg)
653 {
654 u32 ct1 = 0;
655 while (sg) {
656 ct1 += 1;
657 sg = sg_next(sg);
658 }
659
660 return ct1;
661 }
662
663 /**
664 * sep_start_msg -
665 * @ta_ctx: pointer to struct this_task_ctx
666 * @returns: offset to place for the next word in the message
667 * Set up pointer in message pool for new message
668 */
669 static u32 sep_start_msg(struct this_task_ctx *ta_ctx)
670 {
671 u32 *word_ptr;
672 ta_ctx->msg_len_words = 2;
673 ta_ctx->msgptr = ta_ctx->msg;
674 memset(ta_ctx->msg, 0, SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
675 ta_ctx->msgptr += sizeof(u32) * 2;
676 word_ptr = (u32 *)ta_ctx->msgptr;
677 *word_ptr = SEP_START_MSG_TOKEN;
678 return sizeof(u32) * 2;
679 }
680
681 /**
682 * sep_end_msg -
683 * @ta_ctx: pointer to struct this_task_ctx
684 * @messages_offset: current message offset
685 * Returns: 0 for success; <0 otherwise
686 * End message; set length and CRC; and
687 * send interrupt to the SEP
688 */
689 static void sep_end_msg(struct this_task_ctx *ta_ctx, u32 msg_offset)
690 {
691 u32 *word_ptr;
692 /* Msg size goes into msg after token */
693 ta_ctx->msg_len_words = msg_offset / sizeof(u32) + 1;
694 word_ptr = (u32 *)ta_ctx->msgptr;
695 word_ptr += 1;
696 *word_ptr = ta_ctx->msg_len_words;
697
698 /* CRC (currently 0) goes at end of msg */
699 word_ptr = (u32 *)(ta_ctx->msgptr + msg_offset);
700 *word_ptr = 0;
701 }
702
703 /**
704 * sep_start_inbound_msg -
705 * @ta_ctx: pointer to struct this_task_ctx
706 * @msg_offset: offset to place for the next word in the message
707 * @returns: 0 for success; error value for failure
708 * Set up pointer in message pool for inbound message
709 */
710 static u32 sep_start_inbound_msg(struct this_task_ctx *ta_ctx, u32 *msg_offset)
711 {
712 u32 *word_ptr;
713 u32 token;
714 u32 error = SEP_OK;
715
716 *msg_offset = sizeof(u32) * 2;
717 word_ptr = (u32 *)ta_ctx->msgptr;
718 token = *word_ptr;
719 ta_ctx->msg_len_words = *(word_ptr + 1);
720
721 if (token != SEP_START_MSG_TOKEN) {
722 error = SEP_INVALID_START;
723 goto end_function;
724 }
725
726 end_function:
727
728 return error;
729 }
730
731 /**
732 * sep_write_msg -
733 * @ta_ctx: pointer to struct this_task_ctx
734 * @in_addr: pointer to start of parameter
735 * @size: size of parameter to copy (in bytes)
736 * @max_size: size to move up offset; SEP mesg is in word sizes
737 * @msg_offset: pointer to current offset (is updated)
738 * @byte_array: flag ti indicate whether endian must be changed
739 * Copies data into the message area from caller
740 */
741 static void sep_write_msg(struct this_task_ctx *ta_ctx, void *in_addr,
742 u32 size, u32 max_size, u32 *msg_offset, u32 byte_array)
743 {
744 u32 *word_ptr;
745 void *void_ptr;
746 void_ptr = ta_ctx->msgptr + *msg_offset;
747 word_ptr = (u32 *)void_ptr;
748 memcpy(void_ptr, in_addr, size);
749 *msg_offset += max_size;
750
751 /* Do we need to manipulate endian? */
752 if (byte_array) {
753 u32 i;
754 for (i = 0; i < ((size + 3) / 4); i += 1)
755 *(word_ptr + i) = CHG_ENDIAN(*(word_ptr + i));
756 }
757 }
758
759 /**
760 * sep_make_header
761 * @ta_ctx: pointer to struct this_task_ctx
762 * @msg_offset: pointer to current offset (is updated)
763 * @op_code: op code to put into message
764 * Puts op code into message and updates offset
765 */
766 static void sep_make_header(struct this_task_ctx *ta_ctx, u32 *msg_offset,
767 u32 op_code)
768 {
769 u32 *word_ptr;
770
771 *msg_offset = sep_start_msg(ta_ctx);
772 word_ptr = (u32 *)(ta_ctx->msgptr + *msg_offset);
773 *word_ptr = op_code;
774 *msg_offset += sizeof(u32);
775 }
776
777
778
779 /**
780 * sep_read_msg -
781 * @ta_ctx: pointer to struct this_task_ctx
782 * @in_addr: pointer to start of parameter
783 * @size: size of parameter to copy (in bytes)
784 * @max_size: size to move up offset; SEP mesg is in word sizes
785 * @msg_offset: pointer to current offset (is updated)
786 * @byte_array: flag ti indicate whether endian must be changed
787 * Copies data out of the message area to caller
788 */
789 static void sep_read_msg(struct this_task_ctx *ta_ctx, void *in_addr,
790 u32 size, u32 max_size, u32 *msg_offset, u32 byte_array)
791 {
792 u32 *word_ptr;
793 void *void_ptr;
794 void_ptr = ta_ctx->msgptr + *msg_offset;
795 word_ptr = (u32 *)void_ptr;
796
797 /* Do we need to manipulate endian? */
798 if (byte_array) {
799 u32 i;
800 for (i = 0; i < ((size + 3) / 4); i += 1)
801 *(word_ptr + i) = CHG_ENDIAN(*(word_ptr + i));
802 }
803
804 memcpy(in_addr, void_ptr, size);
805 *msg_offset += max_size;
806 }
807
808 /**
809 * sep_verify_op -
810 * @ta_ctx: pointer to struct this_task_ctx
811 * @op_code: expected op_code
812 * @msg_offset: pointer to current offset (is updated)
813 * @returns: 0 for success; error for failure
814 */
815 static u32 sep_verify_op(struct this_task_ctx *ta_ctx, u32 op_code,
816 u32 *msg_offset)
817 {
818 u32 error;
819 u32 in_ary[2];
820
821 struct sep_device *sep = ta_ctx->sep_used;
822
823 dev_dbg(&sep->pdev->dev, "dumping return message\n");
824 error = sep_start_inbound_msg(ta_ctx, msg_offset);
825 if (error) {
826 dev_warn(&sep->pdev->dev,
827 "sep_start_inbound_msg error\n");
828 return error;
829 }
830
831 sep_read_msg(ta_ctx, in_ary, sizeof(u32) * 2, sizeof(u32) * 2,
832 msg_offset, 0);
833
834 if (in_ary[0] != op_code) {
835 dev_warn(&sep->pdev->dev,
836 "sep got back wrong opcode\n");
837 dev_warn(&sep->pdev->dev,
838 "got back %x; expected %x\n",
839 in_ary[0], op_code);
840 return SEP_WRONG_OPCODE;
841 }
842
843 if (in_ary[1] != SEP_OK) {
844 dev_warn(&sep->pdev->dev,
845 "sep execution error\n");
846 dev_warn(&sep->pdev->dev,
847 "got back %x; expected %x\n",
848 in_ary[1], SEP_OK);
849 return in_ary[0];
850 }
851
852 return 0;
853 }
854
855 /**
856 * sep_read_context -
857 * @ta_ctx: pointer to struct this_task_ctx
858 * @msg_offset: point to current place in SEP msg; is updated
859 * @dst: pointer to place to put the context
860 * @len: size of the context structure (differs for crypro/hash)
861 * This function reads the context from the msg area
862 * There is a special way the vendor needs to have the maximum
863 * length calculated so that the msg_offset is updated properly;
864 * it skips over some words in the msg area depending on the size
865 * of the context
866 */
867 static void sep_read_context(struct this_task_ctx *ta_ctx, u32 *msg_offset,
868 void *dst, u32 len)
869 {
870 u32 max_length = ((len + 3) / sizeof(u32)) * sizeof(u32);
871 sep_read_msg(ta_ctx, dst, len, max_length, msg_offset, 0);
872 }
873
874 /**
875 * sep_write_context -
876 * @ta_ctx: pointer to struct this_task_ctx
877 * @msg_offset: point to current place in SEP msg; is updated
878 * @src: pointer to the current context
879 * @len: size of the context structure (differs for crypro/hash)
880 * This function writes the context to the msg area
881 * There is a special way the vendor needs to have the maximum
882 * length calculated so that the msg_offset is updated properly;
883 * it skips over some words in the msg area depending on the size
884 * of the context
885 */
886 static void sep_write_context(struct this_task_ctx *ta_ctx, u32 *msg_offset,
887 void *src, u32 len)
888 {
889 u32 max_length = ((len + 3) / sizeof(u32)) * sizeof(u32);
890 sep_write_msg(ta_ctx, src, len, max_length, msg_offset, 0);
891 }
892
893 /**
894 * sep_clear_out -
895 * @ta_ctx: pointer to struct this_task_ctx
896 * Clear out crypto related values in sep device structure
897 * to enable device to be used by anyone; either kernel
898 * crypto or userspace app via middleware
899 */
900 static void sep_clear_out(struct this_task_ctx *ta_ctx)
901 {
902 if (ta_ctx->src_sg_hold) {
903 sep_free_sg_buf(ta_ctx->src_sg_hold);
904 ta_ctx->src_sg_hold = NULL;
905 }
906
907 if (ta_ctx->dst_sg_hold) {
908 sep_free_sg_buf(ta_ctx->dst_sg_hold);
909 ta_ctx->dst_sg_hold = NULL;
910 }
911
912 ta_ctx->src_sg = NULL;
913 ta_ctx->dst_sg = NULL;
914
915 sep_free_dma_table_data_handler(ta_ctx->sep_used, &ta_ctx->dma_ctx);
916
917 if (ta_ctx->i_own_sep) {
918 /**
919 * The following unlocks the sep and makes it available
920 * to any other application
921 * First, null out crypto entries in sep before releasing it
922 */
923 ta_ctx->sep_used->current_hash_req = NULL;
924 ta_ctx->sep_used->current_cypher_req = NULL;
925 ta_ctx->sep_used->current_request = 0;
926 ta_ctx->sep_used->current_hash_stage = 0;
927 ta_ctx->sep_used->ta_ctx = NULL;
928 ta_ctx->sep_used->in_kernel = 0;
929
930 ta_ctx->call_status.status = 0;
931
932 /* Remove anything confidential */
933 memset(ta_ctx->sep_used->shared_addr, 0,
934 SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
935
936 sep_queue_status_remove(ta_ctx->sep_used, &ta_ctx->queue_elem);
937
938 #ifdef SEP_ENABLE_RUNTIME_PM
939 ta_ctx->sep_used->in_use = 0;
940 pm_runtime_mark_last_busy(&ta_ctx->sep_used->pdev->dev);
941 pm_runtime_put_autosuspend(&ta_ctx->sep_used->pdev->dev);
942 #endif
943
944 clear_bit(SEP_WORKING_LOCK_BIT,
945 &ta_ctx->sep_used->in_use_flags);
946 ta_ctx->sep_used->pid_doing_transaction = 0;
947
948 dev_dbg(&ta_ctx->sep_used->pdev->dev,
949 "[PID%d] waking up next transaction\n",
950 current->pid);
951
952 clear_bit(SEP_TRANSACTION_STARTED_LOCK_BIT,
953 &ta_ctx->sep_used->in_use_flags);
954 wake_up(&ta_ctx->sep_used->event_transactions);
955
956 ta_ctx->i_own_sep = 0;
957 }
958 }
959
960 /**
961 * Release crypto infrastructure from EINPROGRESS and
962 * clear sep_dev so that SEP is available to anyone
963 */
964 static void sep_crypto_release(struct sep_system_ctx *sctx,
965 struct this_task_ctx *ta_ctx, u32 error)
966 {
967 struct ahash_request *hash_req = ta_ctx->current_hash_req;
968 struct ablkcipher_request *cypher_req =
969 ta_ctx->current_cypher_req;
970 struct sep_device *sep = ta_ctx->sep_used;
971
972 sep_clear_out(ta_ctx);
973
974 /**
975 * This may not yet exist depending when we
976 * chose to bail out. If it does exist, set
977 * it to 1
978 */
979 if (ta_ctx->are_we_done_yet != NULL)
980 *ta_ctx->are_we_done_yet = 1;
981
982 if (cypher_req != NULL) {
983 if ((sctx->key_sent == 1) ||
984 ((error != 0) && (error != -EINPROGRESS))) {
985 if (cypher_req->base.complete == NULL) {
986 dev_dbg(&sep->pdev->dev,
987 "release is null for cypher!");
988 } else {
989 cypher_req->base.complete(
990 &cypher_req->base, error);
991 }
992 }
993 }
994
995 if (hash_req != NULL) {
996 if (hash_req->base.complete == NULL) {
997 dev_dbg(&sep->pdev->dev,
998 "release is null for hash!");
999 } else {
1000 hash_req->base.complete(
1001 &hash_req->base, error);
1002 }
1003 }
1004 }
1005
1006 /**
1007 * This is where we grab the sep itself and tell it to do something.
1008 * It will sleep if the sep is currently busy
1009 * and it will return 0 if sep is now ours; error value if there
1010 * were problems
1011 */
1012 static int sep_crypto_take_sep(struct this_task_ctx *ta_ctx)
1013 {
1014 struct sep_device *sep = ta_ctx->sep_used;
1015 int result;
1016 struct sep_msgarea_hdr *my_msg_header;
1017
1018 my_msg_header = (struct sep_msgarea_hdr *)ta_ctx->msg;
1019
1020 /* add to status queue */
1021 ta_ctx->queue_elem = sep_queue_status_add(sep, my_msg_header->opcode,
1022 ta_ctx->nbytes, current->pid,
1023 current->comm, sizeof(current->comm));
1024
1025 if (!ta_ctx->queue_elem) {
1026 dev_dbg(&sep->pdev->dev,
1027 "[PID%d] updating queue status error\n", current->pid);
1028 return -EINVAL;
1029 }
1030
1031 /* get the device; this can sleep */
1032 result = sep_wait_transaction(sep);
1033 if (result)
1034 return result;
1035
1036 if (sep_dev->power_save_setup == 1)
1037 pm_runtime_get_sync(&sep_dev->pdev->dev);
1038
1039 /* Copy in the message */
1040 memcpy(sep->shared_addr, ta_ctx->msg,
1041 SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
1042
1043 /* Copy in the dcb information if there is any */
1044 if (ta_ctx->dcb_region) {
1045 result = sep_activate_dcb_dmatables_context(sep,
1046 &ta_ctx->dcb_region, &ta_ctx->dmatables_region,
1047 ta_ctx->dma_ctx);
1048 if (result)
1049 return result;
1050 }
1051
1052 /* Mark the device so we know how to finish the job in the tasklet */
1053 if (ta_ctx->current_hash_req)
1054 sep->current_hash_req = ta_ctx->current_hash_req;
1055 else
1056 sep->current_cypher_req = ta_ctx->current_cypher_req;
1057
1058 sep->current_request = ta_ctx->current_request;
1059 sep->current_hash_stage = ta_ctx->current_hash_stage;
1060 sep->ta_ctx = ta_ctx;
1061 sep->in_kernel = 1;
1062 ta_ctx->i_own_sep = 1;
1063
1064 /* need to set bit first to avoid race condition with interrupt */
1065 set_bit(SEP_LEGACY_SENDMSG_DONE_OFFSET, &ta_ctx->call_status.status);
1066
1067 result = sep_send_command_handler(sep);
1068
1069 dev_dbg(&sep->pdev->dev, "[PID%d]: sending command to the sep\n",
1070 current->pid);
1071
1072 if (!result)
1073 dev_dbg(&sep->pdev->dev, "[PID%d]: command sent okay\n",
1074 current->pid);
1075 else {
1076 dev_dbg(&sep->pdev->dev, "[PID%d]: cant send command\n",
1077 current->pid);
1078 clear_bit(SEP_LEGACY_SENDMSG_DONE_OFFSET,
1079 &ta_ctx->call_status.status);
1080 }
1081
1082 return result;
1083 }
1084
1085 /**
1086 * This function sets things up for a crypto data block process
1087 * This does all preparation, but does not try to grab the
1088 * sep
1089 * @req: pointer to struct ablkcipher_request
1090 * returns: 0 if all went well, non zero if error
1091 */
1092 static int sep_crypto_block_data(struct ablkcipher_request *req)
1093 {
1094
1095 int int_error;
1096 u32 msg_offset;
1097 static u32 msg[10];
1098 void *src_ptr;
1099 void *dst_ptr;
1100
1101 static char small_buf[100];
1102 ssize_t copy_result;
1103 int result;
1104
1105 struct scatterlist *new_sg;
1106 struct this_task_ctx *ta_ctx;
1107 struct crypto_ablkcipher *tfm;
1108 struct sep_system_ctx *sctx;
1109
1110 struct sep_des_internal_context *des_internal;
1111 struct sep_aes_internal_context *aes_internal;
1112
1113 ta_ctx = ablkcipher_request_ctx(req);
1114 tfm = crypto_ablkcipher_reqtfm(req);
1115 sctx = crypto_ablkcipher_ctx(tfm);
1116
1117 /* start the walk on scatterlists */
1118 ablkcipher_walk_init(&ta_ctx->walk, req->src, req->dst, req->nbytes);
1119 dev_dbg(&ta_ctx->sep_used->pdev->dev, "sep crypto block data size of %x\n",
1120 req->nbytes);
1121
1122 int_error = ablkcipher_walk_phys(req, &ta_ctx->walk);
1123 if (int_error) {
1124 dev_warn(&ta_ctx->sep_used->pdev->dev, "walk phys error %x\n",
1125 int_error);
1126 return -ENOMEM;
1127 }
1128
1129 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1130 "crypto block: src is %lx dst is %lx\n",
1131 (unsigned long)req->src, (unsigned long)req->dst);
1132
1133 /* Make sure all pages are even block */
1134 int_error = sep_oddball_pages(ta_ctx->sep_used, req->src,
1135 req->nbytes, ta_ctx->walk.blocksize, &new_sg, 1);
1136
1137 if (int_error < 0) {
1138 dev_warn(&ta_ctx->sep_used->pdev->dev, "oddball page error\n");
1139 return -ENOMEM;
1140 } else if (int_error == 1) {
1141 ta_ctx->src_sg = new_sg;
1142 ta_ctx->src_sg_hold = new_sg;
1143 } else {
1144 ta_ctx->src_sg = req->src;
1145 ta_ctx->src_sg_hold = NULL;
1146 }
1147
1148 int_error = sep_oddball_pages(ta_ctx->sep_used, req->dst,
1149 req->nbytes, ta_ctx->walk.blocksize, &new_sg, 0);
1150
1151 if (int_error < 0) {
1152 dev_warn(&ta_ctx->sep_used->pdev->dev, "walk phys error %x\n",
1153 int_error);
1154 return -ENOMEM;
1155 } else if (int_error == 1) {
1156 ta_ctx->dst_sg = new_sg;
1157 ta_ctx->dst_sg_hold = new_sg;
1158 } else {
1159 ta_ctx->dst_sg = req->dst;
1160 ta_ctx->dst_sg_hold = NULL;
1161 }
1162
1163 /* set nbytes for queue status */
1164 ta_ctx->nbytes = req->nbytes;
1165
1166 /* Key already done; this is for data */
1167 dev_dbg(&ta_ctx->sep_used->pdev->dev, "sending data\n");
1168
1169 /* check for valid data and proper spacing */
1170 src_ptr = sg_virt(ta_ctx->src_sg);
1171 dst_ptr = sg_virt(ta_ctx->dst_sg);
1172
1173 if (!src_ptr || !dst_ptr ||
1174 (ta_ctx->current_cypher_req->nbytes %
1175 crypto_ablkcipher_blocksize(tfm))) {
1176
1177 dev_warn(&ta_ctx->sep_used->pdev->dev,
1178 "cipher block size odd\n");
1179 dev_warn(&ta_ctx->sep_used->pdev->dev,
1180 "cipher block size is %x\n",
1181 crypto_ablkcipher_blocksize(tfm));
1182 dev_warn(&ta_ctx->sep_used->pdev->dev,
1183 "cipher data size is %x\n",
1184 ta_ctx->current_cypher_req->nbytes);
1185 return -EINVAL;
1186 }
1187
1188 if (partial_overlap(src_ptr, dst_ptr,
1189 ta_ctx->current_cypher_req->nbytes)) {
1190 dev_warn(&ta_ctx->sep_used->pdev->dev,
1191 "block partial overlap\n");
1192 return -EINVAL;
1193 }
1194
1195 /* Put together the message */
1196 sep_make_header(ta_ctx, &msg_offset, ta_ctx->block_opcode);
1197
1198 /* If des, and size is 1 block, put directly in msg */
1199 if ((ta_ctx->block_opcode == SEP_DES_BLOCK_OPCODE) &&
1200 (req->nbytes == crypto_ablkcipher_blocksize(tfm))) {
1201
1202 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1203 "writing out one block des\n");
1204
1205 copy_result = sg_copy_to_buffer(
1206 ta_ctx->src_sg, sep_sg_nents(ta_ctx->src_sg),
1207 small_buf, crypto_ablkcipher_blocksize(tfm));
1208
1209 if (copy_result != crypto_ablkcipher_blocksize(tfm)) {
1210 dev_warn(&ta_ctx->sep_used->pdev->dev,
1211 "des block copy faild\n");
1212 return -ENOMEM;
1213 }
1214
1215 /* Put data into message */
1216 sep_write_msg(ta_ctx, small_buf,
1217 crypto_ablkcipher_blocksize(tfm),
1218 crypto_ablkcipher_blocksize(tfm) * 2,
1219 &msg_offset, 1);
1220
1221 /* Put size into message */
1222 sep_write_msg(ta_ctx, &req->nbytes,
1223 sizeof(u32), sizeof(u32), &msg_offset, 0);
1224 } else {
1225 /* Otherwise, fill out dma tables */
1226 ta_ctx->dcb_input_data.app_in_address = src_ptr;
1227 ta_ctx->dcb_input_data.data_in_size = req->nbytes;
1228 ta_ctx->dcb_input_data.app_out_address = dst_ptr;
1229 ta_ctx->dcb_input_data.block_size =
1230 crypto_ablkcipher_blocksize(tfm);
1231 ta_ctx->dcb_input_data.tail_block_size = 0;
1232 ta_ctx->dcb_input_data.is_applet = 0;
1233 ta_ctx->dcb_input_data.src_sg = ta_ctx->src_sg;
1234 ta_ctx->dcb_input_data.dst_sg = ta_ctx->dst_sg;
1235
1236 result = sep_create_dcb_dmatables_context_kernel(
1237 ta_ctx->sep_used,
1238 &ta_ctx->dcb_region,
1239 &ta_ctx->dmatables_region,
1240 &ta_ctx->dma_ctx,
1241 &ta_ctx->dcb_input_data,
1242 1);
1243 if (result) {
1244 dev_warn(&ta_ctx->sep_used->pdev->dev,
1245 "crypto dma table create failed\n");
1246 return -EINVAL;
1247 }
1248
1249 /* Portion of msg is nulled (no data) */
1250 msg[0] = (u32)0;
1251 msg[1] = (u32)0;
1252 msg[2] = (u32)0;
1253 msg[3] = (u32)0;
1254 msg[4] = (u32)0;
1255 sep_write_msg(ta_ctx, (void *)msg, sizeof(u32) * 5,
1256 sizeof(u32) * 5, &msg_offset, 0);
1257 }
1258
1259 /**
1260 * Before we write the message, we need to overwrite the
1261 * vendor's IV with the one from our own ablkcipher walk
1262 * iv because this is needed for dm-crypt
1263 */
1264 sep_dump_ivs(req, "sending data block to sep\n");
1265 if ((ta_ctx->current_request == DES_CBC) &&
1266 (ta_ctx->des_opmode == SEP_DES_CBC)) {
1267
1268 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1269 "overwrite vendor iv on DES\n");
1270 des_internal = (struct sep_des_internal_context *)
1271 sctx->des_private_ctx.ctx_buf;
1272 memcpy((void *)des_internal->iv_context,
1273 ta_ctx->walk.iv, crypto_ablkcipher_ivsize(tfm));
1274 } else if ((ta_ctx->current_request == AES_CBC) &&
1275 (ta_ctx->aes_opmode == SEP_AES_CBC)) {
1276
1277 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1278 "overwrite vendor iv on AES\n");
1279 aes_internal = (struct sep_aes_internal_context *)
1280 sctx->aes_private_ctx.cbuff;
1281 memcpy((void *)aes_internal->aes_ctx_iv,
1282 ta_ctx->walk.iv, crypto_ablkcipher_ivsize(tfm));
1283 }
1284
1285 /* Write context into message */
1286 if (ta_ctx->block_opcode == SEP_DES_BLOCK_OPCODE) {
1287 sep_write_context(ta_ctx, &msg_offset,
1288 &sctx->des_private_ctx,
1289 sizeof(struct sep_des_private_context));
1290 } else {
1291 sep_write_context(ta_ctx, &msg_offset,
1292 &sctx->aes_private_ctx,
1293 sizeof(struct sep_aes_private_context));
1294 }
1295
1296 /* conclude message */
1297 sep_end_msg(ta_ctx, msg_offset);
1298
1299 /* Parent (caller) is now ready to tell the sep to do ahead */
1300 return 0;
1301 }
1302
1303
1304 /**
1305 * This function sets things up for a crypto key submit process
1306 * This does all preparation, but does not try to grab the
1307 * sep
1308 * @req: pointer to struct ablkcipher_request
1309 * returns: 0 if all went well, non zero if error
1310 */
1311 static int sep_crypto_send_key(struct ablkcipher_request *req)
1312 {
1313
1314 int int_error;
1315 u32 msg_offset;
1316 static u32 msg[10];
1317
1318 u32 max_length;
1319 struct this_task_ctx *ta_ctx;
1320 struct crypto_ablkcipher *tfm;
1321 struct sep_system_ctx *sctx;
1322
1323 ta_ctx = ablkcipher_request_ctx(req);
1324 tfm = crypto_ablkcipher_reqtfm(req);
1325 sctx = crypto_ablkcipher_ctx(tfm);
1326
1327 dev_dbg(&ta_ctx->sep_used->pdev->dev, "sending key\n");
1328
1329 /* start the walk on scatterlists */
1330 ablkcipher_walk_init(&ta_ctx->walk, req->src, req->dst, req->nbytes);
1331 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1332 "sep crypto block data size of %x\n", req->nbytes);
1333
1334 int_error = ablkcipher_walk_phys(req, &ta_ctx->walk);
1335 if (int_error) {
1336 dev_warn(&ta_ctx->sep_used->pdev->dev, "walk phys error %x\n",
1337 int_error);
1338 return -ENOMEM;
1339 }
1340
1341 /* check iv */
1342 if ((ta_ctx->current_request == DES_CBC) &&
1343 (ta_ctx->des_opmode == SEP_DES_CBC)) {
1344 if (!ta_ctx->walk.iv) {
1345 dev_warn(&ta_ctx->sep_used->pdev->dev, "no iv found\n");
1346 return -EINVAL;
1347 }
1348
1349 memcpy(ta_ctx->iv, ta_ctx->walk.iv, SEP_DES_IV_SIZE_BYTES);
1350 }
1351
1352 if ((ta_ctx->current_request == AES_CBC) &&
1353 (ta_ctx->aes_opmode == SEP_AES_CBC)) {
1354 if (!ta_ctx->walk.iv) {
1355 dev_warn(&ta_ctx->sep_used->pdev->dev, "no iv found\n");
1356 return -EINVAL;
1357 }
1358
1359 memcpy(ta_ctx->iv, ta_ctx->walk.iv, SEP_AES_IV_SIZE_BYTES);
1360 }
1361
1362 /* put together message to SEP */
1363 /* Start with op code */
1364 sep_make_header(ta_ctx, &msg_offset, ta_ctx->init_opcode);
1365
1366 /* now deal with IV */
1367 if (ta_ctx->init_opcode == SEP_DES_INIT_OPCODE) {
1368 if (ta_ctx->des_opmode == SEP_DES_CBC) {
1369 sep_write_msg(ta_ctx, ta_ctx->iv,
1370 SEP_DES_IV_SIZE_BYTES, sizeof(u32) * 4,
1371 &msg_offset, 1);
1372 } else {
1373 /* Skip if ECB */
1374 msg_offset += 4 * sizeof(u32);
1375 }
1376 } else {
1377 max_length = ((SEP_AES_IV_SIZE_BYTES + 3) /
1378 sizeof(u32)) * sizeof(u32);
1379 if (ta_ctx->aes_opmode == SEP_AES_CBC) {
1380 sep_write_msg(ta_ctx, ta_ctx->iv,
1381 SEP_AES_IV_SIZE_BYTES, max_length,
1382 &msg_offset, 1);
1383 } else {
1384 /* Skip if ECB */
1385 msg_offset += max_length;
1386 }
1387 }
1388
1389 /* load the key */
1390 if (ta_ctx->init_opcode == SEP_DES_INIT_OPCODE) {
1391 sep_write_msg(ta_ctx, (void *)&sctx->key.des.key1,
1392 sizeof(u32) * 8, sizeof(u32) * 8,
1393 &msg_offset, 1);
1394
1395 msg[0] = (u32)sctx->des_nbr_keys;
1396 msg[1] = (u32)ta_ctx->des_encmode;
1397 msg[2] = (u32)ta_ctx->des_opmode;
1398
1399 sep_write_msg(ta_ctx, (void *)msg,
1400 sizeof(u32) * 3, sizeof(u32) * 3,
1401 &msg_offset, 0);
1402 } else {
1403 sep_write_msg(ta_ctx, (void *)&sctx->key.aes,
1404 sctx->keylen,
1405 SEP_AES_MAX_KEY_SIZE_BYTES,
1406 &msg_offset, 1);
1407
1408 msg[0] = (u32)sctx->aes_key_size;
1409 msg[1] = (u32)ta_ctx->aes_encmode;
1410 msg[2] = (u32)ta_ctx->aes_opmode;
1411 msg[3] = (u32)0; /* Secret key is not used */
1412 sep_write_msg(ta_ctx, (void *)msg,
1413 sizeof(u32) * 4, sizeof(u32) * 4,
1414 &msg_offset, 0);
1415 }
1416
1417 /* conclude message */
1418 sep_end_msg(ta_ctx, msg_offset);
1419
1420 /* Parent (caller) is now ready to tell the sep to do ahead */
1421 return 0;
1422 }
1423
1424
1425 /* This needs to be run as a work queue as it can be put asleep */
1426 static void sep_crypto_block(void *data)
1427 {
1428 unsigned long end_time;
1429
1430 int result;
1431
1432 struct ablkcipher_request *req;
1433 struct this_task_ctx *ta_ctx;
1434 struct crypto_ablkcipher *tfm;
1435 struct sep_system_ctx *sctx;
1436 int are_we_done_yet;
1437
1438 req = (struct ablkcipher_request *)data;
1439 ta_ctx = ablkcipher_request_ctx(req);
1440 tfm = crypto_ablkcipher_reqtfm(req);
1441 sctx = crypto_ablkcipher_ctx(tfm);
1442
1443 ta_ctx->are_we_done_yet = &are_we_done_yet;
1444
1445 pr_debug("sep_crypto_block\n");
1446 pr_debug("tfm is %p sctx is %p ta_ctx is %p\n",
1447 tfm, sctx, ta_ctx);
1448 pr_debug("key_sent is %d\n", sctx->key_sent);
1449
1450 /* do we need to send the key */
1451 if (sctx->key_sent == 0) {
1452 are_we_done_yet = 0;
1453 result = sep_crypto_send_key(req); /* prep to send key */
1454 if (result != 0) {
1455 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1456 "could not prep key %x\n", result);
1457 sep_crypto_release(sctx, ta_ctx, result);
1458 return;
1459 }
1460
1461 result = sep_crypto_take_sep(ta_ctx);
1462 if (result) {
1463 dev_warn(&ta_ctx->sep_used->pdev->dev,
1464 "sep_crypto_take_sep for key send failed\n");
1465 sep_crypto_release(sctx, ta_ctx, result);
1466 return;
1467 }
1468
1469 /* now we sit and wait up to a fixed time for completion */
1470 end_time = jiffies + (WAIT_TIME * HZ);
1471 while ((time_before(jiffies, end_time)) &&
1472 (are_we_done_yet == 0))
1473 schedule();
1474
1475 /* Done waiting; still not done yet? */
1476 if (are_we_done_yet == 0) {
1477 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1478 "Send key job never got done\n");
1479 sep_crypto_release(sctx, ta_ctx, -EINVAL);
1480 return;
1481 }
1482
1483 /* Set the key sent variable so this can be skipped later */
1484 sctx->key_sent = 1;
1485 }
1486
1487 /* Key sent (or maybe not if we did not have to), now send block */
1488 are_we_done_yet = 0;
1489
1490 result = sep_crypto_block_data(req);
1491
1492 if (result != 0) {
1493 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1494 "could prep not send block %x\n", result);
1495 sep_crypto_release(sctx, ta_ctx, result);
1496 return;
1497 }
1498
1499 result = sep_crypto_take_sep(ta_ctx);
1500 if (result) {
1501 dev_warn(&ta_ctx->sep_used->pdev->dev,
1502 "sep_crypto_take_sep for block send failed\n");
1503 sep_crypto_release(sctx, ta_ctx, result);
1504 return;
1505 }
1506
1507 /* now we sit and wait up to a fixed time for completion */
1508 end_time = jiffies + (WAIT_TIME * HZ);
1509 while ((time_before(jiffies, end_time)) && (are_we_done_yet == 0))
1510 schedule();
1511
1512 /* Done waiting; still not done yet? */
1513 if (are_we_done_yet == 0) {
1514 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1515 "Send block job never got done\n");
1516 sep_crypto_release(sctx, ta_ctx, -EINVAL);
1517 return;
1518 }
1519
1520 /* That's it; entire thing done, get out of queue */
1521
1522 pr_debug("crypto_block leaving\n");
1523 pr_debug("tfm is %p sctx is %p ta_ctx is %p\n", tfm, sctx, ta_ctx);
1524 }
1525
1526 /**
1527 * Post operation (after interrupt) for crypto block
1528 */
1529 static u32 crypto_post_op(struct sep_device *sep)
1530 {
1531 /* HERE */
1532 u32 u32_error;
1533 u32 msg_offset;
1534
1535 ssize_t copy_result;
1536 static char small_buf[100];
1537
1538 struct ablkcipher_request *req;
1539 struct this_task_ctx *ta_ctx;
1540 struct sep_system_ctx *sctx;
1541 struct crypto_ablkcipher *tfm;
1542
1543 struct sep_des_internal_context *des_internal;
1544 struct sep_aes_internal_context *aes_internal;
1545
1546 if (!sep->current_cypher_req)
1547 return -EINVAL;
1548
1549 /* hold req since we need to submit work after clearing sep */
1550 req = sep->current_cypher_req;
1551
1552 ta_ctx = ablkcipher_request_ctx(sep->current_cypher_req);
1553 tfm = crypto_ablkcipher_reqtfm(sep->current_cypher_req);
1554 sctx = crypto_ablkcipher_ctx(tfm);
1555
1556 pr_debug("crypto_post op\n");
1557 pr_debug("key_sent is %d tfm is %p sctx is %p ta_ctx is %p\n",
1558 sctx->key_sent, tfm, sctx, ta_ctx);
1559
1560 dev_dbg(&ta_ctx->sep_used->pdev->dev, "crypto post_op\n");
1561 dev_dbg(&ta_ctx->sep_used->pdev->dev, "crypto post_op message dump\n");
1562
1563 /* first bring msg from shared area to local area */
1564 memcpy(ta_ctx->msg, sep->shared_addr,
1565 SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
1566
1567 /* Is this the result of performing init (key to SEP */
1568 if (sctx->key_sent == 0) {
1569
1570 /* Did SEP do it okay */
1571 u32_error = sep_verify_op(ta_ctx, ta_ctx->init_opcode,
1572 &msg_offset);
1573 if (u32_error) {
1574 dev_warn(&ta_ctx->sep_used->pdev->dev,
1575 "aes init error %x\n", u32_error);
1576 sep_crypto_release(sctx, ta_ctx, u32_error);
1577 return u32_error;
1578 }
1579
1580 /* Read Context */
1581 if (ta_ctx->init_opcode == SEP_DES_INIT_OPCODE) {
1582 sep_read_context(ta_ctx, &msg_offset,
1583 &sctx->des_private_ctx,
1584 sizeof(struct sep_des_private_context));
1585 } else {
1586 sep_read_context(ta_ctx, &msg_offset,
1587 &sctx->aes_private_ctx,
1588 sizeof(struct sep_aes_private_context));
1589 }
1590
1591 sep_dump_ivs(req, "after sending key to sep\n");
1592
1593 /* key sent went okay; release sep, and set are_we_done_yet */
1594 sctx->key_sent = 1;
1595 sep_crypto_release(sctx, ta_ctx, -EINPROGRESS);
1596
1597 } else {
1598
1599 /**
1600 * This is the result of a block request
1601 */
1602 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1603 "crypto_post_op block response\n");
1604
1605 u32_error = sep_verify_op(ta_ctx, ta_ctx->block_opcode,
1606 &msg_offset);
1607
1608 if (u32_error) {
1609 dev_warn(&ta_ctx->sep_used->pdev->dev,
1610 "sep block error %x\n", u32_error);
1611 sep_crypto_release(sctx, ta_ctx, u32_error);
1612 return -EINVAL;
1613 }
1614
1615 if (ta_ctx->block_opcode == SEP_DES_BLOCK_OPCODE) {
1616
1617 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1618 "post op for DES\n");
1619
1620 /* special case for 1 block des */
1621 if (sep->current_cypher_req->nbytes ==
1622 crypto_ablkcipher_blocksize(tfm)) {
1623
1624 sep_read_msg(ta_ctx, small_buf,
1625 crypto_ablkcipher_blocksize(tfm),
1626 crypto_ablkcipher_blocksize(tfm) * 2,
1627 &msg_offset, 1);
1628
1629 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1630 "reading in block des\n");
1631
1632 copy_result = sg_copy_from_buffer(
1633 ta_ctx->dst_sg,
1634 sep_sg_nents(ta_ctx->dst_sg),
1635 small_buf,
1636 crypto_ablkcipher_blocksize(tfm));
1637
1638 if (copy_result !=
1639 crypto_ablkcipher_blocksize(tfm)) {
1640
1641 dev_warn(&ta_ctx->sep_used->pdev->dev,
1642 "des block copy faild\n");
1643 sep_crypto_release(sctx, ta_ctx,
1644 -ENOMEM);
1645 return -ENOMEM;
1646 }
1647 }
1648
1649 /* Read Context */
1650 sep_read_context(ta_ctx, &msg_offset,
1651 &sctx->des_private_ctx,
1652 sizeof(struct sep_des_private_context));
1653 } else {
1654
1655 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1656 "post op for AES\n");
1657
1658 /* Skip the MAC Output */
1659 msg_offset += (sizeof(u32) * 4);
1660
1661 /* Read Context */
1662 sep_read_context(ta_ctx, &msg_offset,
1663 &sctx->aes_private_ctx,
1664 sizeof(struct sep_aes_private_context));
1665 }
1666
1667 /* Copy to correct sg if this block had oddball pages */
1668 if (ta_ctx->dst_sg_hold)
1669 sep_copy_sg(ta_ctx->sep_used,
1670 ta_ctx->dst_sg,
1671 ta_ctx->current_cypher_req->dst,
1672 ta_ctx->current_cypher_req->nbytes);
1673
1674 /**
1675 * Copy the iv's back to the walk.iv
1676 * This is required for dm_crypt
1677 */
1678 sep_dump_ivs(req, "got data block from sep\n");
1679 if ((ta_ctx->current_request == DES_CBC) &&
1680 (ta_ctx->des_opmode == SEP_DES_CBC)) {
1681
1682 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1683 "returning result iv to walk on DES\n");
1684 des_internal = (struct sep_des_internal_context *)
1685 sctx->des_private_ctx.ctx_buf;
1686 memcpy(ta_ctx->walk.iv,
1687 (void *)des_internal->iv_context,
1688 crypto_ablkcipher_ivsize(tfm));
1689 } else if ((ta_ctx->current_request == AES_CBC) &&
1690 (ta_ctx->aes_opmode == SEP_AES_CBC)) {
1691
1692 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1693 "returning result iv to walk on AES\n");
1694 aes_internal = (struct sep_aes_internal_context *)
1695 sctx->aes_private_ctx.cbuff;
1696 memcpy(ta_ctx->walk.iv,
1697 (void *)aes_internal->aes_ctx_iv,
1698 crypto_ablkcipher_ivsize(tfm));
1699 }
1700
1701 /* finished, release everything */
1702 sep_crypto_release(sctx, ta_ctx, 0);
1703 }
1704 pr_debug("crypto_post_op done\n");
1705 pr_debug("key_sent is %d tfm is %p sctx is %p ta_ctx is %p\n",
1706 sctx->key_sent, tfm, sctx, ta_ctx);
1707
1708 return 0;
1709 }
1710
1711 static u32 hash_init_post_op(struct sep_device *sep)
1712 {
1713 u32 u32_error;
1714 u32 msg_offset;
1715 struct crypto_ahash *tfm = crypto_ahash_reqtfm(sep->current_hash_req);
1716 struct this_task_ctx *ta_ctx = ahash_request_ctx(sep->current_hash_req);
1717 struct sep_system_ctx *sctx = crypto_ahash_ctx(tfm);
1718 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1719 "hash init post op\n");
1720
1721 /* first bring msg from shared area to local area */
1722 memcpy(ta_ctx->msg, sep->shared_addr,
1723 SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
1724
1725 u32_error = sep_verify_op(ta_ctx, SEP_HASH_INIT_OPCODE,
1726 &msg_offset);
1727
1728 if (u32_error) {
1729 dev_warn(&ta_ctx->sep_used->pdev->dev, "hash init error %x\n",
1730 u32_error);
1731 sep_crypto_release(sctx, ta_ctx, u32_error);
1732 return u32_error;
1733 }
1734
1735 /* Read Context */
1736 sep_read_context(ta_ctx, &msg_offset,
1737 &sctx->hash_private_ctx,
1738 sizeof(struct sep_hash_private_context));
1739
1740 /* Signal to crypto infrastructure and clear out */
1741 dev_dbg(&ta_ctx->sep_used->pdev->dev, "hash init post op done\n");
1742 sep_crypto_release(sctx, ta_ctx, 0);
1743 return 0;
1744 }
1745
1746 static u32 hash_update_post_op(struct sep_device *sep)
1747 {
1748 u32 u32_error;
1749 u32 msg_offset;
1750 struct crypto_ahash *tfm = crypto_ahash_reqtfm(sep->current_hash_req);
1751 struct this_task_ctx *ta_ctx = ahash_request_ctx(sep->current_hash_req);
1752 struct sep_system_ctx *sctx = crypto_ahash_ctx(tfm);
1753 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1754 "hash update post op\n");
1755
1756 /* first bring msg from shared area to local area */
1757 memcpy(ta_ctx->msg, sep->shared_addr,
1758 SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
1759
1760 u32_error = sep_verify_op(ta_ctx, SEP_HASH_UPDATE_OPCODE,
1761 &msg_offset);
1762
1763 if (u32_error) {
1764 dev_warn(&ta_ctx->sep_used->pdev->dev, "hash init error %x\n",
1765 u32_error);
1766 sep_crypto_release(sctx, ta_ctx, u32_error);
1767 return u32_error;
1768 }
1769
1770 /* Read Context */
1771 sep_read_context(ta_ctx, &msg_offset,
1772 &sctx->hash_private_ctx,
1773 sizeof(struct sep_hash_private_context));
1774
1775 /**
1776 * Following is only for finup; if we just completed the
1777 * data portion of finup, we now need to kick off the
1778 * finish portion of finup.
1779 */
1780
1781 if (ta_ctx->sep_used->current_hash_stage == HASH_FINUP_DATA) {
1782
1783 /* first reset stage to HASH_FINUP_FINISH */
1784 ta_ctx->sep_used->current_hash_stage = HASH_FINUP_FINISH;
1785
1786 /* now enqueue the finish operation */
1787 spin_lock_irq(&queue_lock);
1788 u32_error = crypto_enqueue_request(&sep_queue,
1789 &ta_ctx->sep_used->current_hash_req->base);
1790 spin_unlock_irq(&queue_lock);
1791
1792 if ((u32_error != 0) && (u32_error != -EINPROGRESS)) {
1793 dev_warn(&ta_ctx->sep_used->pdev->dev,
1794 "spe cypher post op cant queue\n");
1795 sep_crypto_release(sctx, ta_ctx, u32_error);
1796 return u32_error;
1797 }
1798
1799 /* schedule the data send */
1800 u32_error = sep_submit_work(ta_ctx->sep_used->workqueue,
1801 sep_dequeuer, (void *)&sep_queue);
1802
1803 if (u32_error) {
1804 dev_warn(&ta_ctx->sep_used->pdev->dev,
1805 "cant submit work sep_crypto_block\n");
1806 sep_crypto_release(sctx, ta_ctx, -EINVAL);
1807 return -EINVAL;
1808 }
1809 }
1810
1811 /* Signal to crypto infrastructure and clear out */
1812 dev_dbg(&ta_ctx->sep_used->pdev->dev, "hash update post op done\n");
1813 sep_crypto_release(sctx, ta_ctx, 0);
1814 return 0;
1815 }
1816
1817 static u32 hash_final_post_op(struct sep_device *sep)
1818 {
1819 int max_length;
1820 u32 u32_error;
1821 u32 msg_offset;
1822 struct crypto_ahash *tfm = crypto_ahash_reqtfm(sep->current_hash_req);
1823 struct sep_system_ctx *sctx = crypto_ahash_ctx(tfm);
1824 struct this_task_ctx *ta_ctx = ahash_request_ctx(sep->current_hash_req);
1825 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1826 "hash final post op\n");
1827
1828 /* first bring msg from shared area to local area */
1829 memcpy(ta_ctx->msg, sep->shared_addr,
1830 SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
1831
1832 u32_error = sep_verify_op(ta_ctx, SEP_HASH_FINISH_OPCODE,
1833 &msg_offset);
1834
1835 if (u32_error) {
1836 dev_warn(&ta_ctx->sep_used->pdev->dev, "hash finish error %x\n",
1837 u32_error);
1838 sep_crypto_release(sctx, ta_ctx, u32_error);
1839 return u32_error;
1840 }
1841
1842 /* Grab the result */
1843 if (ta_ctx->current_hash_req->result == NULL) {
1844 /* Oops, null buffer; error out here */
1845 dev_warn(&ta_ctx->sep_used->pdev->dev,
1846 "hash finish null buffer\n");
1847 sep_crypto_release(sctx, ta_ctx, (u32)-ENOMEM);
1848 return -ENOMEM;
1849 }
1850
1851 max_length = (((SEP_HASH_RESULT_SIZE_WORDS * sizeof(u32)) + 3) /
1852 sizeof(u32)) * sizeof(u32);
1853
1854 sep_read_msg(ta_ctx,
1855 ta_ctx->current_hash_req->result,
1856 crypto_ahash_digestsize(tfm), max_length,
1857 &msg_offset, 0);
1858
1859 /* Signal to crypto infrastructure and clear out */
1860 dev_dbg(&ta_ctx->sep_used->pdev->dev, "hash finish post op done\n");
1861 sep_crypto_release(sctx, ta_ctx, 0);
1862 return 0;
1863 }
1864
1865 static u32 hash_digest_post_op(struct sep_device *sep)
1866 {
1867 int max_length;
1868 u32 u32_error;
1869 u32 msg_offset;
1870 struct crypto_ahash *tfm = crypto_ahash_reqtfm(sep->current_hash_req);
1871 struct sep_system_ctx *sctx = crypto_ahash_ctx(tfm);
1872 struct this_task_ctx *ta_ctx = ahash_request_ctx(sep->current_hash_req);
1873 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1874 "hash digest post op\n");
1875
1876 /* first bring msg from shared area to local area */
1877 memcpy(ta_ctx->msg, sep->shared_addr,
1878 SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
1879
1880 u32_error = sep_verify_op(ta_ctx, SEP_HASH_SINGLE_OPCODE,
1881 &msg_offset);
1882
1883 if (u32_error) {
1884 dev_warn(&ta_ctx->sep_used->pdev->dev,
1885 "hash digest finish error %x\n", u32_error);
1886
1887 sep_crypto_release(sctx, ta_ctx, u32_error);
1888 return u32_error;
1889 }
1890
1891 /* Grab the result */
1892 if (ta_ctx->current_hash_req->result == NULL) {
1893 /* Oops, null buffer; error out here */
1894 dev_warn(&ta_ctx->sep_used->pdev->dev,
1895 "hash digest finish null buffer\n");
1896 sep_crypto_release(sctx, ta_ctx, (u32)-ENOMEM);
1897 return -ENOMEM;
1898 }
1899
1900 max_length = (((SEP_HASH_RESULT_SIZE_WORDS * sizeof(u32)) + 3) /
1901 sizeof(u32)) * sizeof(u32);
1902
1903 sep_read_msg(ta_ctx,
1904 ta_ctx->current_hash_req->result,
1905 crypto_ahash_digestsize(tfm), max_length,
1906 &msg_offset, 0);
1907
1908 /* Signal to crypto infrastructure and clear out */
1909 dev_dbg(&ta_ctx->sep_used->pdev->dev,
1910 "hash digest finish post op done\n");
1911
1912 sep_crypto_release(sctx, ta_ctx, 0);
1913 return 0;
1914 }
1915
1916 /**
1917 * The sep_finish function is the function that is scheduled (via tasklet)
1918 * by the interrupt service routine when the SEP sends and interrupt
1919 * This is only called by the interrupt handler as a tasklet.
1920 */
1921 static void sep_finish(unsigned long data)
1922 {
1923 struct sep_device *sep_dev;
1924 int res;
1925
1926 res = 0;
1927
1928 if (data == 0) {
1929 pr_debug("sep_finish called with null data\n");
1930 return;
1931 }
1932
1933 sep_dev = (struct sep_device *)data;
1934 if (sep_dev == NULL) {
1935 pr_debug("sep_finish; sep_dev is NULL\n");
1936 return;
1937 }
1938
1939 if (sep_dev->in_kernel == (u32)0) {
1940 dev_warn(&sep_dev->pdev->dev,
1941 "sep_finish; not in kernel operation\n");
1942 return;
1943 }
1944
1945 /* Did we really do a sep command prior to this? */
1946 if (0 == test_bit(SEP_LEGACY_SENDMSG_DONE_OFFSET,
1947 &sep_dev->ta_ctx->call_status.status)) {
1948
1949 dev_warn(&sep_dev->pdev->dev, "[PID%d] sendmsg not called\n",
1950 current->pid);
1951 return;
1952 }
1953
1954 if (sep_dev->send_ct != sep_dev->reply_ct) {
1955 dev_warn(&sep_dev->pdev->dev,
1956 "[PID%d] poll; no message came back\n",
1957 current->pid);
1958 return;
1959 }
1960
1961 /* Check for error (In case time ran out) */
1962 if ((res != 0x0) && (res != 0x8)) {
1963 dev_warn(&sep_dev->pdev->dev,
1964 "[PID%d] poll; poll error GPR3 is %x\n",
1965 current->pid, res);
1966 return;
1967 }
1968
1969 /* What kind of interrupt from sep was this? */
1970 res = sep_read_reg(sep_dev, HW_HOST_SEP_HOST_GPR2_REG_ADDR);
1971
1972 dev_dbg(&sep_dev->pdev->dev, "[PID%d] GPR2 at crypto finish is %x\n",
1973 current->pid, res);
1974
1975 /* Print request? */
1976 if ((res >> 30) & 0x1) {
1977 dev_dbg(&sep_dev->pdev->dev, "[PID%d] sep print req\n",
1978 current->pid);
1979 dev_dbg(&sep_dev->pdev->dev, "[PID%d] contents: %s\n",
1980 current->pid,
1981 (char *)(sep_dev->shared_addr +
1982 SEP_DRIVER_PRINTF_OFFSET_IN_BYTES));
1983 return;
1984 }
1985
1986 /* Request for daemon (not currently in POR)? */
1987 if (res >> 31) {
1988 dev_dbg(&sep_dev->pdev->dev,
1989 "[PID%d] sep request; ignoring\n",
1990 current->pid);
1991 return;
1992 }
1993
1994 /* If we got here, then we have a replay to a sep command */
1995
1996 dev_dbg(&sep_dev->pdev->dev,
1997 "[PID%d] sep reply to command; processing request: %x\n",
1998 current->pid, sep_dev->current_request);
1999
2000 switch (sep_dev->current_request) {
2001 case AES_CBC:
2002 case AES_ECB:
2003 case DES_CBC:
2004 case DES_ECB:
2005 res = crypto_post_op(sep_dev);
2006 break;
2007 case SHA1:
2008 case MD5:
2009 case SHA224:
2010 case SHA256:
2011 switch (sep_dev->current_hash_stage) {
2012 case HASH_INIT:
2013 res = hash_init_post_op(sep_dev);
2014 break;
2015 case HASH_UPDATE:
2016 case HASH_FINUP_DATA:
2017 res = hash_update_post_op(sep_dev);
2018 break;
2019 case HASH_FINUP_FINISH:
2020 case HASH_FINISH:
2021 res = hash_final_post_op(sep_dev);
2022 break;
2023 case HASH_DIGEST:
2024 res = hash_digest_post_op(sep_dev);
2025 break;
2026 default:
2027 pr_debug("sep - invalid stage for hash finish\n");
2028 }
2029 break;
2030 default:
2031 pr_debug("sep - invalid request for finish\n");
2032 }
2033
2034 if (res)
2035 pr_debug("sep - finish returned error %x\n", res);
2036 }
2037
2038 static int sep_hash_cra_init(struct crypto_tfm *tfm)
2039 {
2040 const char *alg_name = crypto_tfm_alg_name(tfm);
2041
2042 pr_debug("sep_hash_cra_init name is %s\n", alg_name);
2043
2044 crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
2045 sizeof(struct this_task_ctx));
2046 return 0;
2047 }
2048
2049 static void sep_hash_cra_exit(struct crypto_tfm *tfm)
2050 {
2051 pr_debug("sep_hash_cra_exit\n");
2052 }
2053
2054 static void sep_hash_init(void *data)
2055 {
2056 u32 msg_offset;
2057 int result;
2058 struct ahash_request *req;
2059 struct crypto_ahash *tfm;
2060 struct this_task_ctx *ta_ctx;
2061 struct sep_system_ctx *sctx;
2062 unsigned long end_time;
2063 int are_we_done_yet;
2064
2065 req = (struct ahash_request *)data;
2066 tfm = crypto_ahash_reqtfm(req);
2067 sctx = crypto_ahash_ctx(tfm);
2068 ta_ctx = ahash_request_ctx(req);
2069 ta_ctx->sep_used = sep_dev;
2070
2071 ta_ctx->are_we_done_yet = &are_we_done_yet;
2072
2073 dev_dbg(&ta_ctx->sep_used->pdev->dev,
2074 "sep_hash_init\n");
2075 ta_ctx->current_hash_stage = HASH_INIT;
2076 /* opcode and mode */
2077 sep_make_header(ta_ctx, &msg_offset, SEP_HASH_INIT_OPCODE);
2078 sep_write_msg(ta_ctx, &ta_ctx->hash_opmode,
2079 sizeof(u32), sizeof(u32), &msg_offset, 0);
2080 sep_end_msg(ta_ctx, msg_offset);
2081
2082 are_we_done_yet = 0;
2083 result = sep_crypto_take_sep(ta_ctx);
2084 if (result) {
2085 dev_warn(&ta_ctx->sep_used->pdev->dev,
2086 "sep_hash_init take sep failed\n");
2087 sep_crypto_release(sctx, ta_ctx, -EINVAL);
2088 }
2089
2090 /* now we sit and wait up to a fixed time for completion */
2091 end_time = jiffies + (WAIT_TIME * HZ);
2092 while ((time_before(jiffies, end_time)) && (are_we_done_yet == 0))
2093 schedule();
2094
2095 /* Done waiting; still not done yet? */
2096 if (are_we_done_yet == 0) {
2097 dev_dbg(&ta_ctx->sep_used->pdev->dev,
2098 "hash init never got done\n");
2099 sep_crypto_release(sctx, ta_ctx, -EINVAL);
2100 return;
2101 }
2102
2103 }
2104
2105 static void sep_hash_update(void *data)
2106 {
2107 int int_error;
2108 u32 msg_offset;
2109 u32 len;
2110 struct sep_hash_internal_context *int_ctx;
2111 u32 block_size;
2112 u32 head_len;
2113 u32 tail_len;
2114 int are_we_done_yet;
2115
2116 static u32 msg[10];
2117 static char small_buf[100];
2118 void *src_ptr;
2119 struct scatterlist *new_sg;
2120 ssize_t copy_result;
2121 struct ahash_request *req;
2122 struct crypto_ahash *tfm;
2123 struct this_task_ctx *ta_ctx;
2124 struct sep_system_ctx *sctx;
2125 unsigned long end_time;
2126
2127 req = (struct ahash_request *)data;
2128 tfm = crypto_ahash_reqtfm(req);
2129 sctx = crypto_ahash_ctx(tfm);
2130 ta_ctx = ahash_request_ctx(req);
2131 ta_ctx->sep_used = sep_dev;
2132
2133 ta_ctx->are_we_done_yet = &are_we_done_yet;
2134
2135 /* length for queue status */
2136 ta_ctx->nbytes = req->nbytes;
2137
2138 dev_dbg(&ta_ctx->sep_used->pdev->dev,
2139 "sep_hash_update\n");
2140 ta_ctx->current_hash_stage = HASH_UPDATE;
2141 len = req->nbytes;
2142
2143 block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));
2144 tail_len = req->nbytes % block_size;
2145 dev_dbg(&ta_ctx->sep_used->pdev->dev, "length is %x\n", len);
2146 dev_dbg(&ta_ctx->sep_used->pdev->dev, "block_size is %x\n", block_size);
2147 dev_dbg(&ta_ctx->sep_used->pdev->dev, "tail len is %x\n", tail_len);
2148
2149 /* Compute header/tail sizes */
2150 int_ctx = (struct sep_hash_internal_context *)&sctx->
2151 hash_private_ctx.internal_context;
2152 head_len = (block_size - int_ctx->prev_update_bytes) % block_size;
2153 tail_len = (req->nbytes - head_len) % block_size;
2154
2155 /* Make sure all pages are an even block */
2156 int_error = sep_oddball_pages(ta_ctx->sep_used, req->src,
2157 req->nbytes,
2158 block_size, &new_sg, 1);
2159
2160 if (int_error < 0) {
2161 dev_warn(&ta_ctx->sep_used->pdev->dev,
2162 "oddball pages error in crash update\n");
2163 sep_crypto_release(sctx, ta_ctx, -ENOMEM);
2164 return;
2165 } else if (int_error == 1) {
2166 ta_ctx->src_sg = new_sg;
2167 ta_ctx->src_sg_hold = new_sg;
2168 } else {
2169 ta_ctx->src_sg = req->src;
2170 ta_ctx->src_sg_hold = NULL;
2171 }
2172
2173 src_ptr = sg_virt(ta_ctx->src_sg);
2174
2175 if ((!req->nbytes) || (!ta_ctx->src_sg)) {
2176 /* null data */
2177 src_ptr = NULL;
2178 }
2179
2180 ta_ctx->dcb_input_data.app_in_address = src_ptr;
2181 ta_ctx->dcb_input_data.data_in_size =
2182 req->nbytes - (head_len + tail_len);
2183 ta_ctx->dcb_input_data.app_out_address = NULL;
2184 ta_ctx->dcb_input_data.block_size = block_size;
2185 ta_ctx->dcb_input_data.tail_block_size = 0;
2186 ta_ctx->dcb_input_data.is_applet = 0;
2187 ta_ctx->dcb_input_data.src_sg = ta_ctx->src_sg;
2188 ta_ctx->dcb_input_data.dst_sg = NULL;
2189
2190 int_error = sep_create_dcb_dmatables_context_kernel(
2191 ta_ctx->sep_used,
2192 &ta_ctx->dcb_region,
2193 &ta_ctx->dmatables_region,
2194 &ta_ctx->dma_ctx,
2195 &ta_ctx->dcb_input_data,
2196 1);
2197 if (int_error) {
2198 dev_warn(&ta_ctx->sep_used->pdev->dev,
2199 "hash update dma table create failed\n");
2200 sep_crypto_release(sctx, ta_ctx, -EINVAL);
2201 return;
2202 }
2203
2204 /* Construct message to SEP */
2205 sep_make_header(ta_ctx, &msg_offset, SEP_HASH_UPDATE_OPCODE);
2206
2207 msg[0] = (u32)0;
2208 msg[1] = (u32)0;
2209 msg[2] = (u32)0;
2210
2211 sep_write_msg(ta_ctx, msg, sizeof(u32) * 3, sizeof(u32) * 3,
2212 &msg_offset, 0);
2213
2214 /* Handle remainders */
2215
2216 /* Head */
2217 sep_write_msg(ta_ctx, &head_len, sizeof(u32),
2218 sizeof(u32), &msg_offset, 0);
2219
2220 if (head_len) {
2221 copy_result = sg_copy_to_buffer(
2222 req->src,
2223 sep_sg_nents(ta_ctx->src_sg),
2224 small_buf, head_len);
2225
2226 if (copy_result != head_len) {
2227 dev_warn(&ta_ctx->sep_used->pdev->dev,
2228 "sg head copy failure in hash block\n");
2229 sep_crypto_release(sctx, ta_ctx, -ENOMEM);
2230 return;
2231 }
2232
2233 sep_write_msg(ta_ctx, small_buf, head_len,
2234 sizeof(u32) * 32, &msg_offset, 1);
2235 } else {
2236 msg_offset += sizeof(u32) * 32;
2237 }
2238
2239 /* Tail */
2240 sep_write_msg(ta_ctx, &tail_len, sizeof(u32),
2241 sizeof(u32), &msg_offset, 0);
2242
2243 if (tail_len) {
2244 copy_result = sep_copy_offset_sg(
2245 ta_ctx->sep_used,
2246 ta_ctx->src_sg,
2247 req->nbytes - tail_len,
2248 small_buf, tail_len);
2249
2250 if (copy_result != tail_len) {
2251 dev_warn(&ta_ctx->sep_used->pdev->dev,
2252 "sg tail copy failure in hash block\n");
2253 sep_crypto_release(sctx, ta_ctx, -ENOMEM);
2254 return;
2255 }
2256
2257 sep_write_msg(ta_ctx, small_buf, tail_len,
2258 sizeof(u32) * 32, &msg_offset, 1);
2259 } else {
2260 msg_offset += sizeof(u32) * 32;
2261 }
2262
2263 /* Context */
2264 sep_write_context(ta_ctx, &msg_offset, &sctx->hash_private_ctx,
2265 sizeof(struct sep_hash_private_context));
2266
2267 sep_end_msg(ta_ctx, msg_offset);
2268 are_we_done_yet = 0;
2269 int_error = sep_crypto_take_sep(ta_ctx);
2270 if (int_error) {
2271 dev_warn(&ta_ctx->sep_used->pdev->dev,
2272 "sep_hash_update take sep failed\n");
2273 sep_crypto_release(sctx, ta_ctx, -EINVAL);
2274 }
2275
2276 /* now we sit and wait up to a fixed time for completion */
2277 end_time = jiffies + (WAIT_TIME * HZ);
2278 while ((time_before(jiffies, end_time)) && (are_we_done_yet == 0))
2279 schedule();
2280
2281 /* Done waiting; still not done yet? */
2282 if (are_we_done_yet == 0) {
2283 dev_dbg(&ta_ctx->sep_used->pdev->dev,
2284 "hash update never got done\n");
2285 sep_crypto_release(sctx, ta_ctx, -EINVAL);
2286 return;
2287 }
2288
2289 }
2290
2291 static void sep_hash_final(void *data)
2292 {
2293 u32 msg_offset;
2294 struct ahash_request *req;
2295 struct crypto_ahash *tfm;
2296 struct this_task_ctx *ta_ctx;
2297 struct sep_system_ctx *sctx;
2298 int result;
2299 unsigned long end_time;
2300 int are_we_done_yet;
2301
2302 req = (struct ahash_request *)data;
2303 tfm = crypto_ahash_reqtfm(req);
2304 sctx = crypto_ahash_ctx(tfm);
2305 ta_ctx = ahash_request_ctx(req);
2306 ta_ctx->sep_used = sep_dev;
2307
2308 dev_dbg(&ta_ctx->sep_used->pdev->dev,
2309 "sep_hash_final\n");
2310 ta_ctx->current_hash_stage = HASH_FINISH;
2311
2312 ta_ctx->are_we_done_yet = &are_we_done_yet;
2313
2314 /* opcode and mode */
2315 sep_make_header(ta_ctx, &msg_offset, SEP_HASH_FINISH_OPCODE);
2316
2317 /* Context */
2318 sep_write_context(ta_ctx, &msg_offset, &sctx->hash_private_ctx,
2319 sizeof(struct sep_hash_private_context));
2320
2321 sep_end_msg(ta_ctx, msg_offset);
2322 are_we_done_yet = 0;
2323 result = sep_crypto_take_sep(ta_ctx);
2324 if (result) {
2325 dev_warn(&ta_ctx->sep_used->pdev->dev,
2326 "sep_hash_final take sep failed\n");
2327 sep_crypto_release(sctx, ta_ctx, -EINVAL);
2328 }
2329
2330 /* now we sit and wait up to a fixed time for completion */
2331 end_time = jiffies + (WAIT_TIME * HZ);
2332 while ((time_before(jiffies, end_time)) && (are_we_done_yet == 0))
2333 schedule();
2334
2335 /* Done waiting; still not done yet? */
2336 if (are_we_done_yet == 0) {
2337 dev_dbg(&ta_ctx->sep_used->pdev->dev,
2338 "hash final job never got done\n");
2339 sep_crypto_release(sctx, ta_ctx, -EINVAL);
2340 return;
2341 }
2342
2343 }
2344
2345 static void sep_hash_digest(void *data)
2346 {
2347 int int_error;
2348 u32 msg_offset;
2349 u32 block_size;
2350 u32 msg[10];
2351 size_t copy_result;
2352 int result;
2353 int are_we_done_yet;
2354 u32 tail_len;
2355 static char small_buf[100];
2356 struct scatterlist *new_sg;
2357 void *src_ptr;
2358
2359 struct ahash_request *req;
2360 struct crypto_ahash *tfm;
2361 struct this_task_ctx *ta_ctx;
2362 struct sep_system_ctx *sctx;
2363 unsigned long end_time;
2364
2365 req = (struct ahash_request *)data;
2366 tfm = crypto_ahash_reqtfm(req);
2367 sctx = crypto_ahash_ctx(tfm);
2368 ta_ctx = ahash_request_ctx(req);
2369 ta_ctx->sep_used = sep_dev;
2370
2371 dev_dbg(&ta_ctx->sep_used->pdev->dev,
2372 "sep_hash_digest\n");
2373 ta_ctx->current_hash_stage = HASH_DIGEST;
2374
2375 ta_ctx->are_we_done_yet = &are_we_done_yet;
2376
2377 /* length for queue status */
2378 ta_ctx->nbytes = req->nbytes;
2379
2380 block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));
2381 tail_len = req->nbytes % block_size;
2382 dev_dbg(&ta_ctx->sep_used->pdev->dev, "length is %x\n", req->nbytes);
2383 dev_dbg(&ta_ctx->sep_used->pdev->dev, "block_size is %x\n", block_size);
2384 dev_dbg(&ta_ctx->sep_used->pdev->dev, "tail len is %x\n", tail_len);
2385
2386 /* Make sure all pages are an even block */
2387 int_error = sep_oddball_pages(ta_ctx->sep_used, req->src,
2388 req->nbytes,
2389 block_size, &new_sg, 1);
2390
2391 if (int_error < 0) {
2392 dev_warn(&ta_ctx->sep_used->pdev->dev,
2393 "oddball pages error in crash update\n");
2394 sep_crypto_release(sctx, ta_ctx, -ENOMEM);
2395 return;
2396 } else if (int_error == 1) {
2397 ta_ctx->src_sg = new_sg;
2398 ta_ctx->src_sg_hold = new_sg;
2399 } else {
2400 ta_ctx->src_sg = req->src;
2401 ta_ctx->src_sg_hold = NULL;
2402 }
2403
2404 src_ptr = sg_virt(ta_ctx->src_sg);
2405
2406 if ((!req->nbytes) || (!ta_ctx->src_sg)) {
2407 /* null data */
2408 src_ptr = NULL;
2409 }
2410
2411 ta_ctx->dcb_input_data.app_in_address = src_ptr;
2412 ta_ctx->dcb_input_data.data_in_size = req->nbytes - tail_len;
2413 ta_ctx->dcb_input_data.app_out_address = NULL;
2414 ta_ctx->dcb_input_data.block_size = block_size;
2415 ta_ctx->dcb_input_data.tail_block_size = 0;
2416 ta_ctx->dcb_input_data.is_applet = 0;
2417 ta_ctx->dcb_input_data.src_sg = ta_ctx->src_sg;
2418 ta_ctx->dcb_input_data.dst_sg = NULL;
2419
2420 int_error = sep_create_dcb_dmatables_context_kernel(
2421 ta_ctx->sep_used,
2422 &ta_ctx->dcb_region,
2423 &ta_ctx->dmatables_region,
2424 &ta_ctx->dma_ctx,
2425 &ta_ctx->dcb_input_data,
2426 1);
2427 if (int_error) {
2428 dev_warn(&ta_ctx->sep_used->pdev->dev,
2429 "hash update dma table create failed\n");
2430 sep_crypto_release(sctx, ta_ctx, -EINVAL);
2431 return;
2432 }
2433
2434 /* Construct message to SEP */
2435 sep_make_header(ta_ctx, &msg_offset, SEP_HASH_SINGLE_OPCODE);
2436 sep_write_msg(ta_ctx, &ta_ctx->hash_opmode,
2437 sizeof(u32), sizeof(u32), &msg_offset, 0);
2438
2439 msg[0] = (u32)0;
2440 msg[1] = (u32)0;
2441 msg[2] = (u32)0;
2442
2443 sep_write_msg(ta_ctx, msg, sizeof(u32) * 3, sizeof(u32) * 3,
2444 &msg_offset, 0);
2445
2446 /* Tail */
2447 sep_write_msg(ta_ctx, &tail_len, sizeof(u32),
2448 sizeof(u32), &msg_offset, 0);
2449
2450 if (tail_len) {
2451 copy_result = sep_copy_offset_sg(
2452 ta_ctx->sep_used,
2453 ta_ctx->src_sg,
2454 req->nbytes - tail_len,
2455 small_buf, tail_len);
2456
2457 if (copy_result != tail_len) {
2458 dev_warn(&ta_ctx->sep_used->pdev->dev,
2459 "sg tail copy failure in hash block\n");
2460 sep_crypto_release(sctx, ta_ctx, -ENOMEM);
2461 return;
2462 }
2463
2464 sep_write_msg(ta_ctx, small_buf, tail_len,
2465 sizeof(u32) * 32, &msg_offset, 1);
2466 } else {
2467 msg_offset += sizeof(u32) * 32;
2468 }
2469
2470 sep_end_msg(ta_ctx, msg_offset);
2471
2472 are_we_done_yet = 0;
2473 result = sep_crypto_take_sep(ta_ctx);
2474 if (result) {
2475 dev_warn(&ta_ctx->sep_used->pdev->dev,
2476 "sep_hash_digest take sep failed\n");
2477 sep_crypto_release(sctx, ta_ctx, -EINVAL);
2478 }
2479
2480 /* now we sit and wait up to a fixed time for completion */
2481 end_time = jiffies + (WAIT_TIME * HZ);
2482 while ((time_before(jiffies, end_time)) && (are_we_done_yet == 0))
2483 schedule();
2484
2485 /* Done waiting; still not done yet? */
2486 if (are_we_done_yet == 0) {
2487 dev_dbg(&ta_ctx->sep_used->pdev->dev,
2488 "hash digest job never got done\n");
2489 sep_crypto_release(sctx, ta_ctx, -EINVAL);
2490 return;
2491 }
2492
2493 }
2494
2495 /**
2496 * This is what is called by each of the API's provided
2497 * in the kernel crypto descriptors. It is run in a process
2498 * context using the kernel workqueues. Therefore it can
2499 * be put to sleep.
2500 */
2501 static void sep_dequeuer(void *data)
2502 {
2503 struct crypto_queue *this_queue;
2504 struct crypto_async_request *async_req;
2505 struct crypto_async_request *backlog;
2506 struct ablkcipher_request *cypher_req;
2507 struct ahash_request *hash_req;
2508 struct sep_system_ctx *sctx;
2509 struct crypto_ahash *hash_tfm;
2510 struct this_task_ctx *ta_ctx;
2511
2512
2513 this_queue = (struct crypto_queue *)data;
2514
2515 spin_lock_irq(&queue_lock);
2516 backlog = crypto_get_backlog(this_queue);
2517 async_req = crypto_dequeue_request(this_queue);
2518 spin_unlock_irq(&queue_lock);
2519
2520 if (!async_req) {
2521 pr_debug("sep crypto queue is empty\n");
2522 return;
2523 }
2524
2525 if (backlog) {
2526 pr_debug("sep crypto backlog set\n");
2527 if (backlog->complete)
2528 backlog->complete(backlog, -EINPROGRESS);
2529 backlog = NULL;
2530 }
2531
2532 if (!async_req->tfm) {
2533 pr_debug("sep crypto queue null tfm\n");
2534 return;
2535 }
2536
2537 if (!async_req->tfm->__crt_alg) {
2538 pr_debug("sep crypto queue null __crt_alg\n");
2539 return;
2540 }
2541
2542 if (!async_req->tfm->__crt_alg->cra_type) {
2543 pr_debug("sep crypto queue null cra_type\n");
2544 return;
2545 }
2546
2547 /* we have stuff in the queue */
2548 if (async_req->tfm->__crt_alg->cra_type !=
2549 &crypto_ahash_type) {
2550 /* This is for a cypher */
2551 pr_debug("sep crypto queue doing cipher\n");
2552 cypher_req = container_of(async_req,
2553 struct ablkcipher_request,
2554 base);
2555 if (!cypher_req) {
2556 pr_debug("sep crypto queue null cypher_req\n");
2557 return;
2558 }
2559
2560 sep_crypto_block((void *)cypher_req);
2561 return;
2562 } else {
2563 /* This is a hash */
2564 pr_debug("sep crypto queue doing hash\n");
2565 /**
2566 * This is a bit more complex than cipher; we
2567 * need to figure out what type of operation
2568 */
2569 hash_req = ahash_request_cast(async_req);
2570 if (!hash_req) {
2571 pr_debug("sep crypto queue null hash_req\n");
2572 return;
2573 }
2574
2575 hash_tfm = crypto_ahash_reqtfm(hash_req);
2576 if (!hash_tfm) {
2577 pr_debug("sep crypto queue null hash_tfm\n");
2578 return;
2579 }
2580
2581
2582 sctx = crypto_ahash_ctx(hash_tfm);
2583 if (!sctx) {
2584 pr_debug("sep crypto queue null sctx\n");
2585 return;
2586 }
2587
2588 ta_ctx = ahash_request_ctx(hash_req);
2589
2590 if (ta_ctx->current_hash_stage == HASH_INIT) {
2591 pr_debug("sep crypto queue hash init\n");
2592 sep_hash_init((void *)hash_req);
2593 return;
2594 } else if (ta_ctx->current_hash_stage == HASH_UPDATE) {
2595 pr_debug("sep crypto queue hash update\n");
2596 sep_hash_update((void *)hash_req);
2597 return;
2598 } else if (ta_ctx->current_hash_stage == HASH_FINISH) {
2599 pr_debug("sep crypto queue hash final\n");
2600 sep_hash_final((void *)hash_req);
2601 return;
2602 } else if (ta_ctx->current_hash_stage == HASH_DIGEST) {
2603 pr_debug("sep crypto queue hash digest\n");
2604 sep_hash_digest((void *)hash_req);
2605 return;
2606 } else if (ta_ctx->current_hash_stage == HASH_FINUP_DATA) {
2607 pr_debug("sep crypto queue hash digest\n");
2608 sep_hash_update((void *)hash_req);
2609 return;
2610 } else if (ta_ctx->current_hash_stage == HASH_FINUP_FINISH) {
2611 pr_debug("sep crypto queue hash digest\n");
2612 sep_hash_final((void *)hash_req);
2613 return;
2614 } else {
2615 pr_debug("sep crypto queue hash oops nothing\n");
2616 return;
2617 }
2618 }
2619 }
2620
2621 static int sep_sha1_init(struct ahash_request *req)
2622 {
2623 int error;
2624 int error1;
2625 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2626
2627 pr_debug("sep - doing sha1 init\n");
2628
2629 /* Clear out task context */
2630 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
2631
2632 ta_ctx->sep_used = sep_dev;
2633 ta_ctx->current_request = SHA1;
2634 ta_ctx->current_hash_req = req;
2635 ta_ctx->current_cypher_req = NULL;
2636 ta_ctx->hash_opmode = SEP_HASH_SHA1;
2637 ta_ctx->current_hash_stage = HASH_INIT;
2638
2639 /* lock necessary so that only one entity touches the queues */
2640 spin_lock_irq(&queue_lock);
2641 error = crypto_enqueue_request(&sep_queue, &req->base);
2642
2643 if ((error != 0) && (error != -EINPROGRESS))
2644 pr_debug(" sep - crypto enqueue failed: %x\n",
2645 error);
2646 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2647 sep_dequeuer, (void *)&sep_queue);
2648 if (error1)
2649 pr_debug(" sep - workqueue submit failed: %x\n",
2650 error1);
2651 spin_unlock_irq(&queue_lock);
2652 /* We return result of crypto enqueue */
2653 return error;
2654 }
2655
2656 static int sep_sha1_update(struct ahash_request *req)
2657 {
2658 int error;
2659 int error1;
2660 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2661
2662 pr_debug("sep - doing sha1 update\n");
2663
2664 ta_ctx->sep_used = sep_dev;
2665 ta_ctx->current_request = SHA1;
2666 ta_ctx->current_hash_req = req;
2667 ta_ctx->current_cypher_req = NULL;
2668 ta_ctx->hash_opmode = SEP_HASH_SHA1;
2669 ta_ctx->current_hash_stage = HASH_UPDATE;
2670
2671 /* lock necessary so that only one entity touches the queues */
2672 spin_lock_irq(&queue_lock);
2673 error = crypto_enqueue_request(&sep_queue, &req->base);
2674
2675 if ((error != 0) && (error != -EINPROGRESS))
2676 pr_debug(" sep - crypto enqueue failed: %x\n",
2677 error);
2678 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2679 sep_dequeuer, (void *)&sep_queue);
2680 if (error1)
2681 pr_debug(" sep - workqueue submit failed: %x\n",
2682 error1);
2683 spin_unlock_irq(&queue_lock);
2684 /* We return result of crypto enqueue */
2685 return error;
2686 }
2687
2688 static int sep_sha1_final(struct ahash_request *req)
2689 {
2690 int error;
2691 int error1;
2692 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2693 pr_debug("sep - doing sha1 final\n");
2694
2695 ta_ctx->sep_used = sep_dev;
2696 ta_ctx->current_request = SHA1;
2697 ta_ctx->current_hash_req = req;
2698 ta_ctx->current_cypher_req = NULL;
2699 ta_ctx->hash_opmode = SEP_HASH_SHA1;
2700 ta_ctx->current_hash_stage = HASH_FINISH;
2701
2702 /* lock necessary so that only one entity touches the queues */
2703 spin_lock_irq(&queue_lock);
2704 error = crypto_enqueue_request(&sep_queue, &req->base);
2705
2706 if ((error != 0) && (error != -EINPROGRESS))
2707 pr_debug(" sep - crypto enqueue failed: %x\n",
2708 error);
2709 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2710 sep_dequeuer, (void *)&sep_queue);
2711 if (error1)
2712 pr_debug(" sep - workqueue submit failed: %x\n",
2713 error1);
2714 spin_unlock_irq(&queue_lock);
2715 /* We return result of crypto enqueue */
2716 return error;
2717 }
2718
2719 static int sep_sha1_digest(struct ahash_request *req)
2720 {
2721 int error;
2722 int error1;
2723 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2724 pr_debug("sep - doing sha1 digest\n");
2725
2726 /* Clear out task context */
2727 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
2728
2729 ta_ctx->sep_used = sep_dev;
2730 ta_ctx->current_request = SHA1;
2731 ta_ctx->current_hash_req = req;
2732 ta_ctx->current_cypher_req = NULL;
2733 ta_ctx->hash_opmode = SEP_HASH_SHA1;
2734 ta_ctx->current_hash_stage = HASH_DIGEST;
2735
2736 /* lock necessary so that only one entity touches the queues */
2737 spin_lock_irq(&queue_lock);
2738 error = crypto_enqueue_request(&sep_queue, &req->base);
2739
2740 if ((error != 0) && (error != -EINPROGRESS))
2741 pr_debug(" sep - crypto enqueue failed: %x\n",
2742 error);
2743 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2744 sep_dequeuer, (void *)&sep_queue);
2745 if (error1)
2746 pr_debug(" sep - workqueue submit failed: %x\n",
2747 error1);
2748 spin_unlock_irq(&queue_lock);
2749 /* We return result of crypto enqueue */
2750 return error;
2751 }
2752
2753 static int sep_sha1_finup(struct ahash_request *req)
2754 {
2755 int error;
2756 int error1;
2757 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2758 pr_debug("sep - doing sha1 finup\n");
2759
2760 ta_ctx->sep_used = sep_dev;
2761 ta_ctx->current_request = SHA1;
2762 ta_ctx->current_hash_req = req;
2763 ta_ctx->current_cypher_req = NULL;
2764 ta_ctx->hash_opmode = SEP_HASH_SHA1;
2765 ta_ctx->current_hash_stage = HASH_FINUP_DATA;
2766
2767 /* lock necessary so that only one entity touches the queues */
2768 spin_lock_irq(&queue_lock);
2769 error = crypto_enqueue_request(&sep_queue, &req->base);
2770
2771 if ((error != 0) && (error != -EINPROGRESS))
2772 pr_debug(" sep - crypto enqueue failed: %x\n",
2773 error);
2774 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2775 sep_dequeuer, (void *)&sep_queue);
2776 if (error1)
2777 pr_debug(" sep - workqueue submit failed: %x\n",
2778 error1);
2779 spin_unlock_irq(&queue_lock);
2780 /* We return result of crypto enqueue */
2781 return error;
2782 }
2783
2784 static int sep_md5_init(struct ahash_request *req)
2785 {
2786 int error;
2787 int error1;
2788 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2789 pr_debug("sep - doing md5 init\n");
2790
2791 /* Clear out task context */
2792 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
2793
2794 ta_ctx->sep_used = sep_dev;
2795 ta_ctx->current_request = MD5;
2796 ta_ctx->current_hash_req = req;
2797 ta_ctx->current_cypher_req = NULL;
2798 ta_ctx->hash_opmode = SEP_HASH_MD5;
2799 ta_ctx->current_hash_stage = HASH_INIT;
2800
2801 /* lock necessary so that only one entity touches the queues */
2802 spin_lock_irq(&queue_lock);
2803 error = crypto_enqueue_request(&sep_queue, &req->base);
2804
2805 if ((error != 0) && (error != -EINPROGRESS))
2806 pr_debug(" sep - crypto enqueue failed: %x\n",
2807 error);
2808 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2809 sep_dequeuer, (void *)&sep_queue);
2810 if (error1)
2811 pr_debug(" sep - workqueue submit failed: %x\n",
2812 error1);
2813 spin_unlock_irq(&queue_lock);
2814 /* We return result of crypto enqueue */
2815 return error;
2816 }
2817
2818 static int sep_md5_update(struct ahash_request *req)
2819 {
2820 int error;
2821 int error1;
2822 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2823 pr_debug("sep - doing md5 update\n");
2824
2825 ta_ctx->sep_used = sep_dev;
2826 ta_ctx->current_request = MD5;
2827 ta_ctx->current_hash_req = req;
2828 ta_ctx->current_cypher_req = NULL;
2829 ta_ctx->hash_opmode = SEP_HASH_MD5;
2830 ta_ctx->current_hash_stage = HASH_UPDATE;
2831
2832 /* lock necessary so that only one entity touches the queues */
2833 spin_lock_irq(&queue_lock);
2834 error = crypto_enqueue_request(&sep_queue, &req->base);
2835
2836 if ((error != 0) && (error != -EINPROGRESS))
2837 pr_debug(" sep - crypto enqueue failed: %x\n",
2838 error);
2839 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2840 sep_dequeuer, (void *)&sep_queue);
2841 if (error1)
2842 pr_debug(" sep - workqueue submit failed: %x\n",
2843 error1);
2844 spin_unlock_irq(&queue_lock);
2845 /* We return result of crypto enqueue */
2846 return error;
2847 }
2848
2849 static int sep_md5_final(struct ahash_request *req)
2850 {
2851 int error;
2852 int error1;
2853 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2854 pr_debug("sep - doing md5 final\n");
2855
2856 ta_ctx->sep_used = sep_dev;
2857 ta_ctx->current_request = MD5;
2858 ta_ctx->current_hash_req = req;
2859 ta_ctx->current_cypher_req = NULL;
2860 ta_ctx->hash_opmode = SEP_HASH_MD5;
2861 ta_ctx->current_hash_stage = HASH_FINISH;
2862
2863 /* lock necessary so that only one entity touches the queues */
2864 spin_lock_irq(&queue_lock);
2865 error = crypto_enqueue_request(&sep_queue, &req->base);
2866
2867 if ((error != 0) && (error != -EINPROGRESS))
2868 pr_debug(" sep - crypto enqueue failed: %x\n",
2869 error);
2870 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2871 sep_dequeuer, (void *)&sep_queue);
2872 if (error1)
2873 pr_debug(" sep - workqueue submit failed: %x\n",
2874 error1);
2875 spin_unlock_irq(&queue_lock);
2876 /* We return result of crypto enqueue */
2877 return error;
2878 }
2879
2880 static int sep_md5_digest(struct ahash_request *req)
2881 {
2882 int error;
2883 int error1;
2884 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2885
2886 pr_debug("sep - doing md5 digest\n");
2887
2888 /* Clear out task context */
2889 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
2890
2891 ta_ctx->sep_used = sep_dev;
2892 ta_ctx->current_request = MD5;
2893 ta_ctx->current_hash_req = req;
2894 ta_ctx->current_cypher_req = NULL;
2895 ta_ctx->hash_opmode = SEP_HASH_MD5;
2896 ta_ctx->current_hash_stage = HASH_DIGEST;
2897
2898 /* lock necessary so that only one entity touches the queues */
2899 spin_lock_irq(&queue_lock);
2900 error = crypto_enqueue_request(&sep_queue, &req->base);
2901
2902 if ((error != 0) && (error != -EINPROGRESS))
2903 pr_debug(" sep - crypto enqueue failed: %x\n",
2904 error);
2905 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2906 sep_dequeuer, (void *)&sep_queue);
2907 if (error1)
2908 pr_debug(" sep - workqueue submit failed: %x\n",
2909 error1);
2910 spin_unlock_irq(&queue_lock);
2911 /* We return result of crypto enqueue */
2912 return error;
2913 }
2914
2915 static int sep_md5_finup(struct ahash_request *req)
2916 {
2917 int error;
2918 int error1;
2919 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2920
2921 pr_debug("sep - doing md5 finup\n");
2922
2923 ta_ctx->sep_used = sep_dev;
2924 ta_ctx->current_request = MD5;
2925 ta_ctx->current_hash_req = req;
2926 ta_ctx->current_cypher_req = NULL;
2927 ta_ctx->hash_opmode = SEP_HASH_MD5;
2928 ta_ctx->current_hash_stage = HASH_FINUP_DATA;
2929
2930 /* lock necessary so that only one entity touches the queues */
2931 spin_lock_irq(&queue_lock);
2932 error = crypto_enqueue_request(&sep_queue, &req->base);
2933
2934 if ((error != 0) && (error != -EINPROGRESS))
2935 pr_debug(" sep - crypto enqueue failed: %x\n",
2936 error);
2937 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2938 sep_dequeuer, (void *)&sep_queue);
2939 if (error1)
2940 pr_debug(" sep - workqueue submit failed: %x\n",
2941 error1);
2942 spin_unlock_irq(&queue_lock);
2943 /* We return result of crypto enqueue */
2944 return error;
2945 }
2946
2947 static int sep_sha224_init(struct ahash_request *req)
2948 {
2949 int error;
2950 int error1;
2951 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2952 pr_debug("sep - doing sha224 init\n");
2953
2954 /* Clear out task context */
2955 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
2956
2957 ta_ctx->sep_used = sep_dev;
2958 ta_ctx->current_request = SHA224;
2959 ta_ctx->current_hash_req = req;
2960 ta_ctx->current_cypher_req = NULL;
2961 ta_ctx->hash_opmode = SEP_HASH_SHA224;
2962 ta_ctx->current_hash_stage = HASH_INIT;
2963
2964 /* lock necessary so that only one entity touches the queues */
2965 spin_lock_irq(&queue_lock);
2966 error = crypto_enqueue_request(&sep_queue, &req->base);
2967
2968 if ((error != 0) && (error != -EINPROGRESS))
2969 pr_debug(" sep - crypto enqueue failed: %x\n",
2970 error);
2971 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
2972 sep_dequeuer, (void *)&sep_queue);
2973 if (error1)
2974 pr_debug(" sep - workqueue submit failed: %x\n",
2975 error1);
2976 spin_unlock_irq(&queue_lock);
2977 /* We return result of crypto enqueue */
2978 return error;
2979 }
2980
2981 static int sep_sha224_update(struct ahash_request *req)
2982 {
2983 int error;
2984 int error1;
2985 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
2986 pr_debug("sep - doing sha224 update\n");
2987
2988 ta_ctx->sep_used = sep_dev;
2989 ta_ctx->current_request = SHA224;
2990 ta_ctx->current_hash_req = req;
2991 ta_ctx->current_cypher_req = NULL;
2992 ta_ctx->hash_opmode = SEP_HASH_SHA224;
2993 ta_ctx->current_hash_stage = HASH_UPDATE;
2994
2995 /* lock necessary so that only one entity touches the queues */
2996 spin_lock_irq(&queue_lock);
2997 error = crypto_enqueue_request(&sep_queue, &req->base);
2998
2999 if ((error != 0) && (error != -EINPROGRESS))
3000 pr_debug(" sep - crypto enqueue failed: %x\n",
3001 error);
3002 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3003 sep_dequeuer, (void *)&sep_queue);
3004 if (error1)
3005 pr_debug(" sep - workqueue submit failed: %x\n",
3006 error1);
3007 spin_unlock_irq(&queue_lock);
3008 /* We return result of crypto enqueue */
3009 return error;
3010 }
3011
3012 static int sep_sha224_final(struct ahash_request *req)
3013 {
3014 int error;
3015 int error1;
3016 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
3017 pr_debug("sep - doing sha224 final\n");
3018
3019 ta_ctx->sep_used = sep_dev;
3020 ta_ctx->current_request = SHA224;
3021 ta_ctx->current_hash_req = req;
3022 ta_ctx->current_cypher_req = NULL;
3023 ta_ctx->hash_opmode = SEP_HASH_SHA224;
3024 ta_ctx->current_hash_stage = HASH_FINISH;
3025
3026 /* lock necessary so that only one entity touches the queues */
3027 spin_lock_irq(&queue_lock);
3028 error = crypto_enqueue_request(&sep_queue, &req->base);
3029
3030 if ((error != 0) && (error != -EINPROGRESS))
3031 pr_debug(" sep - crypto enqueue failed: %x\n",
3032 error);
3033 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3034 sep_dequeuer, (void *)&sep_queue);
3035 if (error1)
3036 pr_debug(" sep - workqueue submit failed: %x\n",
3037 error1);
3038 spin_unlock_irq(&queue_lock);
3039 /* We return result of crypto enqueue */
3040 return error;
3041 }
3042
3043 static int sep_sha224_digest(struct ahash_request *req)
3044 {
3045 int error;
3046 int error1;
3047 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
3048
3049 pr_debug("sep - doing sha224 digest\n");
3050
3051 /* Clear out task context */
3052 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3053
3054 ta_ctx->sep_used = sep_dev;
3055 ta_ctx->current_request = SHA224;
3056 ta_ctx->current_hash_req = req;
3057 ta_ctx->current_cypher_req = NULL;
3058 ta_ctx->hash_opmode = SEP_HASH_SHA224;
3059 ta_ctx->current_hash_stage = HASH_DIGEST;
3060
3061 /* lock necessary so that only one entity touches the queues */
3062 spin_lock_irq(&queue_lock);
3063 error = crypto_enqueue_request(&sep_queue, &req->base);
3064
3065 if ((error != 0) && (error != -EINPROGRESS))
3066 pr_debug(" sep - crypto enqueue failed: %x\n",
3067 error);
3068 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3069 sep_dequeuer, (void *)&sep_queue);
3070 if (error1)
3071 pr_debug(" sep - workqueue submit failed: %x\n",
3072 error1);
3073 spin_unlock_irq(&queue_lock);
3074 /* We return result of crypto enqueue */
3075 return error;
3076 }
3077
3078 static int sep_sha224_finup(struct ahash_request *req)
3079 {
3080 int error;
3081 int error1;
3082 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
3083
3084 pr_debug("sep - doing sha224 finup\n");
3085
3086 ta_ctx->sep_used = sep_dev;
3087 ta_ctx->current_request = SHA224;
3088 ta_ctx->current_hash_req = req;
3089 ta_ctx->current_cypher_req = NULL;
3090 ta_ctx->hash_opmode = SEP_HASH_SHA224;
3091 ta_ctx->current_hash_stage = HASH_FINUP_DATA;
3092
3093 /* lock necessary so that only one entity touches the queues */
3094 spin_lock_irq(&queue_lock);
3095 error = crypto_enqueue_request(&sep_queue, &req->base);
3096
3097 if ((error != 0) && (error != -EINPROGRESS))
3098 pr_debug(" sep - crypto enqueue failed: %x\n",
3099 error);
3100 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3101 sep_dequeuer, (void *)&sep_queue);
3102 if (error1)
3103 pr_debug(" sep - workqueue submit failed: %x\n",
3104 error1);
3105 spin_unlock_irq(&queue_lock);
3106 /* We return result of crypto enqueue */
3107 return error;
3108 }
3109
3110 static int sep_sha256_init(struct ahash_request *req)
3111 {
3112 int error;
3113 int error1;
3114 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
3115 pr_debug("sep - doing sha256 init\n");
3116
3117 /* Clear out task context */
3118 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3119
3120 ta_ctx->sep_used = sep_dev;
3121 ta_ctx->current_request = SHA256;
3122 ta_ctx->current_hash_req = req;
3123 ta_ctx->current_cypher_req = NULL;
3124 ta_ctx->hash_opmode = SEP_HASH_SHA256;
3125 ta_ctx->current_hash_stage = HASH_INIT;
3126
3127 /* lock necessary so that only one entity touches the queues */
3128 spin_lock_irq(&queue_lock);
3129 error = crypto_enqueue_request(&sep_queue, &req->base);
3130
3131 if ((error != 0) && (error != -EINPROGRESS))
3132 pr_debug(" sep - crypto enqueue failed: %x\n",
3133 error);
3134 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3135 sep_dequeuer, (void *)&sep_queue);
3136 if (error1)
3137 pr_debug(" sep - workqueue submit failed: %x\n",
3138 error1);
3139 spin_unlock_irq(&queue_lock);
3140 /* We return result of crypto enqueue */
3141 return error;
3142 }
3143
3144 static int sep_sha256_update(struct ahash_request *req)
3145 {
3146 int error;
3147 int error1;
3148 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
3149 pr_debug("sep - doing sha256 update\n");
3150
3151 ta_ctx->sep_used = sep_dev;
3152 ta_ctx->current_request = SHA256;
3153 ta_ctx->current_hash_req = req;
3154 ta_ctx->current_cypher_req = NULL;
3155 ta_ctx->hash_opmode = SEP_HASH_SHA256;
3156 ta_ctx->current_hash_stage = HASH_UPDATE;
3157
3158 /* lock necessary so that only one entity touches the queues */
3159 spin_lock_irq(&queue_lock);
3160 error = crypto_enqueue_request(&sep_queue, &req->base);
3161
3162 if ((error != 0) && (error != -EINPROGRESS))
3163 pr_debug(" sep - crypto enqueue failed: %x\n",
3164 error);
3165 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3166 sep_dequeuer, (void *)&sep_queue);
3167 if (error1)
3168 pr_debug(" sep - workqueue submit failed: %x\n",
3169 error1);
3170 spin_unlock_irq(&queue_lock);
3171 /* We return result of crypto enqueue */
3172 return error;
3173 }
3174
3175 static int sep_sha256_final(struct ahash_request *req)
3176 {
3177 int error;
3178 int error1;
3179 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
3180 pr_debug("sep - doing sha256 final\n");
3181
3182 ta_ctx->sep_used = sep_dev;
3183 ta_ctx->current_request = SHA256;
3184 ta_ctx->current_hash_req = req;
3185 ta_ctx->current_cypher_req = NULL;
3186 ta_ctx->hash_opmode = SEP_HASH_SHA256;
3187 ta_ctx->current_hash_stage = HASH_FINISH;
3188
3189 /* lock necessary so that only one entity touches the queues */
3190 spin_lock_irq(&queue_lock);
3191 error = crypto_enqueue_request(&sep_queue, &req->base);
3192
3193 if ((error != 0) && (error != -EINPROGRESS))
3194 pr_debug(" sep - crypto enqueue failed: %x\n",
3195 error);
3196 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3197 sep_dequeuer, (void *)&sep_queue);
3198 if (error1)
3199 pr_debug(" sep - workqueue submit failed: %x\n",
3200 error1);
3201 spin_unlock_irq(&queue_lock);
3202 /* We return result of crypto enqueue */
3203 return error;
3204 }
3205
3206 static int sep_sha256_digest(struct ahash_request *req)
3207 {
3208 int error;
3209 int error1;
3210 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
3211
3212 pr_debug("sep - doing sha256 digest\n");
3213
3214 /* Clear out task context */
3215 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3216
3217 ta_ctx->sep_used = sep_dev;
3218 ta_ctx->current_request = SHA256;
3219 ta_ctx->current_hash_req = req;
3220 ta_ctx->current_cypher_req = NULL;
3221 ta_ctx->hash_opmode = SEP_HASH_SHA256;
3222 ta_ctx->current_hash_stage = HASH_DIGEST;
3223
3224 /* lock necessary so that only one entity touches the queues */
3225 spin_lock_irq(&queue_lock);
3226 error = crypto_enqueue_request(&sep_queue, &req->base);
3227
3228 if ((error != 0) && (error != -EINPROGRESS))
3229 pr_debug(" sep - crypto enqueue failed: %x\n",
3230 error);
3231 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3232 sep_dequeuer, (void *)&sep_queue);
3233 if (error1)
3234 pr_debug(" sep - workqueue submit failed: %x\n",
3235 error1);
3236 spin_unlock_irq(&queue_lock);
3237 /* We return result of crypto enqueue */
3238 return error;
3239 }
3240
3241 static int sep_sha256_finup(struct ahash_request *req)
3242 {
3243 int error;
3244 int error1;
3245 struct this_task_ctx *ta_ctx = ahash_request_ctx(req);
3246
3247 pr_debug("sep - doing sha256 finup\n");
3248
3249 ta_ctx->sep_used = sep_dev;
3250 ta_ctx->current_request = SHA256;
3251 ta_ctx->current_hash_req = req;
3252 ta_ctx->current_cypher_req = NULL;
3253 ta_ctx->hash_opmode = SEP_HASH_SHA256;
3254 ta_ctx->current_hash_stage = HASH_FINUP_DATA;
3255
3256 /* lock necessary so that only one entity touches the queues */
3257 spin_lock_irq(&queue_lock);
3258 error = crypto_enqueue_request(&sep_queue, &req->base);
3259
3260 if ((error != 0) && (error != -EINPROGRESS))
3261 pr_debug(" sep - crypto enqueue failed: %x\n",
3262 error);
3263 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3264 sep_dequeuer, (void *)&sep_queue);
3265 if (error1)
3266 pr_debug(" sep - workqueue submit failed: %x\n",
3267 error1);
3268 spin_unlock_irq(&queue_lock);
3269 /* We return result of crypto enqueue */
3270 return error;
3271 }
3272
3273 static int sep_crypto_init(struct crypto_tfm *tfm)
3274 {
3275 const char *alg_name = crypto_tfm_alg_name(tfm);
3276
3277 if (alg_name == NULL)
3278 pr_debug("sep_crypto_init alg is NULL\n");
3279 else
3280 pr_debug("sep_crypto_init alg is %s\n", alg_name);
3281
3282 tfm->crt_ablkcipher.reqsize = sizeof(struct this_task_ctx);
3283 return 0;
3284 }
3285
3286 static void sep_crypto_exit(struct crypto_tfm *tfm)
3287 {
3288 pr_debug("sep_crypto_exit\n");
3289 }
3290
3291 static int sep_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
3292 unsigned int keylen)
3293 {
3294 struct sep_system_ctx *sctx = crypto_ablkcipher_ctx(tfm);
3295
3296 pr_debug("sep aes setkey\n");
3297
3298 pr_debug("tfm is %p sctx is %p\n", tfm, sctx);
3299 switch (keylen) {
3300 case SEP_AES_KEY_128_SIZE:
3301 sctx->aes_key_size = AES_128;
3302 break;
3303 case SEP_AES_KEY_192_SIZE:
3304 sctx->aes_key_size = AES_192;
3305 break;
3306 case SEP_AES_KEY_256_SIZE:
3307 sctx->aes_key_size = AES_256;
3308 break;
3309 case SEP_AES_KEY_512_SIZE:
3310 sctx->aes_key_size = AES_512;
3311 break;
3312 default:
3313 pr_debug("invalid sep aes key size %x\n",
3314 keylen);
3315 return -EINVAL;
3316 }
3317
3318 memset(&sctx->key.aes, 0, sizeof(u32) *
3319 SEP_AES_MAX_KEY_SIZE_WORDS);
3320 memcpy(&sctx->key.aes, key, keylen);
3321 sctx->keylen = keylen;
3322 /* Indicate to encrypt/decrypt function to send key to SEP */
3323 sctx->key_sent = 0;
3324
3325 return 0;
3326 }
3327
3328 static int sep_aes_ecb_encrypt(struct ablkcipher_request *req)
3329 {
3330 int error;
3331 int error1;
3332 struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
3333
3334 pr_debug("sep - doing aes ecb encrypt\n");
3335
3336 /* Clear out task context */
3337 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3338
3339 ta_ctx->sep_used = sep_dev;
3340 ta_ctx->current_request = AES_ECB;
3341 ta_ctx->current_hash_req = NULL;
3342 ta_ctx->current_cypher_req = req;
3343 ta_ctx->aes_encmode = SEP_AES_ENCRYPT;
3344 ta_ctx->aes_opmode = SEP_AES_ECB;
3345 ta_ctx->init_opcode = SEP_AES_INIT_OPCODE;
3346 ta_ctx->block_opcode = SEP_AES_BLOCK_OPCODE;
3347
3348 /* lock necessary so that only one entity touches the queues */
3349 spin_lock_irq(&queue_lock);
3350 error = crypto_enqueue_request(&sep_queue, &req->base);
3351
3352 if ((error != 0) && (error != -EINPROGRESS))
3353 pr_debug(" sep - crypto enqueue failed: %x\n",
3354 error);
3355 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3356 sep_dequeuer, (void *)&sep_queue);
3357 if (error1)
3358 pr_debug(" sep - workqueue submit failed: %x\n",
3359 error1);
3360 spin_unlock_irq(&queue_lock);
3361 /* We return result of crypto enqueue */
3362 return error;
3363 }
3364
3365 static int sep_aes_ecb_decrypt(struct ablkcipher_request *req)
3366 {
3367 int error;
3368 int error1;
3369 struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
3370
3371 pr_debug("sep - doing aes ecb decrypt\n");
3372
3373 /* Clear out task context */
3374 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3375
3376 ta_ctx->sep_used = sep_dev;
3377 ta_ctx->current_request = AES_ECB;
3378 ta_ctx->current_hash_req = NULL;
3379 ta_ctx->current_cypher_req = req;
3380 ta_ctx->aes_encmode = SEP_AES_DECRYPT;
3381 ta_ctx->aes_opmode = SEP_AES_ECB;
3382 ta_ctx->init_opcode = SEP_AES_INIT_OPCODE;
3383 ta_ctx->block_opcode = SEP_AES_BLOCK_OPCODE;
3384
3385 /* lock necessary so that only one entity touches the queues */
3386 spin_lock_irq(&queue_lock);
3387 error = crypto_enqueue_request(&sep_queue, &req->base);
3388
3389 if ((error != 0) && (error != -EINPROGRESS))
3390 pr_debug(" sep - crypto enqueue failed: %x\n",
3391 error);
3392 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3393 sep_dequeuer, (void *)&sep_queue);
3394 if (error1)
3395 pr_debug(" sep - workqueue submit failed: %x\n",
3396 error1);
3397 spin_unlock_irq(&queue_lock);
3398 /* We return result of crypto enqueue */
3399 return error;
3400 }
3401
3402 static int sep_aes_cbc_encrypt(struct ablkcipher_request *req)
3403 {
3404 int error;
3405 int error1;
3406 struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
3407 struct sep_system_ctx *sctx = crypto_ablkcipher_ctx(
3408 crypto_ablkcipher_reqtfm(req));
3409
3410 pr_debug("sep - doing aes cbc encrypt\n");
3411
3412 /* Clear out task context */
3413 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3414
3415 pr_debug("tfm is %p sctx is %p and ta_ctx is %p\n",
3416 crypto_ablkcipher_reqtfm(req), sctx, ta_ctx);
3417
3418 ta_ctx->sep_used = sep_dev;
3419 ta_ctx->current_request = AES_CBC;
3420 ta_ctx->current_hash_req = NULL;
3421 ta_ctx->current_cypher_req = req;
3422 ta_ctx->aes_encmode = SEP_AES_ENCRYPT;
3423 ta_ctx->aes_opmode = SEP_AES_CBC;
3424 ta_ctx->init_opcode = SEP_AES_INIT_OPCODE;
3425 ta_ctx->block_opcode = SEP_AES_BLOCK_OPCODE;
3426
3427 /* lock necessary so that only one entity touches the queues */
3428 spin_lock_irq(&queue_lock);
3429 error = crypto_enqueue_request(&sep_queue, &req->base);
3430
3431 if ((error != 0) && (error != -EINPROGRESS))
3432 pr_debug(" sep - crypto enqueue failed: %x\n",
3433 error);
3434 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3435 sep_dequeuer, (void *)&sep_queue);
3436 if (error1)
3437 pr_debug(" sep - workqueue submit failed: %x\n",
3438 error1);
3439 spin_unlock_irq(&queue_lock);
3440 /* We return result of crypto enqueue */
3441 return error;
3442 }
3443
3444 static int sep_aes_cbc_decrypt(struct ablkcipher_request *req)
3445 {
3446 int error;
3447 int error1;
3448 struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
3449 struct sep_system_ctx *sctx = crypto_ablkcipher_ctx(
3450 crypto_ablkcipher_reqtfm(req));
3451
3452 pr_debug("sep - doing aes cbc decrypt\n");
3453
3454 pr_debug("tfm is %p sctx is %p and ta_ctx is %p\n",
3455 crypto_ablkcipher_reqtfm(req), sctx, ta_ctx);
3456
3457 /* Clear out task context */
3458 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3459
3460 ta_ctx->sep_used = sep_dev;
3461 ta_ctx->current_request = AES_CBC;
3462 ta_ctx->current_hash_req = NULL;
3463 ta_ctx->current_cypher_req = req;
3464 ta_ctx->aes_encmode = SEP_AES_DECRYPT;
3465 ta_ctx->aes_opmode = SEP_AES_CBC;
3466 ta_ctx->init_opcode = SEP_AES_INIT_OPCODE;
3467 ta_ctx->block_opcode = SEP_AES_BLOCK_OPCODE;
3468
3469 /* lock necessary so that only one entity touches the queues */
3470 spin_lock_irq(&queue_lock);
3471 error = crypto_enqueue_request(&sep_queue, &req->base);
3472
3473 if ((error != 0) && (error != -EINPROGRESS))
3474 pr_debug(" sep - crypto enqueue failed: %x\n",
3475 error);
3476 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3477 sep_dequeuer, (void *)&sep_queue);
3478 if (error1)
3479 pr_debug(" sep - workqueue submit failed: %x\n",
3480 error1);
3481 spin_unlock_irq(&queue_lock);
3482 /* We return result of crypto enqueue */
3483 return error;
3484 }
3485
3486 static int sep_des_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
3487 unsigned int keylen)
3488 {
3489 struct sep_system_ctx *sctx = crypto_ablkcipher_ctx(tfm);
3490 struct crypto_tfm *ctfm = crypto_ablkcipher_tfm(tfm);
3491 u32 *flags = &ctfm->crt_flags;
3492
3493 pr_debug("sep des setkey\n");
3494
3495 switch (keylen) {
3496 case DES_KEY_SIZE:
3497 sctx->des_nbr_keys = DES_KEY_1;
3498 break;
3499 case DES_KEY_SIZE * 2:
3500 sctx->des_nbr_keys = DES_KEY_2;
3501 break;
3502 case DES_KEY_SIZE * 3:
3503 sctx->des_nbr_keys = DES_KEY_3;
3504 break;
3505 default:
3506 pr_debug("invalid key size %x\n",
3507 keylen);
3508 return -EINVAL;
3509 }
3510
3511 if ((*flags & CRYPTO_TFM_REQ_WEAK_KEY) &&
3512 (sep_weak_key(key, keylen))) {
3513
3514 *flags |= CRYPTO_TFM_RES_WEAK_KEY;
3515 pr_debug("weak key\n");
3516 return -EINVAL;
3517 }
3518
3519 memset(&sctx->key.des, 0, sizeof(struct sep_des_key));
3520 memcpy(&sctx->key.des.key1, key, keylen);
3521 sctx->keylen = keylen;
3522 /* Indicate to encrypt/decrypt function to send key to SEP */
3523 sctx->key_sent = 0;
3524
3525 return 0;
3526 }
3527
3528 static int sep_des_ebc_encrypt(struct ablkcipher_request *req)
3529 {
3530 int error;
3531 int error1;
3532 struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
3533
3534 pr_debug("sep - doing des ecb encrypt\n");
3535
3536 /* Clear out task context */
3537 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3538
3539 ta_ctx->sep_used = sep_dev;
3540 ta_ctx->current_request = DES_ECB;
3541 ta_ctx->current_hash_req = NULL;
3542 ta_ctx->current_cypher_req = req;
3543 ta_ctx->des_encmode = SEP_DES_ENCRYPT;
3544 ta_ctx->des_opmode = SEP_DES_ECB;
3545 ta_ctx->init_opcode = SEP_DES_INIT_OPCODE;
3546 ta_ctx->block_opcode = SEP_DES_BLOCK_OPCODE;
3547
3548 /* lock necessary so that only one entity touches the queues */
3549 spin_lock_irq(&queue_lock);
3550 error = crypto_enqueue_request(&sep_queue, &req->base);
3551
3552 if ((error != 0) && (error != -EINPROGRESS))
3553 pr_debug(" sep - crypto enqueue failed: %x\n",
3554 error);
3555 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3556 sep_dequeuer, (void *)&sep_queue);
3557 if (error1)
3558 pr_debug(" sep - workqueue submit failed: %x\n",
3559 error1);
3560 spin_unlock_irq(&queue_lock);
3561 /* We return result of crypto enqueue */
3562 return error;
3563 }
3564
3565 static int sep_des_ebc_decrypt(struct ablkcipher_request *req)
3566 {
3567 int error;
3568 int error1;
3569 struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
3570
3571 pr_debug("sep - doing des ecb decrypt\n");
3572
3573 /* Clear out task context */
3574 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3575
3576 ta_ctx->sep_used = sep_dev;
3577 ta_ctx->current_request = DES_ECB;
3578 ta_ctx->current_hash_req = NULL;
3579 ta_ctx->current_cypher_req = req;
3580 ta_ctx->des_encmode = SEP_DES_DECRYPT;
3581 ta_ctx->des_opmode = SEP_DES_ECB;
3582 ta_ctx->init_opcode = SEP_DES_INIT_OPCODE;
3583 ta_ctx->block_opcode = SEP_DES_BLOCK_OPCODE;
3584
3585 /* lock necessary so that only one entity touches the queues */
3586 spin_lock_irq(&queue_lock);
3587 error = crypto_enqueue_request(&sep_queue, &req->base);
3588
3589 if ((error != 0) && (error != -EINPROGRESS))
3590 pr_debug(" sep - crypto enqueue failed: %x\n",
3591 error);
3592 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3593 sep_dequeuer, (void *)&sep_queue);
3594 if (error1)
3595 pr_debug(" sep - workqueue submit failed: %x\n",
3596 error1);
3597 spin_unlock_irq(&queue_lock);
3598 /* We return result of crypto enqueue */
3599 return error;
3600 }
3601
3602 static int sep_des_cbc_encrypt(struct ablkcipher_request *req)
3603 {
3604 int error;
3605 int error1;
3606 struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
3607
3608 pr_debug("sep - doing des cbc encrypt\n");
3609
3610 /* Clear out task context */
3611 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3612
3613 ta_ctx->sep_used = sep_dev;
3614 ta_ctx->current_request = DES_CBC;
3615 ta_ctx->current_hash_req = NULL;
3616 ta_ctx->current_cypher_req = req;
3617 ta_ctx->des_encmode = SEP_DES_ENCRYPT;
3618 ta_ctx->des_opmode = SEP_DES_CBC;
3619 ta_ctx->init_opcode = SEP_DES_INIT_OPCODE;
3620 ta_ctx->block_opcode = SEP_DES_BLOCK_OPCODE;
3621
3622 /* lock necessary so that only one entity touches the queues */
3623 spin_lock_irq(&queue_lock);
3624 error = crypto_enqueue_request(&sep_queue, &req->base);
3625
3626 if ((error != 0) && (error != -EINPROGRESS))
3627 pr_debug(" sep - crypto enqueue failed: %x\n",
3628 error);
3629 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3630 sep_dequeuer, (void *)&sep_queue);
3631 if (error1)
3632 pr_debug(" sep - workqueue submit failed: %x\n",
3633 error1);
3634 spin_unlock_irq(&queue_lock);
3635 /* We return result of crypto enqueue */
3636 return error;
3637 }
3638
3639 static int sep_des_cbc_decrypt(struct ablkcipher_request *req)
3640 {
3641 int error;
3642 int error1;
3643 struct this_task_ctx *ta_ctx = ablkcipher_request_ctx(req);
3644
3645 pr_debug("sep - doing des ecb decrypt\n");
3646
3647 /* Clear out task context */
3648 memset(ta_ctx, 0, sizeof(struct this_task_ctx));
3649
3650 ta_ctx->sep_used = sep_dev;
3651 ta_ctx->current_request = DES_CBC;
3652 ta_ctx->current_hash_req = NULL;
3653 ta_ctx->current_cypher_req = req;
3654 ta_ctx->des_encmode = SEP_DES_DECRYPT;
3655 ta_ctx->des_opmode = SEP_DES_CBC;
3656 ta_ctx->init_opcode = SEP_DES_INIT_OPCODE;
3657 ta_ctx->block_opcode = SEP_DES_BLOCK_OPCODE;
3658
3659 /* lock necessary so that only one entity touches the queues */
3660 spin_lock_irq(&queue_lock);
3661 error = crypto_enqueue_request(&sep_queue, &req->base);
3662
3663 if ((error != 0) && (error != -EINPROGRESS))
3664 pr_debug(" sep - crypto enqueue failed: %x\n",
3665 error);
3666 error1 = sep_submit_work(ta_ctx->sep_used->workqueue,
3667 sep_dequeuer, (void *)&sep_queue);
3668 if (error1)
3669 pr_debug(" sep - workqueue submit failed: %x\n",
3670 error1);
3671 spin_unlock_irq(&queue_lock);
3672 /* We return result of crypto enqueue */
3673 return error;
3674 }
3675
3676 static struct ahash_alg hash_algs[] = {
3677 {
3678 .init = sep_sha1_init,
3679 .update = sep_sha1_update,
3680 .final = sep_sha1_final,
3681 .digest = sep_sha1_digest,
3682 .finup = sep_sha1_finup,
3683 .halg = {
3684 .digestsize = SHA1_DIGEST_SIZE,
3685 .base = {
3686 .cra_name = "sha1",
3687 .cra_driver_name = "sha1-sep",
3688 .cra_priority = 100,
3689 .cra_flags = CRYPTO_ALG_TYPE_AHASH |
3690 CRYPTO_ALG_ASYNC,
3691 .cra_blocksize = SHA1_BLOCK_SIZE,
3692 .cra_ctxsize = sizeof(struct sep_system_ctx),
3693 .cra_alignmask = 0,
3694 .cra_module = THIS_MODULE,
3695 .cra_init = sep_hash_cra_init,
3696 .cra_exit = sep_hash_cra_exit,
3697 }
3698 }
3699 },
3700 {
3701 .init = sep_md5_init,
3702 .update = sep_md5_update,
3703 .final = sep_md5_final,
3704 .digest = sep_md5_digest,
3705 .finup = sep_md5_finup,
3706 .halg = {
3707 .digestsize = MD5_DIGEST_SIZE,
3708 .base = {
3709 .cra_name = "md5",
3710 .cra_driver_name = "md5-sep",
3711 .cra_priority = 100,
3712 .cra_flags = CRYPTO_ALG_TYPE_AHASH |
3713 CRYPTO_ALG_ASYNC,
3714 .cra_blocksize = SHA1_BLOCK_SIZE,
3715 .cra_ctxsize = sizeof(struct sep_system_ctx),
3716 .cra_alignmask = 0,
3717 .cra_module = THIS_MODULE,
3718 .cra_init = sep_hash_cra_init,
3719 .cra_exit = sep_hash_cra_exit,
3720 }
3721 }
3722 },
3723 {
3724 .init = sep_sha224_init,
3725 .update = sep_sha224_update,
3726 .final = sep_sha224_final,
3727 .digest = sep_sha224_digest,
3728 .finup = sep_sha224_finup,
3729 .halg = {
3730 .digestsize = SHA224_DIGEST_SIZE,
3731 .base = {
3732 .cra_name = "sha224",
3733 .cra_driver_name = "sha224-sep",
3734 .cra_priority = 100,
3735 .cra_flags = CRYPTO_ALG_TYPE_AHASH |
3736 CRYPTO_ALG_ASYNC,
3737 .cra_blocksize = SHA224_BLOCK_SIZE,
3738 .cra_ctxsize = sizeof(struct sep_system_ctx),
3739 .cra_alignmask = 0,
3740 .cra_module = THIS_MODULE,
3741 .cra_init = sep_hash_cra_init,
3742 .cra_exit = sep_hash_cra_exit,
3743 }
3744 }
3745 },
3746 {
3747 .init = sep_sha256_init,
3748 .update = sep_sha256_update,
3749 .final = sep_sha256_final,
3750 .digest = sep_sha256_digest,
3751 .finup = sep_sha256_finup,
3752 .halg = {
3753 .digestsize = SHA256_DIGEST_SIZE,
3754 .base = {
3755 .cra_name = "sha256",
3756 .cra_driver_name = "sha256-sep",
3757 .cra_priority = 100,
3758 .cra_flags = CRYPTO_ALG_TYPE_AHASH |
3759 CRYPTO_ALG_ASYNC,
3760 .cra_blocksize = SHA256_BLOCK_SIZE,
3761 .cra_ctxsize = sizeof(struct sep_system_ctx),
3762 .cra_alignmask = 0,
3763 .cra_module = THIS_MODULE,
3764 .cra_init = sep_hash_cra_init,
3765 .cra_exit = sep_hash_cra_exit,
3766 }
3767 }
3768 }
3769 };
3770
3771 static struct crypto_alg crypto_algs[] = {
3772 {
3773 .cra_name = "ecb(aes)",
3774 .cra_driver_name = "ecb-aes-sep",
3775 .cra_priority = 100,
3776 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
3777 .cra_blocksize = AES_BLOCK_SIZE,
3778 .cra_ctxsize = sizeof(struct sep_system_ctx),
3779 .cra_alignmask = 0,
3780 .cra_type = &crypto_ablkcipher_type,
3781 .cra_module = THIS_MODULE,
3782 .cra_init = sep_crypto_init,
3783 .cra_exit = sep_crypto_exit,
3784 .cra_u.ablkcipher = {
3785 .min_keysize = AES_MIN_KEY_SIZE,
3786 .max_keysize = AES_MAX_KEY_SIZE,
3787 .setkey = sep_aes_setkey,
3788 .encrypt = sep_aes_ecb_encrypt,
3789 .decrypt = sep_aes_ecb_decrypt,
3790 }
3791 },
3792 {
3793 .cra_name = "cbc(aes)",
3794 .cra_driver_name = "cbc-aes-sep",
3795 .cra_priority = 100,
3796 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
3797 .cra_blocksize = AES_BLOCK_SIZE,
3798 .cra_ctxsize = sizeof(struct sep_system_ctx),
3799 .cra_alignmask = 0,
3800 .cra_type = &crypto_ablkcipher_type,
3801 .cra_module = THIS_MODULE,
3802 .cra_init = sep_crypto_init,
3803 .cra_exit = sep_crypto_exit,
3804 .cra_u.ablkcipher = {
3805 .min_keysize = AES_MIN_KEY_SIZE,
3806 .max_keysize = AES_MAX_KEY_SIZE,
3807 .setkey = sep_aes_setkey,
3808 .encrypt = sep_aes_cbc_encrypt,
3809 .ivsize = AES_BLOCK_SIZE,
3810 .decrypt = sep_aes_cbc_decrypt,
3811 }
3812 },
3813 {
3814 .cra_name = "ebc(des)",
3815 .cra_driver_name = "ebc-des-sep",
3816 .cra_priority = 100,
3817 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
3818 .cra_blocksize = DES_BLOCK_SIZE,
3819 .cra_ctxsize = sizeof(struct sep_system_ctx),
3820 .cra_alignmask = 0,
3821 .cra_type = &crypto_ablkcipher_type,
3822 .cra_module = THIS_MODULE,
3823 .cra_init = sep_crypto_init,
3824 .cra_exit = sep_crypto_exit,
3825 .cra_u.ablkcipher = {
3826 .min_keysize = DES_KEY_SIZE,
3827 .max_keysize = DES_KEY_SIZE,
3828 .setkey = sep_des_setkey,
3829 .encrypt = sep_des_ebc_encrypt,
3830 .decrypt = sep_des_ebc_decrypt,
3831 }
3832 },
3833 {
3834 .cra_name = "cbc(des)",
3835 .cra_driver_name = "cbc-des-sep",
3836 .cra_priority = 100,
3837 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
3838 .cra_blocksize = DES_BLOCK_SIZE,
3839 .cra_ctxsize = sizeof(struct sep_system_ctx),
3840 .cra_alignmask = 0,
3841 .cra_type = &crypto_ablkcipher_type,
3842 .cra_module = THIS_MODULE,
3843 .cra_init = sep_crypto_init,
3844 .cra_exit = sep_crypto_exit,
3845 .cra_u.ablkcipher = {
3846 .min_keysize = DES_KEY_SIZE,
3847 .max_keysize = DES_KEY_SIZE,
3848 .setkey = sep_des_setkey,
3849 .encrypt = sep_des_cbc_encrypt,
3850 .ivsize = DES_BLOCK_SIZE,
3851 .decrypt = sep_des_cbc_decrypt,
3852 }
3853 },
3854 {
3855 .cra_name = "ebc(des3-ede)",
3856 .cra_driver_name = "ebc-des3-ede-sep",
3857 .cra_priority = 100,
3858 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
3859 .cra_blocksize = DES_BLOCK_SIZE,
3860 .cra_ctxsize = sizeof(struct sep_system_ctx),
3861 .cra_alignmask = 0,
3862 .cra_type = &crypto_ablkcipher_type,
3863 .cra_module = THIS_MODULE,
3864 .cra_init = sep_crypto_init,
3865 .cra_exit = sep_crypto_exit,
3866 .cra_u.ablkcipher = {
3867 .min_keysize = DES3_EDE_KEY_SIZE,
3868 .max_keysize = DES3_EDE_KEY_SIZE,
3869 .setkey = sep_des_setkey,
3870 .encrypt = sep_des_ebc_encrypt,
3871 .decrypt = sep_des_ebc_decrypt,
3872 }
3873 },
3874 {
3875 .cra_name = "cbc(des3-ede)",
3876 .cra_driver_name = "cbc-des3--ede-sep",
3877 .cra_priority = 100,
3878 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
3879 .cra_blocksize = DES_BLOCK_SIZE,
3880 .cra_ctxsize = sizeof(struct sep_system_ctx),
3881 .cra_alignmask = 0,
3882 .cra_type = &crypto_ablkcipher_type,
3883 .cra_module = THIS_MODULE,
3884 .cra_init = sep_crypto_init,
3885 .cra_exit = sep_crypto_exit,
3886 .cra_u.ablkcipher = {
3887 .min_keysize = DES3_EDE_KEY_SIZE,
3888 .max_keysize = DES3_EDE_KEY_SIZE,
3889 .setkey = sep_des_setkey,
3890 .encrypt = sep_des_cbc_encrypt,
3891 .decrypt = sep_des_cbc_decrypt,
3892 }
3893 }
3894 };
3895
3896 int sep_crypto_setup(void)
3897 {
3898 int err, i, j, k;
3899 tasklet_init(&sep_dev->finish_tasklet, sep_finish,
3900 (unsigned long)sep_dev);
3901
3902 crypto_init_queue(&sep_queue, SEP_QUEUE_LENGTH);
3903
3904 sep_dev->workqueue = create_singlethread_workqueue(
3905 "sep_crypto_workqueue");
3906 if (!sep_dev->workqueue) {
3907 dev_warn(&sep_dev->pdev->dev, "cant create workqueue\n");
3908 return -ENOMEM;
3909 }
3910
3911 i = 0;
3912 j = 0;
3913
3914 spin_lock_init(&queue_lock);
3915
3916 err = 0;
3917
3918 for (i = 0; i < ARRAY_SIZE(hash_algs); i++) {
3919 err = crypto_register_ahash(&hash_algs[i]);
3920 if (err)
3921 goto err_algs;
3922 }
3923
3924 err = 0;
3925 for (j = 0; j < ARRAY_SIZE(crypto_algs); j++) {
3926 err = crypto_register_alg(&crypto_algs[j]);
3927 if (err)
3928 goto err_crypto_algs;
3929 }
3930
3931 return err;
3932
3933 err_algs:
3934 for (k = 0; k < i; k++)
3935 crypto_unregister_ahash(&hash_algs[k]);
3936 return err;
3937
3938 err_crypto_algs:
3939 for (k = 0; k < j; k++)
3940 crypto_unregister_alg(&crypto_algs[k]);
3941 goto err_algs;
3942 }
3943
3944 void sep_crypto_takedown(void)
3945 {
3946
3947 int i;
3948
3949 for (i = 0; i < ARRAY_SIZE(hash_algs); i++)
3950 crypto_unregister_ahash(&hash_algs[i]);
3951 for (i = 0; i < ARRAY_SIZE(crypto_algs); i++)
3952 crypto_unregister_alg(&crypto_algs[i]);
3953
3954 tasklet_kill(&sep_dev->finish_tasklet);
3955 }
3956
3957 #endif
Linux ARM platform port for MOXA ART SoC