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