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