?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pull master
[hh.org.git] / arch / cris / arch-v32 / drivers / cryptocop.c
blob2449637e6fc0ab1bad494dbec05de816f2c12d74
1 /* $Id: cryptocop.c,v 1.13 2005/04/21 17:27:55 henriken Exp $
2 *
3 * Stream co-processor driver for the ETRAX FS
4 *
5 * Copyright (C) 2003-2005 Axis Communications AB
6 */
7
8 #include <linux/init.h>
9 #include <linux/sched.h>
10 #include <linux/module.h>
11 #include <linux/slab.h>
12 #include <linux/string.h>
13 #include <linux/fs.h>
14 #include <linux/mm.h>
15 #include <linux/spinlock.h>
16 #include <linux/stddef.h>
17
18 #include <asm/uaccess.h>
19 #include <asm/io.h>
20 #include <asm/atomic.h>
21
22 #include <linux/list.h>
23 #include <linux/interrupt.h>
24
25 #include <asm/signal.h>
26 #include <asm/irq.h>
27
28 #include <asm/arch/dma.h>
29 #include <asm/arch/hwregs/dma.h>
30 #include <asm/arch/hwregs/reg_map.h>
31 #include <asm/arch/hwregs/reg_rdwr.h>
32 #include <asm/arch/hwregs/intr_vect_defs.h>
33
34 #include <asm/arch/hwregs/strcop.h>
35 #include <asm/arch/hwregs/strcop_defs.h>
36 #include <asm/arch/cryptocop.h>
37
38
39
40 #define DESCR_ALLOC_PAD (31)
41
42 struct cryptocop_dma_desc {
43 char *free_buf; /* If non-null will be kfreed in free_cdesc() */
44 dma_descr_data *dma_descr;
45
46 unsigned char dma_descr_buf[sizeof(dma_descr_data) + DESCR_ALLOC_PAD];
47
48 unsigned int from_pool:1; /* If 1 'allocated' from the descriptor pool. */
49 struct cryptocop_dma_desc *next;
50 };
51
52
53 struct cryptocop_int_operation{
54 void *alloc_ptr;
55 cryptocop_session_id sid;
56
57 dma_descr_context ctx_out;
58 dma_descr_context ctx_in;
59
60 /* DMA descriptors allocated by driver. */
61 struct cryptocop_dma_desc *cdesc_out;
62 struct cryptocop_dma_desc *cdesc_in;
63
64 /* Strcop config to use. */
65 cryptocop_3des_mode tdes_mode;
66 cryptocop_csum_type csum_mode;
67
68 /* DMA descrs provided by consumer. */
69 dma_descr_data *ddesc_out;
70 dma_descr_data *ddesc_in;
71 };
72
73
74 struct cryptocop_tfrm_ctx {
75 cryptocop_tfrm_id tid;
76 unsigned int blocklength;
77
78 unsigned int start_ix;
79
80 struct cryptocop_tfrm_cfg *tcfg;
81 struct cryptocop_transform_ctx *tctx;
82
83 unsigned char previous_src;
84 unsigned char current_src;
85
86 /* Values to use in metadata out. */
87 unsigned char hash_conf;
88 unsigned char hash_mode;
89 unsigned char ciph_conf;
90 unsigned char cbcmode;
91 unsigned char decrypt;
92
93 unsigned int requires_padding:1;
94 unsigned int strict_block_length:1;
95 unsigned int active:1;
96 unsigned int done:1;
97 size_t consumed;
98 size_t produced;
99
100 /* Pad (input) descriptors to put in the DMA out list when the transform
101 * output is put on the DMA in list. */
102 struct cryptocop_dma_desc *pad_descs;
103
104 struct cryptocop_tfrm_ctx *prev_src;
105 struct cryptocop_tfrm_ctx *curr_src;
106
107 /* Mapping to HW. */
108 unsigned char unit_no;
109 };
110
111
112 struct cryptocop_private{
113 cryptocop_session_id sid;
114 struct cryptocop_private *next;
115 };
116
117 /* Session list. */
118
119 struct cryptocop_transform_ctx{
120 struct cryptocop_transform_init init;
121 unsigned char dec_key[CRYPTOCOP_MAX_KEY_LENGTH];
122 unsigned int dec_key_set:1;
123
124 struct cryptocop_transform_ctx *next;
125 };
126
127
128 struct cryptocop_session{
129 cryptocop_session_id sid;
130
131 struct cryptocop_transform_ctx *tfrm_ctx;
132
133 struct cryptocop_session *next;
134 };
135
136 /* Priority levels for jobs sent to the cryptocop. Checksum operations from
137 kernel have highest priority since TCPIP stack processing must not
138 be a bottleneck. */
139 typedef enum {
140 cryptocop_prio_kernel_csum = 0,
141 cryptocop_prio_kernel = 1,
142 cryptocop_prio_user = 2,
143 cryptocop_prio_no_prios = 3
144 } cryptocop_queue_priority;
145
146 struct cryptocop_prio_queue{
147 struct list_head jobs;
148 cryptocop_queue_priority prio;
149 };
150
151 struct cryptocop_prio_job{
152 struct list_head node;
153 cryptocop_queue_priority prio;
154
155 struct cryptocop_operation *oper;
156 struct cryptocop_int_operation *iop;
157 };
158
159 struct ioctl_job_cb_ctx {
160 unsigned int processed:1;
161 };
162
163
164 static struct cryptocop_session *cryptocop_sessions = NULL;
165 spinlock_t cryptocop_sessions_lock;
166
167 /* Next Session ID to assign. */
168 static cryptocop_session_id next_sid = 1;
169
170 /* Pad for checksum. */
171 static const char csum_zero_pad[1] = {0x00};
172
173 /* Trash buffer for mem2mem operations. */
174 #define MEM2MEM_DISCARD_BUF_LENGTH (512)
175 static unsigned char mem2mem_discard_buf[MEM2MEM_DISCARD_BUF_LENGTH];
176
177 /* Descriptor pool. */
178 /* FIXME Tweak this value. */
179 #define CRYPTOCOP_DESCRIPTOR_POOL_SIZE (100)
180 static struct cryptocop_dma_desc descr_pool[CRYPTOCOP_DESCRIPTOR_POOL_SIZE];
181 static struct cryptocop_dma_desc *descr_pool_free_list;
182 static int descr_pool_no_free;
183 static spinlock_t descr_pool_lock;
184
185 /* Lock to stop cryptocop to start processing of a new operation. The holder
186 of this lock MUST call cryptocop_start_job() after it is unlocked. */
187 spinlock_t cryptocop_process_lock;
188
189 static struct cryptocop_prio_queue cryptocop_job_queues[cryptocop_prio_no_prios];
190 static spinlock_t cryptocop_job_queue_lock;
191 static struct cryptocop_prio_job *cryptocop_running_job = NULL;
192 static spinlock_t running_job_lock;
193
194 /* The interrupt handler appends completed jobs to this list. The scehduled
195 * tasklet removes them upon sending the response to the crypto consumer. */
196 static struct list_head cryptocop_completed_jobs;
197 static spinlock_t cryptocop_completed_jobs_lock;
198
199 DECLARE_WAIT_QUEUE_HEAD(cryptocop_ioc_process_wq);
200
201
202 /** Local functions. **/
203
204 static int cryptocop_open(struct inode *, struct file *);
205
206 static int cryptocop_release(struct inode *, struct file *);
207
208 static int cryptocop_ioctl(struct inode *inode, struct file *file,
209 unsigned int cmd, unsigned long arg);
210
211 static void cryptocop_start_job(void);
212
213 static int cryptocop_job_queue_insert(cryptocop_queue_priority prio, struct cryptocop_operation *operation);
214 static int cryptocop_job_setup(struct cryptocop_prio_job **pj, struct cryptocop_operation *operation);
215
216 static int cryptocop_job_queue_init(void);
217 static void cryptocop_job_queue_close(void);
218
219 static int create_md5_pad(int alloc_flag, unsigned long long hashed_length, char **pad, size_t *pad_length);
220
221 static int create_sha1_pad(int alloc_flag, unsigned long long hashed_length, char **pad, size_t *pad_length);
222
223 static int transform_ok(struct cryptocop_transform_init *tinit);
224
225 static struct cryptocop_session *get_session(cryptocop_session_id sid);
226
227 static struct cryptocop_transform_ctx *get_transform_ctx(struct cryptocop_session *sess, cryptocop_tfrm_id tid);
228
229 static void delete_internal_operation(struct cryptocop_int_operation *iop);
230
231 static void get_aes_decrypt_key(unsigned char *dec_key, const unsigned char *key, unsigned int keylength);
232
233 static int init_stream_coprocessor(void);
234
235 static void __exit exit_stream_coprocessor(void);
236
237 /*#define LDEBUG*/
238 #ifdef LDEBUG
239 #define DEBUG(s) s
240 #define DEBUG_API(s) s
241 static void print_cryptocop_operation(struct cryptocop_operation *cop);
242 static void print_dma_descriptors(struct cryptocop_int_operation *iop);
243 static void print_strcop_crypto_op(struct strcop_crypto_op *cop);
244 static void print_lock_status(void);
245 static void print_user_dma_lists(struct cryptocop_dma_list_operation *dma_op);
246 #define assert(s) do{if (!(s)) panic(#s);} while(0);
247 #else
248 #define DEBUG(s)
249 #define DEBUG_API(s)
250 #define assert(s)
251 #endif
252
253
254 /* Transform constants. */
255 #define DES_BLOCK_LENGTH (8)
256 #define AES_BLOCK_LENGTH (16)
257 #define MD5_BLOCK_LENGTH (64)
258 #define SHA1_BLOCK_LENGTH (64)
259 #define CSUM_BLOCK_LENGTH (2)
260 #define MD5_STATE_LENGTH (16)
261 #define SHA1_STATE_LENGTH (20)
262
263 /* The device number. */
264 #define CRYPTOCOP_MAJOR (254)
265 #define CRYPTOCOP_MINOR (0)
266
267
268
269 struct file_operations cryptocop_fops = {
270 owner: THIS_MODULE,
271 open: cryptocop_open,
272 release: cryptocop_release,
273 ioctl: cryptocop_ioctl
274 };
275
276
277 static void free_cdesc(struct cryptocop_dma_desc *cdesc)
278 {
279 DEBUG(printk("free_cdesc: cdesc 0x%p, from_pool=%d\n", cdesc, cdesc->from_pool));
280 kfree(cdesc->free_buf);
281
282 if (cdesc->from_pool) {
283 unsigned long int flags;
284 spin_lock_irqsave(&descr_pool_lock, flags);
285 cdesc->next = descr_pool_free_list;
286 descr_pool_free_list = cdesc;
287 ++descr_pool_no_free;
288 spin_unlock_irqrestore(&descr_pool_lock, flags);
289 } else {
290 kfree(cdesc);
291 }
292 }
293
294
295 static struct cryptocop_dma_desc *alloc_cdesc(int alloc_flag)
296 {
297 int use_pool = (alloc_flag & GFP_ATOMIC) ? 1 : 0;
298 struct cryptocop_dma_desc *cdesc;
299
300 if (use_pool) {
301 unsigned long int flags;
302 spin_lock_irqsave(&descr_pool_lock, flags);
303 if (!descr_pool_free_list) {
304 spin_unlock_irqrestore(&descr_pool_lock, flags);
305 DEBUG_API(printk("alloc_cdesc: pool is empty\n"));
306 return NULL;
307 }
308 cdesc = descr_pool_free_list;
309 descr_pool_free_list = descr_pool_free_list->next;
310 --descr_pool_no_free;
311 spin_unlock_irqrestore(&descr_pool_lock, flags);
312 cdesc->from_pool = 1;
313 } else {
314 cdesc = kmalloc(sizeof(struct cryptocop_dma_desc), alloc_flag);
315 if (!cdesc) {
316 DEBUG_API(printk("alloc_cdesc: kmalloc\n"));
317 return NULL;
318 }
319 cdesc->from_pool = 0;
320 }
321 cdesc->dma_descr = (dma_descr_data*)(((unsigned long int)cdesc + offsetof(struct cryptocop_dma_desc, dma_descr_buf) + DESCR_ALLOC_PAD) & ~0x0000001F);
322
323 cdesc->next = NULL;
324
325 cdesc->free_buf = NULL;
326 cdesc->dma_descr->out_eop = 0;
327 cdesc->dma_descr->in_eop = 0;
328 cdesc->dma_descr->intr = 0;
329 cdesc->dma_descr->eol = 0;
330 cdesc->dma_descr->wait = 0;
331 cdesc->dma_descr->buf = NULL;
332 cdesc->dma_descr->after = NULL;
333
334 DEBUG_API(printk("alloc_cdesc: return 0x%p, cdesc->dma_descr=0x%p, from_pool=%d\n", cdesc, cdesc->dma_descr, cdesc->from_pool));
335 return cdesc;
336 }
337
338
339 static void setup_descr_chain(struct cryptocop_dma_desc *cd)
340 {
341 DEBUG(printk("setup_descr_chain: entering\n"));
342 while (cd) {
343 if (cd->next) {
344 cd->dma_descr->next = (dma_descr_data*)virt_to_phys(cd->next->dma_descr);
345 } else {
346 cd->dma_descr->next = NULL;
347 }
348 cd = cd->next;
349 }
350 DEBUG(printk("setup_descr_chain: exit\n"));
351 }
352
353
354 /* Create a pad descriptor for the transform.
355 * Return -1 for error, 0 if pad created. */
356 static int create_pad_descriptor(struct cryptocop_tfrm_ctx *tc, struct cryptocop_dma_desc **pad_desc, int alloc_flag)
357 {
358 struct cryptocop_dma_desc *cdesc = NULL;
359 int error = 0;
360 struct strcop_meta_out mo = {
361 .ciphsel = src_none,
362 .hashsel = src_none,
363 .csumsel = src_none
364 };
365 char *pad;
366 size_t plen;
367
368 DEBUG(printk("create_pad_descriptor: start.\n"));
369 /* Setup pad descriptor. */
370
371 DEBUG(printk("create_pad_descriptor: setting up padding.\n"));
372 cdesc = alloc_cdesc(alloc_flag);
373 if (!cdesc){
374 DEBUG_API(printk("create_pad_descriptor: alloc pad desc\n"));
375 goto error_cleanup;
376 }
377 switch (tc->unit_no) {
378 case src_md5:
379 error = create_md5_pad(alloc_flag, tc->consumed, &pad, &plen);
380 if (error){
381 DEBUG_API(printk("create_pad_descriptor: create_md5_pad_failed\n"));
382 goto error_cleanup;
383 }
384 cdesc->free_buf = pad;
385 mo.hashsel = src_dma;
386 mo.hashconf = tc->hash_conf;
387 mo.hashmode = tc->hash_mode;
388 break;
389 case src_sha1:
390 error = create_sha1_pad(alloc_flag, tc->consumed, &pad, &plen);
391 if (error){
392 DEBUG_API(printk("create_pad_descriptor: create_sha1_pad_failed\n"));
393 goto error_cleanup;
394 }
395 cdesc->free_buf = pad;
396 mo.hashsel = src_dma;
397 mo.hashconf = tc->hash_conf;
398 mo.hashmode = tc->hash_mode;
399 break;
400 case src_csum:
401 if (tc->consumed % tc->blocklength){
402 pad = (char*)csum_zero_pad;
403 plen = 1;
404 } else {
405 pad = (char*)cdesc; /* Use any pointer. */
406 plen = 0;
407 }
408 mo.csumsel = src_dma;
409 break;
410 }
411 cdesc->dma_descr->wait = 1;
412 cdesc->dma_descr->out_eop = 1; /* Since this is a pad output is pushed. EOP is ok here since the padded unit is the only one active. */
413 cdesc->dma_descr->buf = (char*)virt_to_phys((char*)pad);
414 cdesc->dma_descr->after = cdesc->dma_descr->buf + plen;
415
416 cdesc->dma_descr->md = REG_TYPE_CONV(unsigned short int, struct strcop_meta_out, mo);
417 *pad_desc = cdesc;
418
419 return 0;
420
421 error_cleanup:
422 if (cdesc) free_cdesc(cdesc);
423 return -1;
424 }
425
426
427 static int setup_key_dl_desc(struct cryptocop_tfrm_ctx *tc, struct cryptocop_dma_desc **kd, int alloc_flag)
428 {
429 struct cryptocop_dma_desc *key_desc = alloc_cdesc(alloc_flag);
430 struct strcop_meta_out mo = {0};
431
432 DEBUG(printk("setup_key_dl_desc\n"));
433
434 if (!key_desc) {
435 DEBUG_API(printk("setup_key_dl_desc: failed descriptor allocation.\n"));
436 return -ENOMEM;
437 }
438
439 /* Download key. */
440 if ((tc->tctx->init.alg == cryptocop_alg_aes) && (tc->tcfg->flags & CRYPTOCOP_DECRYPT)) {
441 /* Precook the AES decrypt key. */
442 if (!tc->tctx->dec_key_set){
443 get_aes_decrypt_key(tc->tctx->dec_key, tc->tctx->init.key, tc->tctx->init.keylen);
444 tc->tctx->dec_key_set = 1;
445 }
446 key_desc->dma_descr->buf = (char*)virt_to_phys(tc->tctx->dec_key);
447 key_desc->dma_descr->after = key_desc->dma_descr->buf + tc->tctx->init.keylen/8;
448 } else {
449 key_desc->dma_descr->buf = (char*)virt_to_phys(tc->tctx->init.key);
450 key_desc->dma_descr->after = key_desc->dma_descr->buf + tc->tctx->init.keylen/8;
451 }
452 /* Setup metadata. */
453 mo.dlkey = 1;
454 switch (tc->tctx->init.keylen) {
455 case 64:
456 mo.decrypt = 0;
457 mo.hashmode = 0;
458 break;
459 case 128:
460 mo.decrypt = 0;
461 mo.hashmode = 1;
462 break;
463 case 192:
464 mo.decrypt = 1;
465 mo.hashmode = 0;
466 break;
467 case 256:
468 mo.decrypt = 1;
469 mo.hashmode = 1;
470 break;
471 default:
472 break;
473 }
474 mo.ciphsel = mo.hashsel = mo.csumsel = src_none;
475 key_desc->dma_descr->md = REG_TYPE_CONV(unsigned short int, struct strcop_meta_out, mo);
476
477 key_desc->dma_descr->out_eop = 1;
478 key_desc->dma_descr->wait = 1;
479 key_desc->dma_descr->intr = 0;
480
481 *kd = key_desc;
482 return 0;
483 }
484
485 static int setup_cipher_iv_desc(struct cryptocop_tfrm_ctx *tc, struct cryptocop_dma_desc **id, int alloc_flag)
486 {
487 struct cryptocop_dma_desc *iv_desc = alloc_cdesc(alloc_flag);
488 struct strcop_meta_out mo = {0};
489
490 DEBUG(printk("setup_cipher_iv_desc\n"));
491
492 if (!iv_desc) {
493 DEBUG_API(printk("setup_cipher_iv_desc: failed CBC IV descriptor allocation.\n"));
494 return -ENOMEM;
495 }
496 /* Download IV. */
497 iv_desc->dma_descr->buf = (char*)virt_to_phys(tc->tcfg->iv);
498 iv_desc->dma_descr->after = iv_desc->dma_descr->buf + tc->blocklength;
499
500 /* Setup metadata. */
501 mo.hashsel = mo.csumsel = src_none;
502 mo.ciphsel = src_dma;
503 mo.ciphconf = tc->ciph_conf;
504 mo.cbcmode = tc->cbcmode;
505
506 iv_desc->dma_descr->md = REG_TYPE_CONV(unsigned short int, struct strcop_meta_out, mo);
507
508 iv_desc->dma_descr->out_eop = 0;
509 iv_desc->dma_descr->wait = 1;
510 iv_desc->dma_descr->intr = 0;
511
512 *id = iv_desc;
513 return 0;
514 }
515
516 /* Map the ouput length of the transform to operation output starting on the inject index. */
517 static int create_input_descriptors(struct cryptocop_operation *operation, struct cryptocop_tfrm_ctx *tc, struct cryptocop_dma_desc **id, int alloc_flag)
518 {
519 int err = 0;
520 struct cryptocop_dma_desc head = {0};
521 struct cryptocop_dma_desc *outdesc = &head;
522 size_t iov_offset = 0;
523 size_t out_ix = 0;
524 int outiov_ix = 0;
525 struct strcop_meta_in mi = {0};
526
527 size_t out_length = tc->produced;
528 int rem_length;
529 int dlength;
530
531 assert(out_length != 0);
532 if (((tc->produced + tc->tcfg->inject_ix) > operation->tfrm_op.outlen) || (tc->produced && (operation->tfrm_op.outlen == 0))) {
533 DEBUG_API(printk("create_input_descriptors: operation outdata too small\n"));
534 return -EINVAL;
535 }
536 /* Traverse the out iovec until the result inject index is reached. */
537 while ((outiov_ix < operation->tfrm_op.outcount) && ((out_ix + operation->tfrm_op.outdata[outiov_ix].iov_len) <= tc->tcfg->inject_ix)){
538 out_ix += operation->tfrm_op.outdata[outiov_ix].iov_len;
539 outiov_ix++;
540 }
541 if (outiov_ix >= operation->tfrm_op.outcount){
542 DEBUG_API(printk("create_input_descriptors: operation outdata too small\n"));
543 return -EINVAL;
544 }
545 iov_offset = tc->tcfg->inject_ix - out_ix;
546 mi.dmasel = tc->unit_no;
547
548 /* Setup the output descriptors. */
549 while ((out_length > 0) && (outiov_ix < operation->tfrm_op.outcount)) {
550 outdesc->next = alloc_cdesc(alloc_flag);
551 if (!outdesc->next) {
552 DEBUG_API(printk("create_input_descriptors: alloc_cdesc\n"));
553 err = -ENOMEM;
554 goto error_cleanup;
555 }
556 outdesc = outdesc->next;
557 rem_length = operation->tfrm_op.outdata[outiov_ix].iov_len - iov_offset;
558 dlength = (out_length < rem_length) ? out_length : rem_length;
559
560 DEBUG(printk("create_input_descriptors:\n"
561 "outiov_ix=%d, rem_length=%d, dlength=%d\n"
562 "iov_offset=%d, outdata[outiov_ix].iov_len=%d\n"
563 "outcount=%d, outiov_ix=%d\n",
564 outiov_ix, rem_length, dlength, iov_offset, operation->tfrm_op.outdata[outiov_ix].iov_len, operation->tfrm_op.outcount, outiov_ix));
565
566 outdesc->dma_descr->buf = (char*)virt_to_phys(operation->tfrm_op.outdata[outiov_ix].iov_base + iov_offset);
567 outdesc->dma_descr->after = outdesc->dma_descr->buf + dlength;
568 outdesc->dma_descr->md = REG_TYPE_CONV(unsigned short int, struct strcop_meta_in, mi);
569
570 out_length -= dlength;
571 iov_offset += dlength;
572 if (iov_offset >= operation->tfrm_op.outdata[outiov_ix].iov_len) {
573 iov_offset = 0;
574 ++outiov_ix;
575 }
576 }
577 if (out_length > 0){
578 DEBUG_API(printk("create_input_descriptors: not enough room for output, %d remained\n", out_length));
579 err = -EINVAL;
580 goto error_cleanup;
581 }
582 /* Set sync in last descriptor. */
583 mi.sync = 1;
584 outdesc->dma_descr->md = REG_TYPE_CONV(unsigned short int, struct strcop_meta_in, mi);
585
586 *id = head.next;
587 return 0;
588
589 error_cleanup:
590 while (head.next) {
591 outdesc = head.next->next;
592 free_cdesc(head.next);
593 head.next = outdesc;
594 }
595 return err;
596 }
597
598
599 static int create_output_descriptors(struct cryptocop_operation *operation, int *iniov_ix, int *iniov_offset, size_t desc_len, struct cryptocop_dma_desc **current_out_cdesc, struct strcop_meta_out *meta_out, int alloc_flag)
600 {
601 while (desc_len != 0) {
602 struct cryptocop_dma_desc *cdesc;
603 int rem_length = operation->tfrm_op.indata[*iniov_ix].iov_len - *iniov_offset;
604 int dlength = (desc_len < rem_length) ? desc_len : rem_length;
605
606 cdesc = alloc_cdesc(alloc_flag);
607 if (!cdesc) {
608 DEBUG_API(printk("create_output_descriptors: alloc_cdesc\n"));
609 return -ENOMEM;
610 }
611 (*current_out_cdesc)->next = cdesc;
612 (*current_out_cdesc) = cdesc;
613
614 cdesc->free_buf = NULL;
615
616 cdesc->dma_descr->buf = (char*)virt_to_phys(operation->tfrm_op.indata[*iniov_ix].iov_base + *iniov_offset);
617 cdesc->dma_descr->after = cdesc->dma_descr->buf + dlength;
618
619 desc_len -= dlength;
620 *iniov_offset += dlength;
621 assert(desc_len >= 0);
622 if (*iniov_offset >= operation->tfrm_op.indata[*iniov_ix].iov_len) {
623 *iniov_offset = 0;
624 ++(*iniov_ix);
625 if (*iniov_ix > operation->tfrm_op.incount) {
626 DEBUG_API(printk("create_output_descriptors: not enough indata in operation."));
627 return -EINVAL;
628 }
629 }
630 cdesc->dma_descr->md = REG_TYPE_CONV(unsigned short int, struct strcop_meta_out, (*meta_out));
631 } /* while (desc_len != 0) */
632 /* Last DMA descriptor gets a 'wait' bit to signal expected change in metadata. */
633 (*current_out_cdesc)->dma_descr->wait = 1; /* This will set extraneous WAIT in some situations, e.g. when padding hashes and checksums. */
634
635 return 0;
636 }
637
638
639 static int append_input_descriptors(struct cryptocop_operation *operation, struct cryptocop_dma_desc **current_in_cdesc, struct cryptocop_dma_desc **current_out_cdesc, struct cryptocop_tfrm_ctx *tc, int alloc_flag)
640 {
641 DEBUG(printk("append_input_descriptors, tc=0x%p, unit_no=%d\n", tc, tc->unit_no));
642 if (tc->tcfg) {
643 int failed = 0;
644 struct cryptocop_dma_desc *idescs = NULL;
645 DEBUG(printk("append_input_descriptors: pushing output, consumed %d produced %d bytes.\n", tc->consumed, tc->produced));
646 if (tc->pad_descs) {
647 DEBUG(printk("append_input_descriptors: append pad descriptors to DMA out list.\n"));
648 while (tc->pad_descs) {
649 DEBUG(printk("append descriptor 0x%p\n", tc->pad_descs));
650 (*current_out_cdesc)->next = tc->pad_descs;
651 tc->pad_descs = tc->pad_descs->next;
652 (*current_out_cdesc) = (*current_out_cdesc)->next;
653 }
654 }
655
656 /* Setup and append output descriptors to DMA in list. */
657 if (tc->unit_no == src_dma){
658 /* mem2mem. Setup DMA in descriptors to discard all input prior to the requested mem2mem data. */
659 struct strcop_meta_in mi = {.sync = 0, .dmasel = src_dma};
660 unsigned int start_ix = tc->start_ix;
661 while (start_ix){
662 unsigned int desclen = start_ix < MEM2MEM_DISCARD_BUF_LENGTH ? start_ix : MEM2MEM_DISCARD_BUF_LENGTH;
663 (*current_in_cdesc)->next = alloc_cdesc(alloc_flag);
664 if (!(*current_in_cdesc)->next){
665 DEBUG_API(printk("append_input_descriptors: alloc_cdesc mem2mem discard failed\n"));
666 return -ENOMEM;
667 }
668 (*current_in_cdesc) = (*current_in_cdesc)->next;
669 (*current_in_cdesc)->dma_descr->buf = (char*)virt_to_phys(mem2mem_discard_buf);
670 (*current_in_cdesc)->dma_descr->after = (*current_in_cdesc)->dma_descr->buf + desclen;
671 (*current_in_cdesc)->dma_descr->md = REG_TYPE_CONV(unsigned short int, struct strcop_meta_in, mi);
672 start_ix -= desclen;
673 }
674 mi.sync = 1;
675 (*current_in_cdesc)->dma_descr->md = REG_TYPE_CONV(unsigned short int, struct strcop_meta_in, mi);
676 }
677
678 failed = create_input_descriptors(operation, tc, &idescs, alloc_flag);
679 if (failed){
680 DEBUG_API(printk("append_input_descriptors: output descriptor setup failed\n"));
681 return failed;
682 }
683 DEBUG(printk("append_input_descriptors: append output descriptors to DMA in list.\n"));
684 while (idescs) {
685 DEBUG(printk("append descriptor 0x%p\n", idescs));
686 (*current_in_cdesc)->next = idescs;
687 idescs = idescs->next;
688 (*current_in_cdesc) = (*current_in_cdesc)->next;
689 }
690 }
691 return 0;
692 }
693
694
695
696 static int cryptocop_setup_dma_list(struct cryptocop_operation *operation, struct cryptocop_int_operation **int_op, int alloc_flag)
697 {
698 struct cryptocop_session *sess;
699 struct cryptocop_transform_ctx *tctx;
700
701 struct cryptocop_tfrm_ctx digest_ctx = {
702 .previous_src = src_none,
703 .current_src = src_none,
704 .start_ix = 0,
705 .requires_padding = 1,
706 .strict_block_length = 0,
707 .hash_conf = 0,
708 .hash_mode = 0,
709 .ciph_conf = 0,
710 .cbcmode = 0,
711 .decrypt = 0,
712 .consumed = 0,
713 .produced = 0,
714 .pad_descs = NULL,
715 .active = 0,
716 .done = 0,
717 .prev_src = NULL,
718 .curr_src = NULL,
719 .tcfg = NULL};
720 struct cryptocop_tfrm_ctx cipher_ctx = {
721 .previous_src = src_none,
722 .current_src = src_none,
723 .start_ix = 0,
724 .requires_padding = 0,
725 .strict_block_length = 1,
726 .hash_conf = 0,
727 .hash_mode = 0,
728 .ciph_conf = 0,
729 .cbcmode = 0,
730 .decrypt = 0,
731 .consumed = 0,
732 .produced = 0,
733 .pad_descs = NULL,
734 .active = 0,
735 .done = 0,
736 .prev_src = NULL,
737 .curr_src = NULL,
738 .tcfg = NULL};
739 struct cryptocop_tfrm_ctx csum_ctx = {
740 .previous_src = src_none,
741 .current_src = src_none,
742 .start_ix = 0,
743 .blocklength = 2,
744 .requires_padding = 1,
745 .strict_block_length = 0,
746 .hash_conf = 0,
747 .hash_mode = 0,
748 .ciph_conf = 0,
749 .cbcmode = 0,
750 .decrypt = 0,
751 .consumed = 0,
752 .produced = 0,
753 .pad_descs = NULL,
754 .active = 0,
755 .done = 0,
756 .tcfg = NULL,
757 .prev_src = NULL,
758 .curr_src = NULL,
759 .unit_no = src_csum};
760 struct cryptocop_tfrm_cfg *tcfg = operation->tfrm_op.tfrm_cfg;
761
762 unsigned int indata_ix = 0;
763
764 /* iovec accounting. */
765 int iniov_ix = 0;
766 int iniov_offset = 0;
767
768 /* Operation descriptor cfg traversal pointer. */
769 struct cryptocop_desc *odsc;
770
771 int failed = 0;
772 /* List heads for allocated descriptors. */
773 struct cryptocop_dma_desc out_cdesc_head = {0};
774 struct cryptocop_dma_desc in_cdesc_head = {0};
775
776 struct cryptocop_dma_desc *current_out_cdesc = &out_cdesc_head;
777 struct cryptocop_dma_desc *current_in_cdesc = &in_cdesc_head;
778
779 struct cryptocop_tfrm_ctx *output_tc = NULL;
780 void *iop_alloc_ptr;
781
782 assert(operation != NULL);
783 assert(int_op != NULL);
784
785 DEBUG(printk("cryptocop_setup_dma_list: start\n"));
786 DEBUG(print_cryptocop_operation(operation));
787
788 sess = get_session(operation->sid);
789 if (!sess) {
790 DEBUG_API(printk("cryptocop_setup_dma_list: no session found for operation.\n"));
791 failed = -EINVAL;
792 goto error_cleanup;
793 }
794 iop_alloc_ptr = kmalloc(DESCR_ALLOC_PAD + sizeof(struct cryptocop_int_operation), alloc_flag);
795 if (!iop_alloc_ptr) {
796 DEBUG_API(printk("cryptocop_setup_dma_list: kmalloc cryptocop_int_operation\n"));
797 failed = -ENOMEM;
798 goto error_cleanup;
799 }
800 (*int_op) = (struct cryptocop_int_operation*)(((unsigned long int)(iop_alloc_ptr + DESCR_ALLOC_PAD + offsetof(struct cryptocop_int_operation, ctx_out)) & ~0x0000001F) - offsetof(struct cryptocop_int_operation, ctx_out));
801 DEBUG(memset((*int_op), 0xff, sizeof(struct cryptocop_int_operation)));
802 (*int_op)->alloc_ptr = iop_alloc_ptr;
803 DEBUG(printk("cryptocop_setup_dma_list: *int_op=0x%p, alloc_ptr=0x%p\n", *int_op, (*int_op)->alloc_ptr));
804
805 (*int_op)->sid = operation->sid;
806 (*int_op)->cdesc_out = NULL;
807 (*int_op)->cdesc_in = NULL;
808 (*int_op)->tdes_mode = cryptocop_3des_ede;
809 (*int_op)->csum_mode = cryptocop_csum_le;
810 (*int_op)->ddesc_out = NULL;
811 (*int_op)->ddesc_in = NULL;
812
813 /* Scan operation->tfrm_op.tfrm_cfg for bad configuration and set up the local contexts. */
814 if (!tcfg) {
815 DEBUG_API(printk("cryptocop_setup_dma_list: no configured transforms in operation.\n"));
816 failed = -EINVAL;
817 goto error_cleanup;
818 }
819 while (tcfg) {
820 tctx = get_transform_ctx(sess, tcfg->tid);
821 if (!tctx) {
822 DEBUG_API(printk("cryptocop_setup_dma_list: no transform id %d in session.\n", tcfg->tid));
823 failed = -EINVAL;
824 goto error_cleanup;
825 }
826 if (tcfg->inject_ix > operation->tfrm_op.outlen){
827 DEBUG_API(printk("cryptocop_setup_dma_list: transform id %d inject_ix (%d) > operation->tfrm_op.outlen(%d)", tcfg->tid, tcfg->inject_ix, operation->tfrm_op.outlen));
828 failed = -EINVAL;
829 goto error_cleanup;
830 }
831 switch (tctx->init.alg){
832 case cryptocop_alg_mem2mem:
833 if (cipher_ctx.tcfg != NULL){
834 DEBUG_API(printk("cryptocop_setup_dma_list: multiple ciphers in operation.\n"));
835 failed = -EINVAL;
836 goto error_cleanup;
837 }
838 /* mem2mem is handled as a NULL cipher. */
839 cipher_ctx.cbcmode = 0;
840 cipher_ctx.decrypt = 0;
841 cipher_ctx.blocklength = 1;
842 cipher_ctx.ciph_conf = 0;
843 cipher_ctx.unit_no = src_dma;
844 cipher_ctx.tcfg = tcfg;
845 cipher_ctx.tctx = tctx;
846 break;
847 case cryptocop_alg_des:
848 case cryptocop_alg_3des:
849 case cryptocop_alg_aes:
850 /* cipher */
851 if (cipher_ctx.tcfg != NULL){
852 DEBUG_API(printk("cryptocop_setup_dma_list: multiple ciphers in operation.\n"));
853 failed = -EINVAL;
854 goto error_cleanup;
855 }
856 cipher_ctx.tcfg = tcfg;
857 cipher_ctx.tctx = tctx;
858 if (cipher_ctx.tcfg->flags & CRYPTOCOP_DECRYPT){
859 cipher_ctx.decrypt = 1;
860 }
861 switch (tctx->init.cipher_mode) {
862 case cryptocop_cipher_mode_ecb:
863 cipher_ctx.cbcmode = 0;
864 break;
865 case cryptocop_cipher_mode_cbc:
866 cipher_ctx.cbcmode = 1;
867 break;
868 default:
869 DEBUG_API(printk("cryptocop_setup_dma_list: cipher_ctx, bad cipher mode==%d\n", tctx->init.cipher_mode));
870 failed = -EINVAL;
871 goto error_cleanup;
872 }
873 DEBUG(printk("cryptocop_setup_dma_list: cipher_ctx, set CBC mode==%d\n", cipher_ctx.cbcmode));
874 switch (tctx->init.alg){
875 case cryptocop_alg_des:
876 cipher_ctx.ciph_conf = 0;
877 cipher_ctx.unit_no = src_des;
878 cipher_ctx.blocklength = DES_BLOCK_LENGTH;
879 break;
880 case cryptocop_alg_3des:
881 cipher_ctx.ciph_conf = 1;
882 cipher_ctx.unit_no = src_des;
883 cipher_ctx.blocklength = DES_BLOCK_LENGTH;
884 break;
885 case cryptocop_alg_aes:
886 cipher_ctx.ciph_conf = 2;
887 cipher_ctx.unit_no = src_aes;
888 cipher_ctx.blocklength = AES_BLOCK_LENGTH;
889 break;
890 default:
891 panic("cryptocop_setup_dma_list: impossible algorithm %d\n", tctx->init.alg);
892 }
893 (*int_op)->tdes_mode = tctx->init.tdes_mode;
894 break;
895 case cryptocop_alg_md5:
896 case cryptocop_alg_sha1:
897 /* digest */
898 if (digest_ctx.tcfg != NULL){
899 DEBUG_API(printk("cryptocop_setup_dma_list: multiple digests in operation.\n"));
900 failed = -EINVAL;
901 goto error_cleanup;
902 }
903 digest_ctx.tcfg = tcfg;
904 digest_ctx.tctx = tctx;
905 digest_ctx.hash_mode = 0; /* Don't use explicit IV in this API. */
906 switch (tctx->init.alg){
907 case cryptocop_alg_md5:
908 digest_ctx.blocklength = MD5_BLOCK_LENGTH;
909 digest_ctx.unit_no = src_md5;
910 digest_ctx.hash_conf = 1; /* 1 => MD-5 */
911 break;
912 case cryptocop_alg_sha1:
913 digest_ctx.blocklength = SHA1_BLOCK_LENGTH;
914 digest_ctx.unit_no = src_sha1;
915 digest_ctx.hash_conf = 0; /* 0 => SHA-1 */
916 break;
917 default:
918 panic("cryptocop_setup_dma_list: impossible digest algorithm\n");
919 }
920 break;
921 case cryptocop_alg_csum:
922 /* digest */
923 if (csum_ctx.tcfg != NULL){
924 DEBUG_API(printk("cryptocop_setup_dma_list: multiple checksums in operation.\n"));
925 failed = -EINVAL;
926 goto error_cleanup;
927 }
928 (*int_op)->csum_mode = tctx->init.csum_mode;
929 csum_ctx.tcfg = tcfg;
930 csum_ctx.tctx = tctx;
931 break;
932 default:
933 /* no algorithm. */
934 DEBUG_API(printk("cryptocop_setup_dma_list: invalid algorithm %d specified in tfrm %d.\n", tctx->init.alg, tcfg->tid));
935 failed = -EINVAL;
936 goto error_cleanup;
937 }
938 tcfg = tcfg->next;
939 }
940 /* Download key if a cipher is used. */
941 if (cipher_ctx.tcfg && (cipher_ctx.tctx->init.alg != cryptocop_alg_mem2mem)){
942 struct cryptocop_dma_desc *key_desc = NULL;
943
944 failed = setup_key_dl_desc(&cipher_ctx, &key_desc, alloc_flag);
945 if (failed) {
946 DEBUG_API(printk("cryptocop_setup_dma_list: setup key dl\n"));
947 goto error_cleanup;
948 }
949 current_out_cdesc->next = key_desc;
950 current_out_cdesc = key_desc;
951 indata_ix += (unsigned int)(key_desc->dma_descr->after - key_desc->dma_descr->buf);
952
953 /* Download explicit IV if a cipher is used and CBC mode and explicit IV selected. */
954 if ((cipher_ctx.tctx->init.cipher_mode == cryptocop_cipher_mode_cbc) && (cipher_ctx.tcfg->flags & CRYPTOCOP_EXPLICIT_IV)) {
955 struct cryptocop_dma_desc *iv_desc = NULL;
956
957 DEBUG(printk("cryptocop_setup_dma_list: setup cipher CBC IV descriptor.\n"));
958
959 failed = setup_cipher_iv_desc(&cipher_ctx, &iv_desc, alloc_flag);
960 if (failed) {
961 DEBUG_API(printk("cryptocop_setup_dma_list: CBC IV descriptor.\n"));
962 goto error_cleanup;
963 }
964 current_out_cdesc->next = iv_desc;
965 current_out_cdesc = iv_desc;
966 indata_ix += (unsigned int)(iv_desc->dma_descr->after - iv_desc->dma_descr->buf);
967 }
968 }
969
970 /* Process descriptors. */
971 odsc = operation->tfrm_op.desc;
972 while (odsc) {
973 struct cryptocop_desc_cfg *dcfg = odsc->cfg;
974 struct strcop_meta_out meta_out = {0};
975 size_t desc_len = odsc->length;
976 int active_count, eop_needed_count;
977
978 output_tc = NULL;
979
980 DEBUG(printk("cryptocop_setup_dma_list: parsing an operation descriptor\n"));
981
982 while (dcfg) {
983 struct cryptocop_tfrm_ctx *tc = NULL;
984
985 DEBUG(printk("cryptocop_setup_dma_list: parsing an operation descriptor configuration.\n"));
986 /* Get the local context for the transform and mark it as the output unit if it produces output. */
987 if (digest_ctx.tcfg && (digest_ctx.tcfg->tid == dcfg->tid)){
988 tc = &digest_ctx;
989 } else if (cipher_ctx.tcfg && (cipher_ctx.tcfg->tid == dcfg->tid)){
990 tc = &cipher_ctx;
991 } else if (csum_ctx.tcfg && (csum_ctx.tcfg->tid == dcfg->tid)){
992 tc = &csum_ctx;
993 }
994 if (!tc) {
995 DEBUG_API(printk("cryptocop_setup_dma_list: invalid transform %d specified in descriptor.\n", dcfg->tid));
996 failed = -EINVAL;
997 goto error_cleanup;
998 }
999 if (tc->done) {
1000 DEBUG_API(printk("cryptocop_setup_dma_list: completed transform %d reused.\n", dcfg->tid));
1001 failed = -EINVAL;
1002 goto error_cleanup;
1003 }
1004 if (!tc->active) {
1005 tc->start_ix = indata_ix;
1006 tc->active = 1;
1007 }
1008
1009 tc->previous_src = tc->current_src;
1010 tc->prev_src = tc->curr_src;
1011 /* Map source unit id to DMA source config. */
1012 switch (dcfg->src){
1013 case cryptocop_source_dma:
1014 tc->current_src = src_dma;
1015 break;
1016 case cryptocop_source_des:
1017 tc->current_src = src_des;
1018 break;
1019 case cryptocop_source_3des:
1020 tc->current_src = src_des;
1021 break;
1022 case cryptocop_source_aes:
1023 tc->current_src = src_aes;
1024 break;
1025 case cryptocop_source_md5:
1026 case cryptocop_source_sha1:
1027 case cryptocop_source_csum:
1028 case cryptocop_source_none:
1029 default:
1030 /* We do not allow using accumulating style units (SHA-1, MD5, checksum) as sources to other units.
1031 */
1032 DEBUG_API(printk("cryptocop_setup_dma_list: bad unit source configured %d.\n", dcfg->src));
1033 failed = -EINVAL;
1034 goto error_cleanup;
1035 }
1036 if (tc->current_src != src_dma) {
1037 /* Find the unit we are sourcing from. */
1038 if (digest_ctx.unit_no == tc->current_src){
1039 tc->curr_src = &digest_ctx;
1040 } else if (cipher_ctx.unit_no == tc->current_src){
1041 tc->curr_src = &cipher_ctx;
1042 } else if (csum_ctx.unit_no == tc->current_src){
1043 tc->curr_src = &csum_ctx;
1044 }
1045 if ((tc->curr_src == tc) && (tc->unit_no != src_dma)){
1046 DEBUG_API(printk("cryptocop_setup_dma_list: unit %d configured to source from itself.\n", tc->unit_no));
1047 failed = -EINVAL;
1048 goto error_cleanup;
1049 }
1050 } else {
1051 tc->curr_src = NULL;
1052 }
1053
1054 /* Detect source switch. */
1055 DEBUG(printk("cryptocop_setup_dma_list: tc->active=%d tc->unit_no=%d tc->current_src=%d tc->previous_src=%d, tc->curr_src=0x%p, tc->prev_srv=0x%p\n", tc->active, tc->unit_no, tc->current_src, tc->previous_src, tc->curr_src, tc->prev_src));
1056 if (tc->active && (tc->current_src != tc->previous_src)) {
1057 /* Only allow source switch when both the old source unit and the new one have
1058 * no pending data to process (i.e. the consumed length must be a multiple of the
1059 * transform blocklength). */
1060 /* Note: if the src == NULL we are actually sourcing from DMA out. */
1061 if (((tc->prev_src != NULL) && (tc->prev_src->consumed % tc->prev_src->blocklength)) ||
1062 ((tc->curr_src != NULL) && (tc->curr_src->consumed % tc->curr_src->blocklength)))
1063 {
1064 DEBUG_API(printk("cryptocop_setup_dma_list: can only disconnect from or connect to a unit on a multiple of the blocklength, old: cons=%d, prod=%d, block=%d, new: cons=%d prod=%d, block=%d.\n", tc->prev_src ? tc->prev_src->consumed : INT_MIN, tc->prev_src ? tc->prev_src->produced : INT_MIN, tc->prev_src ? tc->prev_src->blocklength : INT_MIN, tc->curr_src ? tc->curr_src->consumed : INT_MIN, tc->curr_src ? tc->curr_src->produced : INT_MIN, tc->curr_src ? tc->curr_src->blocklength : INT_MIN));
1065 failed = -EINVAL;
1066 goto error_cleanup;
1067 }
1068 }
1069 /* Detect unit deactivation. */
1070 if (dcfg->last) {
1071 /* Length check of this is handled below. */
1072 tc->done = 1;
1073 }
1074 dcfg = dcfg->next;
1075 } /* while (dcfg) */
1076 DEBUG(printk("cryptocop_setup_dma_list: parsing operation descriptor configuration complete.\n"));
1077
1078 if (cipher_ctx.active && (cipher_ctx.curr_src != NULL) && !cipher_ctx.curr_src->active){
1079 DEBUG_API(printk("cryptocop_setup_dma_list: cipher source from inactive unit %d\n", cipher_ctx.curr_src->unit_no));
1080 failed = -EINVAL;
1081 goto error_cleanup;
1082 }
1083 if (digest_ctx.active && (digest_ctx.curr_src != NULL) && !digest_ctx.curr_src->active){
1084 DEBUG_API(printk("cryptocop_setup_dma_list: digest source from inactive unit %d\n", digest_ctx.curr_src->unit_no));
1085 failed = -EINVAL;
1086 goto error_cleanup;
1087 }
1088 if (csum_ctx.active && (csum_ctx.curr_src != NULL) && !csum_ctx.curr_src->active){
1089 DEBUG_API(printk("cryptocop_setup_dma_list: cipher source from inactive unit %d\n", csum_ctx.curr_src->unit_no));
1090 failed = -EINVAL;
1091 goto error_cleanup;
1092 }
1093
1094 /* Update consumed and produced lengths.
1095
1096 The consumed length accounting here is actually cheating. If a unit source from DMA (or any
1097 other unit that process data in blocks of one octet) it is correct, but if it source from a
1098 block processing unit, i.e. a cipher, it will be temporarily incorrect at some times. However
1099 since it is only allowed--by the HW--to change source to or from a block processing unit at times where that
1100 unit has processed an exact multiple of its block length the end result will be correct.
1101 Beware that if the source change restriction change this code will need to be (much) reworked.
1102 */
1103 DEBUG(printk("cryptocop_setup_dma_list: desc->length=%d, desc_len=%d.\n", odsc->length, desc_len));
1104
1105 if (csum_ctx.active) {
1106 csum_ctx.consumed += desc_len;
1107 if (csum_ctx.done) {
1108 csum_ctx.produced = 2;
1109 }
1110 DEBUG(printk("cryptocop_setup_dma_list: csum_ctx producing: consumed=%d, produced=%d, blocklength=%d.\n", csum_ctx.consumed, csum_ctx.produced, csum_ctx.blocklength));
1111 }
1112 if (digest_ctx.active) {
1113 digest_ctx.consumed += desc_len;
1114 if (digest_ctx.done) {
1115 if (digest_ctx.unit_no == src_md5) {
1116 digest_ctx.produced = MD5_STATE_LENGTH;
1117 } else {
1118 digest_ctx.produced = SHA1_STATE_LENGTH;
1119 }
1120 }
1121 DEBUG(printk("cryptocop_setup_dma_list: digest_ctx producing: consumed=%d, produced=%d, blocklength=%d.\n", digest_ctx.consumed, digest_ctx.produced, digest_ctx.blocklength));
1122 }
1123 if (cipher_ctx.active) {
1124 /* Ciphers are allowed only to source from DMA out. That is filtered above. */
1125 assert(cipher_ctx.current_src == src_dma);
1126 cipher_ctx.consumed += desc_len;
1127 cipher_ctx.produced = cipher_ctx.blocklength * (cipher_ctx.consumed / cipher_ctx.blocklength);
1128 if (cipher_ctx.cbcmode && !(cipher_ctx.tcfg->flags & CRYPTOCOP_EXPLICIT_IV) && cipher_ctx.produced){
1129 cipher_ctx.produced -= cipher_ctx.blocklength; /* Compensate for CBC iv. */
1130 }
1131 DEBUG(printk("cryptocop_setup_dma_list: cipher_ctx producing: consumed=%d, produced=%d, blocklength=%d.\n", cipher_ctx.consumed, cipher_ctx.produced, cipher_ctx.blocklength));
1132 }
1133
1134 /* Setup the DMA out descriptors. */
1135 /* Configure the metadata. */
1136 active_count = 0;
1137 eop_needed_count = 0;
1138 if (cipher_ctx.active) {
1139 ++active_count;
1140 if (cipher_ctx.unit_no == src_dma){
1141 /* mem2mem */
1142 meta_out.ciphsel = src_none;
1143 } else {
1144 meta_out.ciphsel = cipher_ctx.current_src;
1145 }
1146 meta_out.ciphconf = cipher_ctx.ciph_conf;
1147 meta_out.cbcmode = cipher_ctx.cbcmode;
1148 meta_out.decrypt = cipher_ctx.decrypt;
1149 DEBUG(printk("set ciphsel=%d ciphconf=%d cbcmode=%d decrypt=%d\n", meta_out.ciphsel, meta_out.ciphconf, meta_out.cbcmode, meta_out.decrypt));
1150 if (cipher_ctx.done) ++eop_needed_count;
1151 } else {
1152 meta_out.ciphsel = src_none;
1153 }
1154
1155 if (digest_ctx.active) {
1156 ++active_count;
1157 meta_out.hashsel = digest_ctx.current_src;
1158 meta_out.hashconf = digest_ctx.hash_conf;
1159 meta_out.hashmode = 0; /* Explicit mode is not used here. */
1160 DEBUG(printk("set hashsel=%d hashconf=%d hashmode=%d\n", meta_out.hashsel, meta_out.hashconf, meta_out.hashmode));
1161 if (digest_ctx.done) {
1162 assert(digest_ctx.pad_descs == NULL);
1163 failed = create_pad_descriptor(&digest_ctx, &digest_ctx.pad_descs, alloc_flag);
1164 if (failed) {
1165 DEBUG_API(printk("cryptocop_setup_dma_list: failed digest pad creation.\n"));
1166 goto error_cleanup;
1167 }
1168 }
1169 } else {
1170 meta_out.hashsel = src_none;
1171 }
1172
1173 if (csum_ctx.active) {
1174 ++active_count;
1175 meta_out.csumsel = csum_ctx.current_src;
1176 if (csum_ctx.done) {
1177 assert(csum_ctx.pad_descs == NULL);
1178 failed = create_pad_descriptor(&csum_ctx, &csum_ctx.pad_descs, alloc_flag);
1179 if (failed) {
1180 DEBUG_API(printk("cryptocop_setup_dma_list: failed csum pad creation.\n"));
1181 goto error_cleanup;
1182 }
1183 }
1184 } else {
1185 meta_out.csumsel = src_none;
1186 }
1187 DEBUG(printk("cryptocop_setup_dma_list: %d eop needed, %d active units\n", eop_needed_count, active_count));
1188 /* Setup DMA out descriptors for the indata. */
1189 failed = create_output_descriptors(operation, &iniov_ix, &iniov_offset, desc_len, &current_out_cdesc, &meta_out, alloc_flag);
1190 if (failed) {
1191 DEBUG_API(printk("cryptocop_setup_dma_list: create_output_descriptors %d\n", failed));
1192 goto error_cleanup;
1193 }
1194 /* Setup out EOP. If there are active units that are not done here they cannot get an EOP
1195 * so we ust setup a zero length descriptor to DMA to signal EOP only to done units.
1196 * If there is a pad descriptor EOP for the padded unit will be EOPed by it.
1197 */
1198 assert(active_count >= eop_needed_count);
1199 assert((eop_needed_count == 0) || (eop_needed_count == 1));
1200 if (eop_needed_count) {
1201 /* This means that the bulk operation (cipeher/m2m) is terminated. */
1202 if (active_count > 1) {
1203 /* Use zero length EOP descriptor. */
1204 struct cryptocop_dma_desc *ed = alloc_cdesc(alloc_flag);
1205 struct strcop_meta_out ed_mo = {0};
1206 if (!ed) {
1207 DEBUG_API(printk("cryptocop_setup_dma_list: alloc EOP descriptor for cipher\n"));
1208 failed = -ENOMEM;
1209 goto error_cleanup;
1210 }
1211
1212 assert(cipher_ctx.active && cipher_ctx.done);
1213
1214 if (cipher_ctx.unit_no == src_dma){
1215 /* mem2mem */
1216 ed_mo.ciphsel = src_none;
1217 } else {
1218 ed_mo.ciphsel = cipher_ctx.current_src;
1219 }
1220 ed_mo.ciphconf = cipher_ctx.ciph_conf;
1221 ed_mo.cbcmode = cipher_ctx.cbcmode;
1222 ed_mo.decrypt = cipher_ctx.decrypt;
1223
1224 ed->free_buf = NULL;
1225 ed->dma_descr->wait = 1;
1226 ed->dma_descr->out_eop = 1;
1227
1228 ed->dma_descr->buf = (char*)virt_to_phys(&ed); /* Use any valid physical address for zero length descriptor. */
1229 ed->dma_descr->after = ed->dma_descr->buf;
1230 ed->dma_descr->md = REG_TYPE_CONV(unsigned short int, struct strcop_meta_out, ed_mo);
1231 current_out_cdesc->next = ed;
1232 current_out_cdesc = ed;
1233 } else {
1234 /* Set EOP in the current out descriptor since the only active module is
1235 * the one needing the EOP. */
1236
1237 current_out_cdesc->dma_descr->out_eop = 1;
1238 }
1239 }
1240
1241 if (cipher_ctx.done && cipher_ctx.active) cipher_ctx.active = 0;
1242 if (digest_ctx.done && digest_ctx.active) digest_ctx.active = 0;
1243 if (csum_ctx.done && csum_ctx.active) csum_ctx.active = 0;
1244 indata_ix += odsc->length;
1245 odsc = odsc->next;
1246 } /* while (odsc) */ /* Process descriptors. */
1247 DEBUG(printk("cryptocop_setup_dma_list: done parsing operation descriptors\n"));
1248 if (cipher_ctx.tcfg && (cipher_ctx.active || !cipher_ctx.done)){
1249 DEBUG_API(printk("cryptocop_setup_dma_list: cipher operation not terminated.\n"));
1250 failed = -EINVAL;
1251 goto error_cleanup;
1252 }
1253 if (digest_ctx.tcfg && (digest_ctx.active || !digest_ctx.done)){
1254 DEBUG_API(printk("cryptocop_setup_dma_list: digest operation not terminated.\n"));
1255 failed = -EINVAL;
1256 goto error_cleanup;
1257 }
1258 if (csum_ctx.tcfg && (csum_ctx.active || !csum_ctx.done)){
1259 DEBUG_API(printk("cryptocop_setup_dma_list: csum operation not terminated.\n"));
1260 failed = -EINVAL;
1261 goto error_cleanup;
1262 }
1263
1264 failed = append_input_descriptors(operation, &current_in_cdesc, &current_out_cdesc, &cipher_ctx, alloc_flag);
1265 if (failed){
1266 DEBUG_API(printk("cryptocop_setup_dma_list: append_input_descriptors cipher_ctx %d\n", failed));
1267 goto error_cleanup;
1268 }
1269 failed = append_input_descriptors(operation, &current_in_cdesc, &current_out_cdesc, &digest_ctx, alloc_flag);
1270 if (failed){
1271 DEBUG_API(printk("cryptocop_setup_dma_list: append_input_descriptors cipher_ctx %d\n", failed));
1272 goto error_cleanup;
1273 }
1274 failed = append_input_descriptors(operation, &current_in_cdesc, &current_out_cdesc, &csum_ctx, alloc_flag);
1275 if (failed){
1276 DEBUG_API(printk("cryptocop_setup_dma_list: append_input_descriptors cipher_ctx %d\n", failed));
1277 goto error_cleanup;
1278 }
1279
1280 DEBUG(printk("cryptocop_setup_dma_list: int_op=0x%p, *int_op=0x%p\n", int_op, *int_op));
1281 (*int_op)->cdesc_out = out_cdesc_head.next;
1282 (*int_op)->cdesc_in = in_cdesc_head.next;
1283 DEBUG(printk("cryptocop_setup_dma_list: out_cdesc_head=0x%p in_cdesc_head=0x%p\n", (*int_op)->cdesc_out, (*int_op)->cdesc_in));
1284
1285 setup_descr_chain(out_cdesc_head.next);
1286 setup_descr_chain(in_cdesc_head.next);
1287
1288 /* Last but not least: mark the last DMA in descriptor for a INTR and EOL and the the
1289 * last DMA out descriptor for EOL.
1290 */
1291 current_in_cdesc->dma_descr->intr = 1;
1292 current_in_cdesc->dma_descr->eol = 1;
1293 current_out_cdesc->dma_descr->eol = 1;
1294
1295 /* Setup DMA contexts. */
1296 (*int_op)->ctx_out.next = NULL;
1297 (*int_op)->ctx_out.eol = 1;
1298 (*int_op)->ctx_out.intr = 0;
1299 (*int_op)->ctx_out.store_mode = 0;
1300 (*int_op)->ctx_out.en = 0;
1301 (*int_op)->ctx_out.dis = 0;
1302 (*int_op)->ctx_out.md0 = 0;
1303 (*int_op)->ctx_out.md1 = 0;
1304 (*int_op)->ctx_out.md2 = 0;
1305 (*int_op)->ctx_out.md3 = 0;
1306 (*int_op)->ctx_out.md4 = 0;
1307 (*int_op)->ctx_out.saved_data = (dma_descr_data*)virt_to_phys((*int_op)->cdesc_out->dma_descr);
1308 (*int_op)->ctx_out.saved_data_buf = (*int_op)->cdesc_out->dma_descr->buf; /* Already physical address. */
1309
1310 (*int_op)->ctx_in.next = NULL;
1311 (*int_op)->ctx_in.eol = 1;
1312 (*int_op)->ctx_in.intr = 0;
1313 (*int_op)->ctx_in.store_mode = 0;
1314 (*int_op)->ctx_in.en = 0;
1315 (*int_op)->ctx_in.dis = 0;
1316 (*int_op)->ctx_in.md0 = 0;
1317 (*int_op)->ctx_in.md1 = 0;
1318 (*int_op)->ctx_in.md2 = 0;
1319 (*int_op)->ctx_in.md3 = 0;
1320 (*int_op)->ctx_in.md4 = 0;
1321
1322 (*int_op)->ctx_in.saved_data = (dma_descr_data*)virt_to_phys((*int_op)->cdesc_in->dma_descr);
1323 (*int_op)->ctx_in.saved_data_buf = (*int_op)->cdesc_in->dma_descr->buf; /* Already physical address. */
1324
1325 DEBUG(printk("cryptocop_setup_dma_list: done\n"));
1326 return 0;
1327
1328 error_cleanup:
1329 {
1330 /* Free all allocated resources. */
1331 struct cryptocop_dma_desc *tmp_cdesc;
1332 while (digest_ctx.pad_descs){
1333 tmp_cdesc = digest_ctx.pad_descs->next;
1334 free_cdesc(digest_ctx.pad_descs);
1335 digest_ctx.pad_descs = tmp_cdesc;
1336 }
1337 while (csum_ctx.pad_descs){
1338 tmp_cdesc = csum_ctx.pad_descs->next;
1339 free_cdesc(csum_ctx.pad_descs);
1340 csum_ctx.pad_descs = tmp_cdesc;
1341 }
1342 assert(cipher_ctx.pad_descs == NULL); /* The ciphers are never padded. */
1343
1344 if (*int_op != NULL) delete_internal_operation(*int_op);
1345 }
1346 DEBUG_API(printk("cryptocop_setup_dma_list: done with error %d\n", failed));
1347 return failed;
1348 }
1349
1350
1351 static void delete_internal_operation(struct cryptocop_int_operation *iop)
1352 {
1353 void *ptr = iop->alloc_ptr;
1354 struct cryptocop_dma_desc *cd = iop->cdesc_out;
1355 struct cryptocop_dma_desc *next;
1356
1357 DEBUG(printk("delete_internal_operation: iop=0x%p, alloc_ptr=0x%p\n", iop, ptr));
1358
1359 while (cd) {
1360 next = cd->next;
1361 free_cdesc(cd);
1362 cd = next;
1363 }
1364 cd = iop->cdesc_in;
1365 while (cd) {
1366 next = cd->next;
1367 free_cdesc(cd);
1368 cd = next;
1369 }
1370 kfree(ptr);
1371 }
1372
1373 #define MD5_MIN_PAD_LENGTH (9)
1374 #define MD5_PAD_LENGTH_FIELD_LENGTH (8)
1375
1376 static int create_md5_pad(int alloc_flag, unsigned long long hashed_length, char **pad, size_t *pad_length)
1377 {
1378 size_t padlen = MD5_BLOCK_LENGTH - (hashed_length % MD5_BLOCK_LENGTH);
1379 unsigned char *p;
1380 int i;
1381 unsigned long long int bit_length = hashed_length << 3;
1382
1383 if (padlen < MD5_MIN_PAD_LENGTH) padlen += MD5_BLOCK_LENGTH;
1384
1385 p = kmalloc(padlen, alloc_flag);
1386 if (!pad) return -ENOMEM;
1387
1388 *p = 0x80;
1389 memset(p+1, 0, padlen - 1);
1390
1391 DEBUG(printk("create_md5_pad: hashed_length=%lld bits == %lld bytes\n", bit_length, hashed_length));
1392
1393 i = padlen - MD5_PAD_LENGTH_FIELD_LENGTH;
1394 while (bit_length != 0){
1395 p[i++] = bit_length % 0x100;
1396 bit_length >>= 8;
1397 }
1398
1399 *pad = (char*)p;
1400 *pad_length = padlen;
1401
1402 return 0;
1403 }
1404
1405 #define SHA1_MIN_PAD_LENGTH (9)
1406 #define SHA1_PAD_LENGTH_FIELD_LENGTH (8)
1407
1408 static int create_sha1_pad(int alloc_flag, unsigned long long hashed_length, char **pad, size_t *pad_length)
1409 {
1410 size_t padlen = SHA1_BLOCK_LENGTH - (hashed_length % SHA1_BLOCK_LENGTH);
1411 unsigned char *p;
1412 int i;
1413 unsigned long long int bit_length = hashed_length << 3;
1414
1415 if (padlen < SHA1_MIN_PAD_LENGTH) padlen += SHA1_BLOCK_LENGTH;
1416
1417 p = kmalloc(padlen, alloc_flag);
1418 if (!pad) return -ENOMEM;
1419
1420 *p = 0x80;
1421 memset(p+1, 0, padlen - 1);
1422
1423 DEBUG(printk("create_sha1_pad: hashed_length=%lld bits == %lld bytes\n", bit_length, hashed_length));
1424
1425 i = padlen - 1;
1426 while (bit_length != 0){
1427 p[i--] = bit_length % 0x100;
1428 bit_length >>= 8;
1429 }
1430
1431 *pad = (char*)p;
1432 *pad_length = padlen;
1433
1434 return 0;
1435 }
1436
1437
1438 static int transform_ok(struct cryptocop_transform_init *tinit)
1439 {
1440 switch (tinit->alg){
1441 case cryptocop_alg_csum:
1442 switch (tinit->csum_mode){
1443 case cryptocop_csum_le:
1444 case cryptocop_csum_be:
1445 break;
1446 default:
1447 DEBUG_API(printk("transform_ok: Bad mode set for csum transform\n"));
1448 return -EINVAL;
1449 }
1450 case cryptocop_alg_mem2mem:
1451 case cryptocop_alg_md5:
1452 case cryptocop_alg_sha1:
1453 if (tinit->keylen != 0) {
1454 DEBUG_API(printk("transform_ok: non-zero keylength, %d, for a digest/csum algorithm\n", tinit->keylen));
1455 return -EINVAL; /* This check is a bit strict. */
1456 }
1457 break;
1458 case cryptocop_alg_des:
1459 if (tinit->keylen != 64) {
1460 DEBUG_API(printk("transform_ok: keylen %d invalid for DES\n", tinit->keylen));
1461 return -EINVAL;
1462 }
1463 break;
1464 case cryptocop_alg_3des:
1465 if (tinit->keylen != 192) {
1466 DEBUG_API(printk("transform_ok: keylen %d invalid for 3DES\n", tinit->keylen));
1467 return -EINVAL;
1468 }
1469 break;
1470 case cryptocop_alg_aes:
1471 if (tinit->keylen != 128 && tinit->keylen != 192 && tinit->keylen != 256) {
1472 DEBUG_API(printk("transform_ok: keylen %d invalid for AES\n", tinit->keylen));
1473 return -EINVAL;
1474 }
1475 break;
1476 case cryptocop_no_alg:
1477 default:
1478 DEBUG_API(printk("transform_ok: no such algorithm %d\n", tinit->alg));
1479 return -EINVAL;
1480 }
1481
1482 switch (tinit->alg){
1483 case cryptocop_alg_des:
1484 case cryptocop_alg_3des:
1485 case cryptocop_alg_aes:
1486 if (tinit->cipher_mode != cryptocop_cipher_mode_ecb && tinit->cipher_mode != cryptocop_cipher_mode_cbc) return -EINVAL;
1487 default:
1488 break;
1489 }
1490 return 0;
1491 }
1492
1493
1494 int cryptocop_new_session(cryptocop_session_id *sid, struct cryptocop_transform_init *tinit, int alloc_flag)
1495 {
1496 struct cryptocop_session *sess;
1497 struct cryptocop_transform_init *tfrm_in = tinit;
1498 struct cryptocop_transform_init *tmp_in;
1499 int no_tfrms = 0;
1500 int i;
1501 unsigned long int flags;
1502
1503 init_stream_coprocessor(); /* For safety if we are called early */
1504
1505 while (tfrm_in){
1506 int err;
1507 ++no_tfrms;
1508 if ((err = transform_ok(tfrm_in))) {
1509 DEBUG_API(printk("cryptocop_new_session, bad transform\n"));
1510 return err;
1511 }
1512 tfrm_in = tfrm_in->next;
1513 }
1514 if (0 == no_tfrms) {
1515 DEBUG_API(printk("cryptocop_new_session, no transforms specified\n"));
1516 return -EINVAL;
1517 }
1518
1519 sess = kmalloc(sizeof(struct cryptocop_session), alloc_flag);
1520 if (!sess){
1521 DEBUG_API(printk("cryptocop_new_session, kmalloc cryptocop_session\n"));
1522 return -ENOMEM;
1523 }
1524
1525 sess->tfrm_ctx = kmalloc(no_tfrms * sizeof(struct cryptocop_transform_ctx), alloc_flag);
1526 if (!sess->tfrm_ctx) {
1527 DEBUG_API(printk("cryptocop_new_session, kmalloc cryptocop_transform_ctx\n"));
1528 kfree(sess);
1529 return -ENOMEM;
1530 }
1531
1532 tfrm_in = tinit;
1533 for (i = 0; i < no_tfrms; i++){
1534 tmp_in = tfrm_in->next;
1535 while (tmp_in){
1536 if (tmp_in->tid == tfrm_in->tid) {
1537 DEBUG_API(printk("cryptocop_new_session, duplicate transform ids\n"));
1538 kfree(sess->tfrm_ctx);
1539 kfree(sess);
1540 return -EINVAL;
1541 }
1542 tmp_in = tmp_in->next;
1543 }
1544 memcpy(&sess->tfrm_ctx[i].init, tfrm_in, sizeof(struct cryptocop_transform_init));
1545 sess->tfrm_ctx[i].dec_key_set = 0;
1546 sess->tfrm_ctx[i].next = &sess->tfrm_ctx[i] + 1;
1547
1548 tfrm_in = tfrm_in->next;
1549 }
1550 sess->tfrm_ctx[i-1].next = NULL;
1551
1552 spin_lock_irqsave(&cryptocop_sessions_lock, flags);
1553 sess->sid = next_sid;
1554 next_sid++;
1555 /* TODO If we are really paranoid we should do duplicate check to handle sid wraparound.
1556 * OTOH 2^64 is a really large number of session. */
1557 if (next_sid == 0) next_sid = 1;
1558
1559 /* Prepend to session list. */
1560 sess->next = cryptocop_sessions;
1561 cryptocop_sessions = sess;
1562 spin_unlock_irqrestore(&cryptocop_sessions_lock, flags);
1563 *sid = sess->sid;
1564 return 0;
1565 }
1566
1567
1568 int cryptocop_free_session(cryptocop_session_id sid)
1569 {
1570 struct cryptocop_transform_ctx *tc;
1571 struct cryptocop_session *sess = NULL;
1572 struct cryptocop_session *psess = NULL;
1573 unsigned long int flags;
1574 int i;
1575 LIST_HEAD(remove_list);
1576 struct list_head *node, *tmp;
1577 struct cryptocop_prio_job *pj;
1578
1579 DEBUG(printk("cryptocop_free_session: sid=%lld\n", sid));
1580
1581 spin_lock_irqsave(&cryptocop_sessions_lock, flags);
1582 sess = cryptocop_sessions;
1583 while (sess && sess->sid != sid){
1584 psess = sess;
1585 sess = sess->next;
1586 }
1587 if (sess){
1588 if (psess){
1589 psess->next = sess->next;
1590 } else {
1591 cryptocop_sessions = sess->next;
1592 }
1593 }
1594 spin_unlock_irqrestore(&cryptocop_sessions_lock, flags);
1595
1596 if (!sess) return -EINVAL;
1597
1598 /* Remove queued jobs. */
1599 spin_lock_irqsave(&cryptocop_job_queue_lock, flags);
1600
1601 for (i = 0; i < cryptocop_prio_no_prios; i++){
1602 if (!list_empty(&(cryptocop_job_queues[i].jobs))){
1603 list_for_each_safe(node, tmp, &(cryptocop_job_queues[i].jobs)) {
1604 pj = list_entry(node, struct cryptocop_prio_job, node);
1605 if (pj->oper->sid == sid) {
1606 list_move_tail(node, &remove_list);
1607 }
1608 }
1609 }
1610 }
1611 spin_unlock_irqrestore(&cryptocop_job_queue_lock, flags);
1612
1613 list_for_each_safe(node, tmp, &remove_list) {
1614 list_del(node);
1615 pj = list_entry(node, struct cryptocop_prio_job, node);
1616 pj->oper->operation_status = -EAGAIN; /* EAGAIN is not ideal for job/session terminated but it's the best choice I know of. */
1617 DEBUG(printk("cryptocop_free_session: pj=0x%p, pj->oper=0x%p, pj->iop=0x%p\n", pj, pj->oper, pj->iop));
1618 pj->oper->cb(pj->oper, pj->oper->cb_data);
1619 delete_internal_operation(pj->iop);
1620 kfree(pj);
1621 }
1622
1623 tc = sess->tfrm_ctx;
1624 /* Erase keying data. */
1625 while (tc){
1626 DEBUG(printk("cryptocop_free_session: memset keys, tfrm id=%d\n", tc->init.tid));
1627 memset(tc->init.key, 0xff, CRYPTOCOP_MAX_KEY_LENGTH);
1628 memset(tc->dec_key, 0xff, CRYPTOCOP_MAX_KEY_LENGTH);
1629 tc = tc->next;
1630 }
1631 kfree(sess->tfrm_ctx);
1632 kfree(sess);
1633
1634 return 0;
1635 }
1636
1637 static struct cryptocop_session *get_session(cryptocop_session_id sid)
1638 {
1639 struct cryptocop_session *sess;
1640 unsigned long int flags;
1641
1642 spin_lock_irqsave(&cryptocop_sessions_lock, flags);
1643 sess = cryptocop_sessions;
1644 while (sess && (sess->sid != sid)){
1645 sess = sess->next;
1646 }
1647 spin_unlock_irqrestore(&cryptocop_sessions_lock, flags);
1648
1649 return sess;
1650 }
1651
1652 static struct cryptocop_transform_ctx *get_transform_ctx(struct cryptocop_session *sess, cryptocop_tfrm_id tid)
1653 {
1654 struct cryptocop_transform_ctx *tc = sess->tfrm_ctx;
1655
1656 DEBUG(printk("get_transform_ctx, sess=0x%p, tid=%d\n", sess, tid));
1657 assert(sess != NULL);
1658 while (tc && tc->init.tid != tid){
1659 DEBUG(printk("tc=0x%p, tc->next=0x%p\n", tc, tc->next));
1660 tc = tc->next;
1661 }
1662 DEBUG(printk("get_transform_ctx, returning tc=0x%p\n", tc));
1663 return tc;
1664 }
1665
1666
1667
1668 /* The AES s-transform matrix (s-box). */
1669 static const u8 aes_sbox[256] = {
1670 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118,
1671 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192,
1672 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21,
1673 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117,
1674 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132,
1675 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207,
1676 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168,
1677 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210,
1678 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115,
1679 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219,
1680 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121,
1681 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8,
1682 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138,
1683 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158,
1684 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223,
1685 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22
1686 };
1687
1688 /* AES has a 32 bit word round constants for each round in the
1689 * key schedule. round_constant[i] is really Rcon[i+1] in FIPS187.
1690 */
1691 static u32 round_constant[11] = {
1692 0x01000000, 0x02000000, 0x04000000, 0x08000000,
1693 0x10000000, 0x20000000, 0x40000000, 0x80000000,
1694 0x1B000000, 0x36000000, 0x6C000000
1695 };
1696
1697 /* Apply the s-box to each of the four occtets in w. */
1698 static u32 aes_ks_subword(const u32 w)
1699 {
1700 u8 bytes[4];
1701
1702 *(u32*)(&bytes[0]) = w;
1703 bytes[0] = aes_sbox[bytes[0]];
1704 bytes[1] = aes_sbox[bytes[1]];
1705 bytes[2] = aes_sbox[bytes[2]];
1706 bytes[3] = aes_sbox[bytes[3]];
1707 return *(u32*)(&bytes[0]);
1708 }
1709
1710 /* The encrypt (forward) Rijndael key schedule algorithm pseudo code:
1711 * (Note that AES words are 32 bit long)
1712 *
1713 * KeyExpansion(byte key[4*Nk], word w[Nb*(Nr+1)], Nk){
1714 * word temp
1715 * i = 0
1716 * while (i < Nk) {
1717 * w[i] = word(key[4*i, 4*i + 1, 4*i + 2, 4*i + 3])
1718 * i = i + 1
1719 * }
1720 * i = Nk
1721 *
1722 * while (i < (Nb * (Nr + 1))) {
1723 * temp = w[i - 1]
1724 * if ((i mod Nk) == 0) {
1725 * temp = SubWord(RotWord(temp)) xor Rcon[i/Nk]
1726 * }
1727 * else if ((Nk > 6) && ((i mod Nk) == 4)) {
1728 * temp = SubWord(temp)
1729 * }
1730 * w[i] = w[i - Nk] xor temp
1731 * }
1732 * RotWord(t) does a 8 bit cyclic shift left on a 32 bit word.
1733 * SubWord(t) applies the AES s-box individually to each octet
1734 * in a 32 bit word.
1735 *
1736 * For AES Nk can have the values 4, 6, and 8 (corresponding to
1737 * values for Nr of 10, 12, and 14). Nb is always 4.
1738 *
1739 * To construct w[i], w[i - 1] and w[i - Nk] must be
1740 * available. Consequently we must keep a state of the last Nk words
1741 * to be able to create the last round keys.
1742 */
1743 static void get_aes_decrypt_key(unsigned char *dec_key, const unsigned char *key, unsigned int keylength)
1744 {
1745 u32 temp;
1746 u32 w_ring[8]; /* nk is max 8, use elements 0..(nk - 1) as a ringbuffer */
1747 u8 w_last_ix;
1748 int i;
1749 u8 nr, nk;
1750
1751 switch (keylength){
1752 case 128:
1753 nk = 4;
1754 nr = 10;
1755 break;
1756 case 192:
1757 nk = 6;
1758 nr = 12;
1759 break;
1760 case 256:
1761 nk = 8;
1762 nr = 14;
1763 break;
1764 default:
1765 panic("stream co-processor: bad aes key length in get_aes_decrypt_key\n");
1766 };
1767
1768 /* Need to do host byte order correction here since key is byte oriented and the
1769 * kx algorithm is word (u32) oriented. */
1770 for (i = 0; i < nk; i+=1) {
1771 w_ring[i] = be32_to_cpu(*(u32*)&key[4*i]);
1772 }
1773
1774 i = (int)nk;
1775 w_last_ix = i - 1;
1776 while (i < (4 * (nr + 2))) {
1777 temp = w_ring[w_last_ix];
1778 if (!(i % nk)) {
1779 /* RotWord(temp) */
1780 temp = (temp << 8) | (temp >> 24);
1781 temp = aes_ks_subword(temp);
1782 temp ^= round_constant[i/nk - 1];
1783 } else if ((nk > 6) && ((i % nk) == 4)) {
1784 temp = aes_ks_subword(temp);
1785 }
1786 w_last_ix = (w_last_ix + 1) % nk; /* This is the same as (i-Nk) mod Nk */
1787 temp ^= w_ring[w_last_ix];
1788 w_ring[w_last_ix] = temp;
1789
1790 /* We need the round keys for round Nr+1 and Nr+2 (round key
1791 * Nr+2 is the round key beyond the last one used when
1792 * encrypting). Rounds are numbered starting from 0, Nr=10
1793 * implies 11 rounds are used in encryption/decryption.
1794 */
1795 if (i >= (4 * nr)) {
1796 /* Need to do host byte order correction here, the key
1797 * is byte oriented. */
1798 *(u32*)dec_key = cpu_to_be32(temp);
1799 dec_key += 4;
1800 }
1801 ++i;
1802 }
1803 }
1804
1805
1806 /**** Job/operation management. ****/
1807
1808 int cryptocop_job_queue_insert_csum(struct cryptocop_operation *operation)
1809 {
1810 return cryptocop_job_queue_insert(cryptocop_prio_kernel_csum, operation);
1811 }
1812
1813 int cryptocop_job_queue_insert_crypto(struct cryptocop_operation *operation)
1814 {
1815 return cryptocop_job_queue_insert(cryptocop_prio_kernel, operation);
1816 }
1817
1818 int cryptocop_job_queue_insert_user_job(struct cryptocop_operation *operation)
1819 {
1820 return cryptocop_job_queue_insert(cryptocop_prio_user, operation);
1821 }
1822
1823 static int cryptocop_job_queue_insert(cryptocop_queue_priority prio, struct cryptocop_operation *operation)
1824 {
1825 int ret;
1826 struct cryptocop_prio_job *pj = NULL;
1827 unsigned long int flags;
1828
1829 DEBUG(printk("cryptocop_job_queue_insert(%d, 0x%p)\n", prio, operation));
1830
1831 if (!operation || !operation->cb){
1832 DEBUG_API(printk("cryptocop_job_queue_insert oper=0x%p, NULL operation or callback\n", operation));
1833 return -EINVAL;
1834 }
1835
1836 if ((ret = cryptocop_job_setup(&pj, operation)) != 0){
1837 DEBUG_API(printk("cryptocop_job_queue_insert: job setup failed\n"));
1838 return ret;
1839 }
1840 assert(pj != NULL);
1841
1842 spin_lock_irqsave(&cryptocop_job_queue_lock, flags);
1843 list_add_tail(&pj->node, &cryptocop_job_queues[prio].jobs);
1844 spin_unlock_irqrestore(&cryptocop_job_queue_lock, flags);
1845
1846 /* Make sure a job is running */
1847 cryptocop_start_job();
1848 return 0;
1849 }
1850
1851 static void cryptocop_do_tasklet(unsigned long unused);
1852 DECLARE_TASKLET (cryptocop_tasklet, cryptocop_do_tasklet, 0);
1853
1854 static void cryptocop_do_tasklet(unsigned long unused)
1855 {
1856 struct list_head *node;
1857 struct cryptocop_prio_job *pj = NULL;
1858 unsigned long flags;
1859
1860 DEBUG(printk("cryptocop_do_tasklet: entering\n"));
1861
1862 do {
1863 spin_lock_irqsave(&cryptocop_completed_jobs_lock, flags);
1864 if (!list_empty(&cryptocop_completed_jobs)){
1865 node = cryptocop_completed_jobs.next;
1866 list_del(node);
1867 pj = list_entry(node, struct cryptocop_prio_job, node);
1868 } else {
1869 pj = NULL;
1870 }
1871 spin_unlock_irqrestore(&cryptocop_completed_jobs_lock, flags);
1872 if (pj) {
1873 assert(pj->oper != NULL);
1874
1875 /* Notify consumer of operation completeness. */
1876 DEBUG(printk("cryptocop_do_tasklet: callback 0x%p, data 0x%p\n", pj->oper->cb, pj->oper->cb_data));
1877
1878 pj->oper->operation_status = 0; /* Job is completed. */
1879 pj->oper->cb(pj->oper, pj->oper->cb_data);
1880 delete_internal_operation(pj->iop);
1881 kfree(pj);
1882 }
1883 } while (pj != NULL);
1884
1885 DEBUG(printk("cryptocop_do_tasklet: exiting\n"));
1886 }
1887
1888 static irqreturn_t
1889 dma_done_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1890 {
1891 struct cryptocop_prio_job *done_job;
1892 reg_dma_rw_ack_intr ack_intr = {
1893 .data = 1,
1894 };
1895
1896 REG_WR (dma, regi_dma9, rw_ack_intr, ack_intr);
1897
1898 DEBUG(printk("cryptocop DMA done\n"));
1899
1900 spin_lock(&running_job_lock);
1901 if (cryptocop_running_job == NULL){
1902 printk("stream co-processor got interrupt when not busy\n");
1903 spin_unlock(&running_job_lock);
1904 return IRQ_HANDLED;
1905 }
1906 done_job = cryptocop_running_job;
1907 cryptocop_running_job = NULL;
1908 spin_unlock(&running_job_lock);
1909
1910 /* Start processing a job. */
1911 if (!spin_trylock(&cryptocop_process_lock)){
1912 DEBUG(printk("cryptocop irq handler, not starting a job\n"));
1913 } else {
1914 cryptocop_start_job();
1915 spin_unlock(&cryptocop_process_lock);
1916 }
1917
1918 done_job->oper->operation_status = 0; /* Job is completed. */
1919 if (done_job->oper->fast_callback){
1920 /* This operation wants callback from interrupt. */
1921 done_job->oper->cb(done_job->oper, done_job->oper->cb_data);
1922 delete_internal_operation(done_job->iop);
1923 kfree(done_job);
1924 } else {
1925 spin_lock(&cryptocop_completed_jobs_lock);
1926 list_add_tail(&(done_job->node), &cryptocop_completed_jobs);
1927 spin_unlock(&cryptocop_completed_jobs_lock);
1928 tasklet_schedule(&cryptocop_tasklet);
1929 }
1930
1931 DEBUG(printk("cryptocop leave irq handler\n"));
1932 return IRQ_HANDLED;
1933 }
1934
1935
1936 /* Setup interrupts and DMA channels. */
1937 static int init_cryptocop(void)
1938 {
1939 unsigned long flags;
1940 reg_intr_vect_rw_mask intr_mask;
1941 reg_dma_rw_cfg dma_cfg = {.en = 1};
1942 reg_dma_rw_intr_mask intr_mask_in = {.data = regk_dma_yes}; /* Only want descriptor interrupts from the DMA in channel. */
1943 reg_dma_rw_ack_intr ack_intr = {.data = 1,.in_eop = 1 };
1944 reg_strcop_rw_cfg strcop_cfg = {
1945 .ipend = regk_strcop_little,
1946 .td1 = regk_strcop_e,
1947 .td2 = regk_strcop_d,
1948 .td3 = regk_strcop_e,
1949 .ignore_sync = 0,
1950 .en = 1
1951 };
1952
1953 if (request_irq(DMA9_INTR_VECT, dma_done_interrupt, 0, "stream co-processor DMA", NULL)) panic("request_irq stream co-processor irq dma9");
1954
1955 (void)crisv32_request_dma(8, "strcop", DMA_PANIC_ON_ERROR, 0, dma_strp);
1956 (void)crisv32_request_dma(9, "strcop", DMA_PANIC_ON_ERROR, 0, dma_strp);
1957
1958 local_irq_save(flags);
1959
1960 /* Reset and enable the cryptocop. */
1961 strcop_cfg.en = 0;
1962 REG_WR(strcop, regi_strcop, rw_cfg, strcop_cfg);
1963 strcop_cfg.en = 1;
1964 REG_WR(strcop, regi_strcop, rw_cfg, strcop_cfg);
1965
1966 /* Enable DMA9 interrupt */
1967 intr_mask = REG_RD(intr_vect, regi_irq, rw_mask);
1968 intr_mask.dma9 = 1;
1969 REG_WR(intr_vect, regi_irq, rw_mask, intr_mask);
1970
1971 /* Enable DMAs. */
1972 REG_WR(dma, regi_dma9, rw_cfg, dma_cfg); /* input DMA */
1973 REG_WR(dma, regi_dma8, rw_cfg, dma_cfg); /* output DMA */
1974
1975 /* Set up wordsize = 4 for DMAs. */
1976 DMA_WR_CMD (regi_dma8, regk_dma_set_w_size4);
1977 DMA_WR_CMD (regi_dma9, regk_dma_set_w_size4);
1978
1979 /* Enable interrupts. */
1980 REG_WR(dma, regi_dma9, rw_intr_mask, intr_mask_in);
1981
1982 /* Clear intr ack. */
1983 REG_WR(dma, regi_dma9, rw_ack_intr, ack_intr);
1984
1985 local_irq_restore(flags);
1986
1987 return 0;
1988 }
1989
1990 /* Free used cryptocop hw resources (interrupt and DMA channels). */
1991 static void release_cryptocop(void)
1992 {
1993 unsigned long flags;
1994 reg_intr_vect_rw_mask intr_mask;
1995 reg_dma_rw_cfg dma_cfg = {.en = 0};
1996 reg_dma_rw_intr_mask intr_mask_in = {0};
1997 reg_dma_rw_ack_intr ack_intr = {.data = 1,.in_eop = 1 };
1998
1999 local_irq_save(flags);
2000
2001 /* Clear intr ack. */
2002 REG_WR(dma, regi_dma9, rw_ack_intr, ack_intr);
2003
2004 /* Disable DMA9 interrupt */
2005 intr_mask = REG_RD(intr_vect, regi_irq, rw_mask);
2006 intr_mask.dma9 = 0;
2007 REG_WR(intr_vect, regi_irq, rw_mask, intr_mask);
2008
2009 /* Disable DMAs. */
2010 REG_WR(dma, regi_dma9, rw_cfg, dma_cfg); /* input DMA */
2011 REG_WR(dma, regi_dma8, rw_cfg, dma_cfg); /* output DMA */
2012
2013 /* Disable interrupts. */
2014 REG_WR(dma, regi_dma9, rw_intr_mask, intr_mask_in);
2015
2016 local_irq_restore(flags);
2017
2018 free_irq(DMA9_INTR_VECT, NULL);
2019
2020 (void)crisv32_free_dma(8);
2021 (void)crisv32_free_dma(9);
2022 }
2023
2024
2025 /* Init job queue. */
2026 static int cryptocop_job_queue_init(void)
2027 {
2028 int i;
2029
2030 INIT_LIST_HEAD(&cryptocop_completed_jobs);
2031
2032 for (i = 0; i < cryptocop_prio_no_prios; i++){
2033 cryptocop_job_queues[i].prio = (cryptocop_queue_priority)i;
2034 INIT_LIST_HEAD(&cryptocop_job_queues[i].jobs);
2035 }
2036 return 0;
2037 }
2038
2039
2040 static void cryptocop_job_queue_close(void)
2041 {
2042 struct list_head *node, *tmp;
2043 struct cryptocop_prio_job *pj = NULL;
2044 unsigned long int process_flags, flags;
2045 int i;
2046
2047 /* FIXME: This is as yet untested code. */
2048
2049 /* Stop strcop from getting an operation to process while we are closing the
2050 module. */
2051 spin_lock_irqsave(&cryptocop_process_lock, process_flags);
2052
2053 /* Empty the job queue. */
2054 for (i = 0; i < cryptocop_prio_no_prios; i++){
2055 if (!list_empty(&(cryptocop_job_queues[i].jobs))){
2056 list_for_each_safe(node, tmp, &(cryptocop_job_queues[i].jobs)) {
2057 pj = list_entry(node, struct cryptocop_prio_job, node);
2058 list_del(node);
2059
2060 /* Call callback to notify consumer of job removal. */
2061 DEBUG(printk("cryptocop_job_queue_close: callback 0x%p, data 0x%p\n", pj->oper->cb, pj->oper->cb_data));
2062 pj->oper->operation_status = -EINTR; /* Job is terminated without completion. */
2063 pj->oper->cb(pj->oper, pj->oper->cb_data);
2064
2065 delete_internal_operation(pj->iop);
2066 kfree(pj);
2067 }
2068 }
2069 }
2070 spin_unlock_irqrestore(&cryptocop_process_lock, process_flags);
2071
2072 /* Remove the running job, if any. */
2073 spin_lock_irqsave(&running_job_lock, flags);
2074 if (cryptocop_running_job){
2075 reg_strcop_rw_cfg rw_cfg;
2076 reg_dma_rw_cfg dma_out_cfg, dma_in_cfg;
2077
2078 /* Stop DMA. */
2079 dma_out_cfg = REG_RD(dma, regi_dma8, rw_cfg);
2080 dma_out_cfg.en = regk_dma_no;
2081 REG_WR(dma, regi_dma8, rw_cfg, dma_out_cfg);
2082
2083 dma_in_cfg = REG_RD(dma, regi_dma9, rw_cfg);
2084 dma_in_cfg.en = regk_dma_no;
2085 REG_WR(dma, regi_dma9, rw_cfg, dma_in_cfg);
2086
2087 /* Disble the cryptocop. */
2088 rw_cfg = REG_RD(strcop, regi_strcop, rw_cfg);
2089 rw_cfg.en = 0;
2090 REG_WR(strcop, regi_strcop, rw_cfg, rw_cfg);
2091
2092 pj = cryptocop_running_job;
2093 cryptocop_running_job = NULL;
2094
2095 /* Call callback to notify consumer of job removal. */
2096 DEBUG(printk("cryptocop_job_queue_close: callback 0x%p, data 0x%p\n", pj->oper->cb, pj->oper->cb_data));
2097 pj->oper->operation_status = -EINTR; /* Job is terminated without completion. */
2098 pj->oper->cb(pj->oper, pj->oper->cb_data);
2099
2100 delete_internal_operation(pj->iop);
2101 kfree(pj);
2102 }
2103 spin_unlock_irqrestore(&running_job_lock, flags);
2104
2105 /* Remove completed jobs, if any. */
2106 spin_lock_irqsave(&cryptocop_completed_jobs_lock, flags);
2107
2108 list_for_each_safe(node, tmp, &cryptocop_completed_jobs) {
2109 pj = list_entry(node, struct cryptocop_prio_job, node);
2110 list_del(node);
2111 /* Call callback to notify consumer of job removal. */
2112 DEBUG(printk("cryptocop_job_queue_close: callback 0x%p, data 0x%p\n", pj->oper->cb, pj->oper->cb_data));
2113 pj->oper->operation_status = -EINTR; /* Job is terminated without completion. */
2114 pj->oper->cb(pj->oper, pj->oper->cb_data);
2115
2116 delete_internal_operation(pj->iop);
2117 kfree(pj);
2118 }
2119 spin_unlock_irqrestore(&cryptocop_completed_jobs_lock, flags);
2120 }
2121
2122
2123 static void cryptocop_start_job(void)
2124 {
2125 int i;
2126 struct cryptocop_prio_job *pj;
2127 unsigned long int flags;
2128 unsigned long int running_job_flags;
2129 reg_strcop_rw_cfg rw_cfg = {.en = 1, .ignore_sync = 0};
2130
2131 DEBUG(printk("cryptocop_start_job: entering\n"));
2132
2133 spin_lock_irqsave(&running_job_lock, running_job_flags);
2134 if (cryptocop_running_job != NULL){
2135 /* Already running. */
2136 DEBUG(printk("cryptocop_start_job: already running, exit\n"));
2137 spin_unlock_irqrestore(&running_job_lock, running_job_flags);
2138 return;
2139 }
2140 spin_lock_irqsave(&cryptocop_job_queue_lock, flags);
2141
2142 /* Check the queues in priority order. */
2143 for (i = cryptocop_prio_kernel_csum; (i < cryptocop_prio_no_prios) && list_empty(&cryptocop_job_queues[i].jobs); i++);
2144 if (i == cryptocop_prio_no_prios) {
2145 spin_unlock_irqrestore(&cryptocop_job_queue_lock, flags);
2146 spin_unlock_irqrestore(&running_job_lock, running_job_flags);
2147 DEBUG(printk("cryptocop_start_job: no jobs to run\n"));
2148 return; /* No jobs to run */
2149 }
2150 DEBUG(printk("starting job for prio %d\n", i));
2151
2152 /* TODO: Do not starve lower priority jobs. Let in a lower
2153 * prio job for every N-th processed higher prio job or some
2154 * other scheduling policy. This could reasonably be
2155 * tweakable since the optimal balance would depend on the
2156 * type of load on the system. */
2157
2158 /* Pull the DMA lists from the job and start the DMA client. */
2159 pj = list_entry(cryptocop_job_queues[i].jobs.next, struct cryptocop_prio_job, node);
2160 list_del(&pj->node);
2161 spin_unlock_irqrestore(&cryptocop_job_queue_lock, flags);
2162 cryptocop_running_job = pj;
2163
2164 /* Set config register (3DES and CSUM modes). */
2165 switch (pj->iop->tdes_mode){
2166 case cryptocop_3des_eee:
2167 rw_cfg.td1 = regk_strcop_e;
2168 rw_cfg.td2 = regk_strcop_e;
2169 rw_cfg.td3 = regk_strcop_e;
2170 break;
2171 case cryptocop_3des_eed:
2172 rw_cfg.td1 = regk_strcop_e;
2173 rw_cfg.td2 = regk_strcop_e;
2174 rw_cfg.td3 = regk_strcop_d;
2175 break;
2176 case cryptocop_3des_ede:
2177 rw_cfg.td1 = regk_strcop_e;
2178 rw_cfg.td2 = regk_strcop_d;
2179 rw_cfg.td3 = regk_strcop_e;
2180 break;
2181 case cryptocop_3des_edd:
2182 rw_cfg.td1 = regk_strcop_e;
2183 rw_cfg.td2 = regk_strcop_d;
2184 rw_cfg.td3 = regk_strcop_d;
2185 break;
2186 case cryptocop_3des_dee:
2187 rw_cfg.td1 = regk_strcop_d;
2188 rw_cfg.td2 = regk_strcop_e;
2189 rw_cfg.td3 = regk_strcop_e;
2190 break;
2191 case cryptocop_3des_ded:
2192 rw_cfg.td1 = regk_strcop_d;
2193 rw_cfg.td2 = regk_strcop_e;
2194 rw_cfg.td3 = regk_strcop_d;
2195 break;
2196 case cryptocop_3des_dde:
2197 rw_cfg.td1 = regk_strcop_d;
2198 rw_cfg.td2 = regk_strcop_d;
2199 rw_cfg.td3 = regk_strcop_e;
2200 break;
2201 case cryptocop_3des_ddd:
2202 rw_cfg.td1 = regk_strcop_d;
2203 rw_cfg.td2 = regk_strcop_d;
2204 rw_cfg.td3 = regk_strcop_d;
2205 break;
2206 default:
2207 DEBUG(printk("cryptocop_setup_dma_list: bad 3DES mode\n"));
2208 }
2209 switch (pj->iop->csum_mode){
2210 case cryptocop_csum_le:
2211 rw_cfg.ipend = regk_strcop_little;
2212 break;
2213 case cryptocop_csum_be:
2214 rw_cfg.ipend = regk_strcop_big;
2215 break;
2216 default:
2217 DEBUG(printk("cryptocop_setup_dma_list: bad checksum mode\n"));
2218 }
2219 REG_WR(strcop, regi_strcop, rw_cfg, rw_cfg);
2220
2221 DEBUG(printk("cryptocop_start_job: starting DMA, new cryptocop_running_job=0x%p\n"
2222 "ctx_in: 0x%p, phys: 0x%p\n"
2223 "ctx_out: 0x%p, phys: 0x%p\n",
2224 pj,
2225 &pj->iop->ctx_in, (char*)virt_to_phys(&pj->iop->ctx_in),
2226 &pj->iop->ctx_out, (char*)virt_to_phys(&pj->iop->ctx_out)));
2227
2228 /* Start input DMA. */
2229 DMA_START_CONTEXT(regi_dma9, virt_to_phys(&pj->iop->ctx_in));
2230
2231 /* Start output DMA. */
2232 DMA_START_CONTEXT(regi_dma8, virt_to_phys(&pj->iop->ctx_out));
2233
2234 spin_unlock_irqrestore(&running_job_lock, running_job_flags);
2235 DEBUG(printk("cryptocop_start_job: exiting\n"));
2236 }
2237
2238
2239 static int cryptocop_job_setup(struct cryptocop_prio_job **pj, struct cryptocop_operation *operation)
2240 {
2241 int err;
2242 int alloc_flag = operation->in_interrupt ? GFP_ATOMIC : GFP_KERNEL;
2243 void *iop_alloc_ptr = NULL;
2244
2245 *pj = kmalloc(sizeof (struct cryptocop_prio_job), alloc_flag);
2246 if (!*pj) return -ENOMEM;
2247
2248 DEBUG(printk("cryptocop_job_setup: operation=0x%p\n", operation));
2249
2250 (*pj)->oper = operation;
2251 DEBUG(printk("cryptocop_job_setup, cb=0x%p cb_data=0x%p\n", (*pj)->oper->cb, (*pj)->oper->cb_data));
2252
2253 if (operation->use_dmalists) {
2254 DEBUG(print_user_dma_lists(&operation->list_op));
2255 if (!operation->list_op.inlist || !operation->list_op.outlist || !operation->list_op.out_data_buf || !operation->list_op.in_data_buf){
2256 DEBUG_API(printk("cryptocop_job_setup: bad indata (use_dmalists)\n"));
2257 kfree(*pj);
2258 return -EINVAL;
2259 }
2260 iop_alloc_ptr = kmalloc(DESCR_ALLOC_PAD + sizeof(struct cryptocop_int_operation), alloc_flag);
2261 if (!iop_alloc_ptr) {
2262 DEBUG_API(printk("cryptocop_job_setup: kmalloc cryptocop_int_operation\n"));
2263 kfree(*pj);
2264 return -ENOMEM;
2265 }
2266 (*pj)->iop = (struct cryptocop_int_operation*)(((unsigned long int)(iop_alloc_ptr + DESCR_ALLOC_PAD + offsetof(struct cryptocop_int_operation, ctx_out)) & ~0x0000001F) - offsetof(struct cryptocop_int_operation, ctx_out));
2267 DEBUG(memset((*pj)->iop, 0xff, sizeof(struct cryptocop_int_operation)));
2268 (*pj)->iop->alloc_ptr = iop_alloc_ptr;
2269 (*pj)->iop->sid = operation->sid;
2270 (*pj)->iop->cdesc_out = NULL;
2271 (*pj)->iop->cdesc_in = NULL;
2272 (*pj)->iop->tdes_mode = operation->list_op.tdes_mode;
2273 (*pj)->iop->csum_mode = operation->list_op.csum_mode;
2274 (*pj)->iop->ddesc_out = operation->list_op.outlist;
2275 (*pj)->iop->ddesc_in = operation->list_op.inlist;
2276
2277 /* Setup DMA contexts. */
2278 (*pj)->iop->ctx_out.next = NULL;
2279 (*pj)->iop->ctx_out.eol = 1;
2280 (*pj)->iop->ctx_out.saved_data = operation->list_op.outlist;
2281 (*pj)->iop->ctx_out.saved_data_buf = operation->list_op.out_data_buf;
2282
2283 (*pj)->iop->ctx_in.next = NULL;
2284 (*pj)->iop->ctx_in.eol = 1;
2285 (*pj)->iop->ctx_in.saved_data = operation->list_op.inlist;
2286 (*pj)->iop->ctx_in.saved_data_buf = operation->list_op.in_data_buf;
2287 } else {
2288 if ((err = cryptocop_setup_dma_list(operation, &(*pj)->iop, alloc_flag))) {
2289 DEBUG_API(printk("cryptocop_job_setup: cryptocop_setup_dma_list failed %d\n", err));
2290 kfree(*pj);
2291 return err;
2292 }
2293 }
2294 DEBUG(print_dma_descriptors((*pj)->iop));
2295
2296 DEBUG(printk("cryptocop_job_setup, DMA list setup successful\n"));
2297
2298 return 0;
2299 }
2300
2301
2302 static int cryptocop_open(struct inode *inode, struct file *filp)
2303 {
2304 int p = iminor(inode);
2305
2306 if (p != CRYPTOCOP_MINOR) return -EINVAL;
2307
2308 filp->private_data = NULL;
2309 return 0;
2310 }
2311
2312
2313 static int cryptocop_release(struct inode *inode, struct file *filp)
2314 {
2315 struct cryptocop_private *dev = filp->private_data;
2316 struct cryptocop_private *dev_next;
2317
2318 while (dev){
2319 dev_next = dev->next;
2320 if (dev->sid != CRYPTOCOP_SESSION_ID_NONE) {
2321 (void)cryptocop_free_session(dev->sid);
2322 }
2323 kfree(dev);
2324 dev = dev_next;
2325 }
2326
2327 return 0;
2328 }
2329
2330
2331 static int cryptocop_ioctl_close_session(struct inode *inode, struct file *filp,
2332 unsigned int cmd, unsigned long arg)
2333 {
2334 struct cryptocop_private *dev = filp->private_data;
2335 struct cryptocop_private *prev_dev = NULL;
2336 struct strcop_session_op *sess_op = (struct strcop_session_op *)arg;
2337 struct strcop_session_op sop;
2338 int err;
2339
2340 DEBUG(printk("cryptocop_ioctl_close_session\n"));
2341
2342 if (!access_ok(VERIFY_READ, sess_op, sizeof(struct strcop_session_op)))
2343 return -EFAULT;
2344 err = copy_from_user(&sop, sess_op, sizeof(struct strcop_session_op));
2345 if (err) return -EFAULT;
2346
2347 while (dev && (dev->sid != sop.ses_id)) {
2348 prev_dev = dev;
2349 dev = dev->next;
2350 }
2351 if (dev){
2352 if (prev_dev){
2353 prev_dev->next = dev->next;
2354 } else {
2355 filp->private_data = dev->next;
2356 }
2357 err = cryptocop_free_session(dev->sid);
2358 if (err) return -EFAULT;
2359 } else {
2360 DEBUG_API(printk("cryptocop_ioctl_close_session: session %lld not found\n", sop.ses_id));
2361 return -EINVAL;
2362 }
2363 return 0;
2364 }
2365
2366
2367 static void ioctl_process_job_callback(struct cryptocop_operation *op, void*cb_data)
2368 {
2369 struct ioctl_job_cb_ctx *jc = (struct ioctl_job_cb_ctx *)cb_data;
2370
2371 DEBUG(printk("ioctl_process_job_callback: op=0x%p, cb_data=0x%p\n", op, cb_data));
2372
2373 jc->processed = 1;
2374 wake_up(&cryptocop_ioc_process_wq);
2375 }
2376
2377
2378 #define CRYPTOCOP_IOCTL_CIPHER_TID (1)
2379 #define CRYPTOCOP_IOCTL_DIGEST_TID (2)
2380 #define CRYPTOCOP_IOCTL_CSUM_TID (3)
2381
2382 static size_t first_cfg_change_ix(struct strcop_crypto_op *crp_op)
2383 {
2384 size_t ch_ix = 0;
2385
2386 if (crp_op->do_cipher) ch_ix = crp_op->cipher_start;
2387 if (crp_op->do_digest && (crp_op->digest_start < ch_ix)) ch_ix = crp_op->digest_start;
2388 if (crp_op->do_csum && (crp_op->csum_start < ch_ix)) ch_ix = crp_op->csum_start;
2389
2390 DEBUG(printk("first_cfg_change_ix: ix=%d\n", ch_ix));
2391 return ch_ix;
2392 }
2393
2394
2395 static size_t next_cfg_change_ix(struct strcop_crypto_op *crp_op, size_t ix)
2396 {
2397 size_t ch_ix = INT_MAX;
2398 size_t tmp_ix = 0;
2399
2400 if (crp_op->do_cipher && ((crp_op->cipher_start + crp_op->cipher_len) > ix)){
2401 if (crp_op->cipher_start > ix) {
2402 ch_ix = crp_op->cipher_start;
2403 } else {
2404 ch_ix = crp_op->cipher_start + crp_op->cipher_len;
2405 }
2406 }
2407 if (crp_op->do_digest && ((crp_op->digest_start + crp_op->digest_len) > ix)){
2408 if (crp_op->digest_start > ix) {
2409 tmp_ix = crp_op->digest_start;
2410 } else {
2411 tmp_ix = crp_op->digest_start + crp_op->digest_len;
2412 }
2413 if (tmp_ix < ch_ix) ch_ix = tmp_ix;
2414 }
2415 if (crp_op->do_csum && ((crp_op->csum_start + crp_op->csum_len) > ix)){
2416 if (crp_op->csum_start > ix) {
2417 tmp_ix = crp_op->csum_start;
2418 } else {
2419 tmp_ix = crp_op->csum_start + crp_op->csum_len;
2420 }
2421 if (tmp_ix < ch_ix) ch_ix = tmp_ix;
2422 }
2423 if (ch_ix == INT_MAX) ch_ix = ix;
2424 DEBUG(printk("next_cfg_change_ix prev ix=%d, next ix=%d\n", ix, ch_ix));
2425 return ch_ix;
2426 }
2427
2428
2429 /* Map map_length bytes from the pages starting on *pageix and *pageoffset to iovecs starting on *iovix.
2430 * Return -1 for ok, 0 for fail. */
2431 static int map_pages_to_iovec(struct iovec *iov, int iovlen, int *iovix, struct page **pages, int nopages, int *pageix, int *pageoffset, int map_length )
2432 {
2433 int tmplen;
2434
2435 assert(iov != NULL);
2436 assert(iovix != NULL);
2437 assert(pages != NULL);
2438 assert(pageix != NULL);
2439 assert(pageoffset != NULL);
2440
2441 DEBUG(printk("map_pages_to_iovec, map_length=%d, iovlen=%d, *iovix=%d, nopages=%d, *pageix=%d, *pageoffset=%d\n", map_length, iovlen, *iovix, nopages, *pageix, *pageoffset));
2442
2443 while (map_length > 0){
2444 DEBUG(printk("map_pages_to_iovec, map_length=%d, iovlen=%d, *iovix=%d, nopages=%d, *pageix=%d, *pageoffset=%d\n", map_length, iovlen, *iovix, nopages, *pageix, *pageoffset));
2445 if (*iovix >= iovlen){
2446 DEBUG_API(printk("map_page_to_iovec: *iovix=%d >= iovlen=%d\n", *iovix, iovlen));
2447 return 0;
2448 }
2449 if (*pageix >= nopages){
2450 DEBUG_API(printk("map_page_to_iovec: *pageix=%d >= nopages=%d\n", *pageix, nopages));
2451 return 0;
2452 }
2453 iov[*iovix].iov_base = (unsigned char*)page_address(pages[*pageix]) + *pageoffset;
2454 tmplen = PAGE_SIZE - *pageoffset;
2455 if (tmplen < map_length){
2456 (*pageoffset) = 0;
2457 (*pageix)++;
2458 } else {
2459 tmplen = map_length;
2460 (*pageoffset) += map_length;
2461 }
2462 DEBUG(printk("mapping %d bytes from page %d (or %d) to iovec %d\n", tmplen, *pageix, *pageix-1, *iovix));
2463 iov[*iovix].iov_len = tmplen;
2464 map_length -= tmplen;
2465 (*iovix)++;
2466 }
2467 DEBUG(printk("map_page_to_iovec, exit, *iovix=%d\n", *iovix));
2468 return -1;
2469 }
2470
2471
2472
2473 static int cryptocop_ioctl_process(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
2474 {
2475 int i;
2476 struct cryptocop_private *dev = filp->private_data;
2477 struct strcop_crypto_op *crp_oper = (struct strcop_crypto_op *)arg;
2478 struct strcop_crypto_op oper = {0};
2479 int err = 0;
2480 struct cryptocop_operation *cop = NULL;
2481
2482 struct ioctl_job_cb_ctx *jc = NULL;
2483
2484 struct page **inpages = NULL;
2485 struct page **outpages = NULL;
2486 int noinpages = 0;
2487 int nooutpages = 0;
2488
2489 struct cryptocop_desc descs[5]; /* Max 5 descriptors are needed, there are three transforms that
2490 * can get connected/disconnected on different places in the indata. */
2491 struct cryptocop_desc_cfg dcfgs[5*3];
2492 int desc_ix = 0;
2493 int dcfg_ix = 0;
2494 struct cryptocop_tfrm_cfg ciph_tcfg = {0};
2495 struct cryptocop_tfrm_cfg digest_tcfg = {0};
2496 struct cryptocop_tfrm_cfg csum_tcfg = {0};
2497
2498 unsigned char *digest_result = NULL;
2499 int digest_length = 0;
2500 int cblocklen = 0;
2501 unsigned char csum_result[CSUM_BLOCK_LENGTH];
2502 struct cryptocop_session *sess;
2503
2504 int iovlen = 0;
2505 int iovix = 0;
2506 int pageix = 0;
2507 int pageoffset = 0;
2508
2509 size_t prev_ix = 0;
2510 size_t next_ix;
2511
2512 int cipher_active, digest_active, csum_active;
2513 int end_digest, end_csum;
2514 int digest_done = 0;
2515 int cipher_done = 0;
2516 int csum_done = 0;
2517
2518 DEBUG(printk("cryptocop_ioctl_process\n"));
2519
2520 if (!access_ok(VERIFY_WRITE, crp_oper, sizeof(struct strcop_crypto_op))){
2521 DEBUG_API(printk("cryptocop_ioctl_process: !access_ok crp_oper!\n"));
2522 return -EFAULT;
2523 }
2524 if (copy_from_user(&oper, crp_oper, sizeof(struct strcop_crypto_op))) {
2525 DEBUG_API(printk("cryptocop_ioctl_process: copy_from_user\n"));
2526 return -EFAULT;
2527 }
2528 DEBUG(print_strcop_crypto_op(&oper));
2529
2530 while (dev && dev->sid != oper.ses_id) dev = dev->next;
2531 if (!dev){
2532 DEBUG_API(printk("cryptocop_ioctl_process: session %lld not found\n", oper.ses_id));
2533 return -EINVAL;
2534 }
2535
2536 /* Check buffers. */
2537 if (((oper.indata + oper.inlen) < oper.indata) || ((oper.cipher_outdata + oper.cipher_outlen) < oper.cipher_outdata)){
2538 DEBUG_API(printk("cryptocop_ioctl_process: user buffers wrapped around, bad user!\n"));
2539 return -EINVAL;
2540 }
2541
2542 if (!access_ok(VERIFY_WRITE, oper.cipher_outdata, oper.cipher_outlen)){
2543 DEBUG_API(printk("cryptocop_ioctl_process: !access_ok out data!\n"));
2544 return -EFAULT;
2545 }
2546 if (!access_ok(VERIFY_READ, oper.indata, oper.inlen)){
2547 DEBUG_API(printk("cryptocop_ioctl_process: !access_ok in data!\n"));
2548 return -EFAULT;
2549 }
2550
2551 cop = kmalloc(sizeof(struct cryptocop_operation), GFP_KERNEL);
2552 if (!cop) {
2553 DEBUG_API(printk("cryptocop_ioctl_process: kmalloc\n"));
2554 return -ENOMEM;
2555 }
2556 jc = kmalloc(sizeof(struct ioctl_job_cb_ctx), GFP_KERNEL);
2557 if (!jc) {
2558 DEBUG_API(printk("cryptocop_ioctl_process: kmalloc\n"));
2559 err = -ENOMEM;
2560 goto error_cleanup;
2561 }
2562 jc->processed = 0;
2563
2564 cop->cb_data = jc;
2565 cop->cb = ioctl_process_job_callback;
2566 cop->operation_status = 0;
2567 cop->use_dmalists = 0;
2568 cop->in_interrupt = 0;
2569 cop->fast_callback = 0;
2570 cop->tfrm_op.tfrm_cfg = NULL;
2571 cop->tfrm_op.desc = NULL;
2572 cop->tfrm_op.indata = NULL;
2573 cop->tfrm_op.incount = 0;
2574 cop->tfrm_op.inlen = 0;
2575 cop->tfrm_op.outdata = NULL;
2576 cop->tfrm_op.outcount = 0;
2577 cop->tfrm_op.outlen = 0;
2578
2579 sess = get_session(oper.ses_id);
2580 if (!sess){
2581 DEBUG_API(printk("cryptocop_ioctl_process: bad session id.\n"));
2582 kfree(cop);
2583 kfree(jc);
2584 return -EINVAL;
2585 }
2586
2587 if (oper.do_cipher) {
2588 unsigned int cipher_outlen = 0;
2589 struct cryptocop_transform_ctx *tc = get_transform_ctx(sess, CRYPTOCOP_IOCTL_CIPHER_TID);
2590 if (!tc) {
2591 DEBUG_API(printk("cryptocop_ioctl_process: no cipher transform in session.\n"));
2592 err = -EINVAL;
2593 goto error_cleanup;
2594 }
2595 ciph_tcfg.tid = CRYPTOCOP_IOCTL_CIPHER_TID;
2596 ciph_tcfg.inject_ix = 0;
2597 ciph_tcfg.flags = 0;
2598 if ((oper.cipher_start < 0) || (oper.cipher_len <= 0) || (oper.cipher_start > oper.inlen) || ((oper.cipher_start + oper.cipher_len) > oper.inlen)){
2599 DEBUG_API(printk("cryptocop_ioctl_process: bad cipher length\n"));
2600 kfree(cop);
2601 kfree(jc);
2602 return -EINVAL;
2603 }
2604 cblocklen = tc->init.alg == cryptocop_alg_aes ? AES_BLOCK_LENGTH : DES_BLOCK_LENGTH;
2605 if (oper.cipher_len % cblocklen) {
2606 kfree(cop);
2607 kfree(jc);
2608 DEBUG_API(printk("cryptocop_ioctl_process: cipher inlength not multiple of block length.\n"));
2609 return -EINVAL;
2610 }
2611 cipher_outlen = oper.cipher_len;
2612 if (tc->init.cipher_mode == cryptocop_cipher_mode_cbc){
2613 if (oper.cipher_explicit) {
2614 ciph_tcfg.flags |= CRYPTOCOP_EXPLICIT_IV;
2615 memcpy(ciph_tcfg.iv, oper.cipher_iv, cblocklen);
2616 } else {
2617 cipher_outlen = oper.cipher_len - cblocklen;
2618 }
2619 } else {
2620 if (oper.cipher_explicit){
2621 kfree(cop);
2622 kfree(jc);
2623 DEBUG_API(printk("cryptocop_ioctl_process: explicit_iv when not CBC mode\n"));
2624 return -EINVAL;
2625 }
2626 }
2627 if (oper.cipher_outlen != cipher_outlen) {
2628 kfree(cop);
2629 kfree(jc);
2630 DEBUG_API(printk("cryptocop_ioctl_process: cipher_outlen incorrect, should be %d not %d.\n", cipher_outlen, oper.cipher_outlen));
2631 return -EINVAL;
2632 }
2633
2634 if (oper.decrypt){
2635 ciph_tcfg.flags |= CRYPTOCOP_DECRYPT;
2636 } else {
2637 ciph_tcfg.flags |= CRYPTOCOP_ENCRYPT;
2638 }
2639 ciph_tcfg.next = cop->tfrm_op.tfrm_cfg;
2640 cop->tfrm_op.tfrm_cfg = &ciph_tcfg;
2641 }
2642 if (oper.do_digest){
2643 struct cryptocop_transform_ctx *tc = get_transform_ctx(sess, CRYPTOCOP_IOCTL_DIGEST_TID);
2644 if (!tc) {
2645 DEBUG_API(printk("cryptocop_ioctl_process: no digest transform in session.\n"));
2646 err = -EINVAL;
2647 goto error_cleanup;
2648 }
2649 digest_length = tc->init.alg == cryptocop_alg_md5 ? 16 : 20;
2650 digest_result = kmalloc(digest_length, GFP_KERNEL);
2651 if (!digest_result) {
2652 DEBUG_API(printk("cryptocop_ioctl_process: kmalloc digest_result\n"));
2653 err = -EINVAL;
2654 goto error_cleanup;
2655 }
2656 DEBUG(memset(digest_result, 0xff, digest_length));
2657
2658 digest_tcfg.tid = CRYPTOCOP_IOCTL_DIGEST_TID;
2659 digest_tcfg.inject_ix = 0;
2660 ciph_tcfg.inject_ix += digest_length;
2661 if ((oper.digest_start < 0) || (oper.digest_len <= 0) || (oper.digest_start > oper.inlen) || ((oper.digest_start + oper.digest_len) > oper.inlen)){
2662 DEBUG_API(printk("cryptocop_ioctl_process: bad digest length\n"));
2663 err = -EINVAL;
2664 goto error_cleanup;
2665 }
2666
2667 digest_tcfg.next = cop->tfrm_op.tfrm_cfg;
2668 cop->tfrm_op.tfrm_cfg = &digest_tcfg;
2669 }
2670 if (oper.do_csum){
2671 csum_tcfg.tid = CRYPTOCOP_IOCTL_CSUM_TID;
2672 csum_tcfg.inject_ix = digest_length;
2673 ciph_tcfg.inject_ix += 2;
2674
2675 if ((oper.csum_start < 0) || (oper.csum_len <= 0) || (oper.csum_start > oper.inlen) || ((oper.csum_start + oper.csum_len) > oper.inlen)){
2676 DEBUG_API(printk("cryptocop_ioctl_process: bad csum length\n"));
2677 kfree(cop);
2678 kfree(jc);
2679 return -EINVAL;
2680 }
2681
2682 csum_tcfg.next = cop->tfrm_op.tfrm_cfg;
2683 cop->tfrm_op.tfrm_cfg = &csum_tcfg;
2684 }
2685
2686 prev_ix = first_cfg_change_ix(&oper);
2687 if (prev_ix > oper.inlen) {
2688 DEBUG_API(printk("cryptocop_ioctl_process: length mismatch\n"));
2689 nooutpages = noinpages = 0;
2690 err = -EINVAL;
2691 goto error_cleanup;
2692 }
2693 DEBUG(printk("cryptocop_ioctl_process: inlen=%d, cipher_outlen=%d\n", oper.inlen, oper.cipher_outlen));
2694
2695 /* Map user pages for in and out data of the operation. */
2696 noinpages = (((unsigned long int)(oper.indata + prev_ix) & ~PAGE_MASK) + oper.inlen - 1 - prev_ix + ~PAGE_MASK) >> PAGE_SHIFT;
2697 DEBUG(printk("cryptocop_ioctl_process: noinpages=%d\n", noinpages));
2698 inpages = kmalloc(noinpages * sizeof(struct page*), GFP_KERNEL);
2699 if (!inpages){
2700 DEBUG_API(printk("cryptocop_ioctl_process: kmalloc inpages\n"));
2701 nooutpages = noinpages = 0;
2702 err = -ENOMEM;
2703 goto error_cleanup;
2704 }
2705 if (oper.do_cipher){
2706 nooutpages = (((unsigned long int)oper.cipher_outdata & ~PAGE_MASK) + oper.cipher_outlen - 1 + ~PAGE_MASK) >> PAGE_SHIFT;
2707 DEBUG(printk("cryptocop_ioctl_process: nooutpages=%d\n", nooutpages));
2708 outpages = kmalloc(nooutpages * sizeof(struct page*), GFP_KERNEL);
2709 if (!outpages){
2710 DEBUG_API(printk("cryptocop_ioctl_process: kmalloc outpages\n"));
2711 nooutpages = noinpages = 0;
2712 err = -ENOMEM;
2713 goto error_cleanup;
2714 }
2715 }
2716
2717 /* Acquire the mm page semaphore. */
2718 down_read(&current->mm->mmap_sem);
2719
2720 err = get_user_pages(current,
2721 current->mm,
2722 (unsigned long int)(oper.indata + prev_ix),
2723 noinpages,
2724 0, /* read access only for in data */
2725 0, /* no force */
2726 inpages,
2727 NULL);
2728
2729 if (err < 0) {
2730 up_read(&current->mm->mmap_sem);
2731 nooutpages = noinpages = 0;
2732 DEBUG_API(printk("cryptocop_ioctl_process: get_user_pages indata\n"));
2733 goto error_cleanup;
2734 }
2735 noinpages = err;
2736 if (oper.do_cipher){
2737 err = get_user_pages(current,
2738 current->mm,
2739 (unsigned long int)oper.cipher_outdata,
2740 nooutpages,
2741 1, /* write access for out data */
2742 0, /* no force */
2743 outpages,
2744 NULL);
2745 up_read(&current->mm->mmap_sem);
2746 if (err < 0) {
2747 nooutpages = 0;
2748 DEBUG_API(printk("cryptocop_ioctl_process: get_user_pages outdata\n"));
2749 goto error_cleanup;
2750 }
2751 nooutpages = err;
2752 } else {
2753 up_read(&current->mm->mmap_sem);
2754 }
2755
2756 /* Add 6 to nooutpages to make room for possibly inserted buffers for storing digest and
2757 * csum output and splits when units are (dis-)connected. */
2758 cop->tfrm_op.indata = kmalloc((noinpages) * sizeof(struct iovec), GFP_KERNEL);
2759 cop->tfrm_op.outdata = kmalloc((6 + nooutpages) * sizeof(struct iovec), GFP_KERNEL);
2760 if (!cop->tfrm_op.indata || !cop->tfrm_op.outdata) {
2761 DEBUG_API(printk("cryptocop_ioctl_process: kmalloc iovecs\n"));
2762 err = -ENOMEM;
2763 goto error_cleanup;
2764 }
2765
2766 cop->tfrm_op.inlen = oper.inlen - prev_ix;
2767 cop->tfrm_op.outlen = 0;
2768 if (oper.do_cipher) cop->tfrm_op.outlen += oper.cipher_outlen;
2769 if (oper.do_digest) cop->tfrm_op.outlen += digest_length;
2770 if (oper.do_csum) cop->tfrm_op.outlen += 2;
2771
2772 /* Setup the in iovecs. */
2773 cop->tfrm_op.incount = noinpages;
2774 if (noinpages > 1){
2775 size_t tmplen = cop->tfrm_op.inlen;
2776
2777 cop->tfrm_op.indata[0].iov_len = PAGE_SIZE - ((unsigned long int)(oper.indata + prev_ix) & ~PAGE_MASK);
2778 cop->tfrm_op.indata[0].iov_base = (unsigned char*)page_address(inpages[0]) + ((unsigned long int)(oper.indata + prev_ix) & ~PAGE_MASK);
2779 tmplen -= cop->tfrm_op.indata[0].iov_len;
2780 for (i = 1; i<noinpages; i++){
2781 cop->tfrm_op.indata[i].iov_len = tmplen < PAGE_SIZE ? tmplen : PAGE_SIZE;
2782 cop->tfrm_op.indata[i].iov_base = (unsigned char*)page_address(inpages[i]);
2783 tmplen -= PAGE_SIZE;
2784 }
2785 } else {
2786 cop->tfrm_op.indata[0].iov_len = oper.inlen - prev_ix;
2787 cop->tfrm_op.indata[0].iov_base = (unsigned char*)page_address(inpages[0]) + ((unsigned long int)(oper.indata + prev_ix) & ~PAGE_MASK);
2788 }
2789
2790 iovlen = nooutpages + 6;
2791 pageoffset = oper.do_cipher ? ((unsigned long int)oper.cipher_outdata & ~PAGE_MASK) : 0;
2792
2793 next_ix = next_cfg_change_ix(&oper, prev_ix);
2794 if (prev_ix == next_ix){
2795 DEBUG_API(printk("cryptocop_ioctl_process: length configuration broken.\n"));
2796 err = -EINVAL; /* This should be impossible barring bugs. */
2797 goto error_cleanup;
2798 }
2799 while (prev_ix != next_ix){
2800 end_digest = end_csum = cipher_active = digest_active = csum_active = 0;
2801 descs[desc_ix].cfg = NULL;
2802 descs[desc_ix].length = next_ix - prev_ix;
2803
2804 if (oper.do_cipher && (oper.cipher_start < next_ix) && (prev_ix < (oper.cipher_start + oper.cipher_len))) {
2805 dcfgs[dcfg_ix].tid = CRYPTOCOP_IOCTL_CIPHER_TID;
2806 dcfgs[dcfg_ix].src = cryptocop_source_dma;
2807 cipher_active = 1;
2808
2809 if (next_ix == (oper.cipher_start + oper.cipher_len)){
2810 cipher_done = 1;
2811 dcfgs[dcfg_ix].last = 1;
2812 } else {
2813 dcfgs[dcfg_ix].last = 0;
2814 }
2815 dcfgs[dcfg_ix].next = descs[desc_ix].cfg;
2816 descs[desc_ix].cfg = &dcfgs[dcfg_ix];
2817 ++dcfg_ix;
2818 }
2819 if (oper.do_digest && (oper.digest_start < next_ix) && (prev_ix < (oper.digest_start + oper.digest_len))) {
2820 digest_active = 1;
2821 dcfgs[dcfg_ix].tid = CRYPTOCOP_IOCTL_DIGEST_TID;
2822 dcfgs[dcfg_ix].src = cryptocop_source_dma;
2823 if (next_ix == (oper.digest_start + oper.digest_len)){
2824 assert(!digest_done);
2825 digest_done = 1;
2826 dcfgs[dcfg_ix].last = 1;
2827 } else {
2828 dcfgs[dcfg_ix].last = 0;
2829 }
2830 dcfgs[dcfg_ix].next = descs[desc_ix].cfg;
2831 descs[desc_ix].cfg = &dcfgs[dcfg_ix];
2832 ++dcfg_ix;
2833 }
2834 if (oper.do_csum && (oper.csum_start < next_ix) && (prev_ix < (oper.csum_start + oper.csum_len))){
2835 csum_active = 1;
2836 dcfgs[dcfg_ix].tid = CRYPTOCOP_IOCTL_CSUM_TID;
2837 dcfgs[dcfg_ix].src = cryptocop_source_dma;
2838 if (next_ix == (oper.csum_start + oper.csum_len)){
2839 csum_done = 1;
2840 dcfgs[dcfg_ix].last = 1;
2841 } else {
2842 dcfgs[dcfg_ix].last = 0;
2843 }
2844 dcfgs[dcfg_ix].next = descs[desc_ix].cfg;
2845 descs[desc_ix].cfg = &dcfgs[dcfg_ix];
2846 ++dcfg_ix;
2847 }
2848 if (!descs[desc_ix].cfg){
2849 DEBUG_API(printk("cryptocop_ioctl_process: data segment %d (%d to %d) had no active transforms\n", desc_ix, prev_ix, next_ix));
2850 err = -EINVAL;
2851 goto error_cleanup;
2852 }
2853 descs[desc_ix].next = &(descs[desc_ix]) + 1;
2854 ++desc_ix;
2855 prev_ix = next_ix;
2856 next_ix = next_cfg_change_ix(&oper, prev_ix);
2857 }
2858 if (desc_ix > 0){
2859 descs[desc_ix-1].next = NULL;
2860 } else {
2861 descs[0].next = NULL;
2862 }
2863 if (oper.do_digest) {
2864 DEBUG(printk("cryptocop_ioctl_process: mapping %d byte digest output to iovec %d\n", digest_length, iovix));
2865 /* Add outdata iovec, length == <length of type of digest> */
2866 cop->tfrm_op.outdata[iovix].iov_base = digest_result;
2867 cop->tfrm_op.outdata[iovix].iov_len = digest_length;
2868 ++iovix;
2869 }
2870 if (oper.do_csum) {
2871 /* Add outdata iovec, length == 2, the length of csum. */
2872 DEBUG(printk("cryptocop_ioctl_process: mapping 2 byte csum output to iovec %d\n", iovix));
2873 /* Add outdata iovec, length == <length of type of digest> */
2874 cop->tfrm_op.outdata[iovix].iov_base = csum_result;
2875 cop->tfrm_op.outdata[iovix].iov_len = 2;
2876 ++iovix;
2877 }
2878 if (oper.do_cipher) {
2879 if (!map_pages_to_iovec(cop->tfrm_op.outdata, iovlen, &iovix, outpages, nooutpages, &pageix, &pageoffset, oper.cipher_outlen)){
2880 DEBUG_API(printk("cryptocop_ioctl_process: failed to map pages to iovec.\n"));
2881 err = -ENOSYS; /* This should be impossible barring bugs. */
2882 goto error_cleanup;
2883 }
2884 }
2885 DEBUG(printk("cryptocop_ioctl_process: setting cop->tfrm_op.outcount %d\n", iovix));
2886 cop->tfrm_op.outcount = iovix;
2887 assert(iovix <= (nooutpages + 6));
2888
2889 cop->sid = oper.ses_id;
2890 cop->tfrm_op.desc = &descs[0];
2891
2892 DEBUG(printk("cryptocop_ioctl_process: inserting job, cb_data=0x%p\n", cop->cb_data));
2893
2894 if ((err = cryptocop_job_queue_insert_user_job(cop)) != 0) {
2895 DEBUG_API(printk("cryptocop_ioctl_process: insert job %d\n", err));
2896 err = -EINVAL;
2897 goto error_cleanup;
2898 }
2899
2900 DEBUG(printk("cryptocop_ioctl_process: begin wait for result\n"));
2901
2902 wait_event(cryptocop_ioc_process_wq, (jc->processed != 0));
2903 DEBUG(printk("cryptocop_ioctl_process: end wait for result\n"));
2904 if (!jc->processed){
2905 printk(KERN_WARNING "cryptocop_ioctl_process: job not processed at completion\n");
2906 err = -EIO;
2907 goto error_cleanup;
2908 }
2909
2910 /* Job process done. Cipher output should already be correct in job so no post processing of outdata. */
2911 DEBUG(printk("cryptocop_ioctl_process: operation_status = %d\n", cop->operation_status));
2912 if (cop->operation_status == 0){
2913 if (oper.do_digest){
2914 DEBUG(printk("cryptocop_ioctl_process: copy %d bytes digest to user\n", digest_length));
2915 err = copy_to_user((unsigned char*)crp_oper + offsetof(struct strcop_crypto_op, digest), digest_result, digest_length);
2916 if (0 != err){
2917 DEBUG_API(printk("cryptocop_ioctl_process: copy_to_user, digest length %d, err %d\n", digest_length, err));
2918 err = -EFAULT;
2919 goto error_cleanup;
2920 }
2921 }
2922 if (oper.do_csum){
2923 DEBUG(printk("cryptocop_ioctl_process: copy 2 bytes checksum to user\n"));
2924 err = copy_to_user((unsigned char*)crp_oper + offsetof(struct strcop_crypto_op, csum), csum_result, 2);
2925 if (0 != err){
2926 DEBUG_API(printk("cryptocop_ioctl_process: copy_to_user, csum, err %d\n", err));
2927 err = -EFAULT;
2928 goto error_cleanup;
2929 }
2930 }
2931 err = 0;
2932 } else {
2933 DEBUG(printk("cryptocop_ioctl_process: returning err = operation_status = %d\n", cop->operation_status));
2934 err = cop->operation_status;
2935 }
2936
2937 error_cleanup:
2938 /* Release page caches. */
2939 for (i = 0; i < noinpages; i++){
2940 put_page(inpages[i]);
2941 }
2942 for (i = 0; i < nooutpages; i++){
2943 int spdl_err;
2944 /* Mark output pages dirty. */
2945 spdl_err = set_page_dirty_lock(outpages[i]);
2946 DEBUG(if (spdl_err < 0)printk("cryptocop_ioctl_process: set_page_dirty_lock returned %d\n", spdl_err));
2947 }
2948 for (i = 0; i < nooutpages; i++){
2949 put_page(outpages[i]);
2950 }
2951
2952 kfree(digest_result);
2953 kfree(inpages);
2954 kfree(outpages);
2955 if (cop){
2956 kfree(cop->tfrm_op.indata);
2957 kfree(cop->tfrm_op.outdata);
2958 kfree(cop);
2959 }
2960 kfree(jc);
2961
2962 DEBUG(print_lock_status());
2963
2964 return err;
2965 }
2966
2967
2968 static int cryptocop_ioctl_create_session(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
2969 {
2970 cryptocop_session_id sid;
2971 int err;
2972 struct cryptocop_private *dev;
2973 struct strcop_session_op *sess_op = (struct strcop_session_op *)arg;
2974 struct strcop_session_op sop;
2975 struct cryptocop_transform_init *tis = NULL;
2976 struct cryptocop_transform_init ti_cipher = {0};
2977 struct cryptocop_transform_init ti_digest = {0};
2978 struct cryptocop_transform_init ti_csum = {0};
2979
2980 if (!access_ok(VERIFY_WRITE, sess_op, sizeof(struct strcop_session_op)))
2981 return -EFAULT;
2982 err = copy_from_user(&sop, sess_op, sizeof(struct strcop_session_op));
2983 if (err) return -EFAULT;
2984 if (sop.cipher != cryptocop_cipher_none) {
2985 if (!access_ok(VERIFY_READ, sop.key, sop.keylen)) return -EFAULT;
2986 }
2987 DEBUG(printk("cryptocop_ioctl_create_session, sess_op:\n"));
2988
2989 DEBUG(printk("\tcipher:%d\n"
2990 "\tcipher_mode:%d\n"
2991 "\tdigest:%d\n"
2992 "\tcsum:%d\n",
2993 (int)sop.cipher,
2994 (int)sop.cmode,
2995 (int)sop.digest,
2996 (int)sop.csum));
2997
2998 if (sop.cipher != cryptocop_cipher_none){
2999 /* Init the cipher. */
3000 switch (sop.cipher){
3001 case cryptocop_cipher_des:
3002 ti_cipher.alg = cryptocop_alg_des;
3003 break;
3004 case cryptocop_cipher_3des:
3005 ti_cipher.alg = cryptocop_alg_3des;
3006 break;
3007 case cryptocop_cipher_aes:
3008 ti_cipher.alg = cryptocop_alg_aes;
3009 break;
3010 default:
3011 DEBUG_API(printk("create session, bad cipher algorithm %d\n", sop.cipher));
3012 return -EINVAL;
3013 };
3014 DEBUG(printk("setting cipher transform %d\n", ti_cipher.alg));
3015 copy_from_user(ti_cipher.key, sop.key, sop.keylen/8);
3016 ti_cipher.keylen = sop.keylen;
3017 switch (sop.cmode){
3018 case cryptocop_cipher_mode_cbc:
3019 case cryptocop_cipher_mode_ecb:
3020 ti_cipher.cipher_mode = sop.cmode;
3021 break;
3022 default:
3023 DEBUG_API(printk("create session, bad cipher mode %d\n", sop.cmode));
3024 return -EINVAL;
3025 }
3026 DEBUG(printk("cryptocop_ioctl_create_session: setting CBC mode %d\n", ti_cipher.cipher_mode));
3027 switch (sop.des3_mode){
3028 case cryptocop_3des_eee:
3029 case cryptocop_3des_eed:
3030 case cryptocop_3des_ede:
3031 case cryptocop_3des_edd:
3032 case cryptocop_3des_dee:
3033 case cryptocop_3des_ded:
3034 case cryptocop_3des_dde:
3035 case cryptocop_3des_ddd:
3036 ti_cipher.tdes_mode = sop.des3_mode;
3037 break;
3038 default:
3039 DEBUG_API(printk("create session, bad 3DES mode %d\n", sop.des3_mode));
3040 return -EINVAL;
3041 }
3042 ti_cipher.tid = CRYPTOCOP_IOCTL_CIPHER_TID;
3043 ti_cipher.next = tis;
3044 tis = &ti_cipher;
3045 } /* if (sop.cipher != cryptocop_cipher_none) */
3046 if (sop.digest != cryptocop_digest_none){
3047 DEBUG(printk("setting digest transform\n"));
3048 switch (sop.digest){
3049 case cryptocop_digest_md5:
3050 ti_digest.alg = cryptocop_alg_md5;
3051 break;
3052 case cryptocop_digest_sha1:
3053 ti_digest.alg = cryptocop_alg_sha1;
3054 break;
3055 default:
3056 DEBUG_API(printk("create session, bad digest algorithm %d\n", sop.digest));
3057 return -EINVAL;
3058 }
3059 ti_digest.tid = CRYPTOCOP_IOCTL_DIGEST_TID;
3060 ti_digest.next = tis;
3061 tis = &ti_digest;
3062 } /* if (sop.digest != cryptocop_digest_none) */
3063 if (sop.csum != cryptocop_csum_none){
3064 DEBUG(printk("setting csum transform\n"));
3065 switch (sop.csum){
3066 case cryptocop_csum_le:
3067 case cryptocop_csum_be:
3068 ti_csum.csum_mode = sop.csum;
3069 break;
3070 default:
3071 DEBUG_API(printk("create session, bad checksum algorithm %d\n", sop.csum));
3072 return -EINVAL;
3073 }
3074 ti_csum.alg = cryptocop_alg_csum;
3075 ti_csum.tid = CRYPTOCOP_IOCTL_CSUM_TID;
3076 ti_csum.next = tis;
3077 tis = &ti_csum;
3078 } /* (sop.csum != cryptocop_csum_none) */
3079 dev = kmalloc(sizeof(struct cryptocop_private), GFP_KERNEL);
3080 if (!dev){
3081 DEBUG_API(printk("create session, alloc dev\n"));
3082 return -ENOMEM;
3083 }
3084
3085 err = cryptocop_new_session(&sid, tis, GFP_KERNEL);
3086 DEBUG({ if (err) printk("create session, cryptocop_new_session %d\n", err);});
3087
3088 if (err) {
3089 kfree(dev);
3090 return err;
3091 }
3092 sess_op->ses_id = sid;
3093 dev->sid = sid;
3094 dev->next = filp->private_data;
3095 filp->private_data = dev;
3096
3097 return 0;
3098 }
3099
3100 static int cryptocop_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
3101 {
3102 int err = 0;
3103 if (_IOC_TYPE(cmd) != ETRAXCRYPTOCOP_IOCTYPE) {
3104 DEBUG_API(printk("cryptocop_ioctl: wrong type\n"));
3105 return -ENOTTY;
3106 }
3107 if (_IOC_NR(cmd) > CRYPTOCOP_IO_MAXNR){
3108 return -ENOTTY;
3109 }
3110 /* Access check of the argument. Some commands, e.g. create session and process op,
3111 needs additional checks. Those are handled in the command handling functions. */
3112 if (_IOC_DIR(cmd) & _IOC_READ)
3113 err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
3114 else if (_IOC_DIR(cmd) & _IOC_WRITE)
3115 err = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
3116 if (err) return -EFAULT;
3117
3118 switch (cmd) {
3119 case CRYPTOCOP_IO_CREATE_SESSION:
3120 return cryptocop_ioctl_create_session(inode, filp, cmd, arg);
3121 case CRYPTOCOP_IO_CLOSE_SESSION:
3122 return cryptocop_ioctl_close_session(inode, filp, cmd, arg);
3123 case CRYPTOCOP_IO_PROCESS_OP:
3124 return cryptocop_ioctl_process(inode, filp, cmd, arg);
3125 default:
3126 DEBUG_API(printk("cryptocop_ioctl: unknown command\n"));
3127 return -ENOTTY;
3128 }
3129 return 0;
3130 }
3131
3132
3133 #ifdef LDEBUG
3134 static void print_dma_descriptors(struct cryptocop_int_operation *iop)
3135 {
3136 struct cryptocop_dma_desc *cdesc_out = iop->cdesc_out;
3137 struct cryptocop_dma_desc *cdesc_in = iop->cdesc_in;
3138 int i;
3139
3140 printk("print_dma_descriptors start\n");
3141
3142 printk("iop:\n");
3143 printk("\tsid: 0x%lld\n", iop->sid);
3144
3145 printk("\tcdesc_out: 0x%p\n", iop->cdesc_out);
3146 printk("\tcdesc_in: 0x%p\n", iop->cdesc_in);
3147 printk("\tddesc_out: 0x%p\n", iop->ddesc_out);
3148 printk("\tddesc_in: 0x%p\n", iop->ddesc_in);
3149
3150 printk("\niop->ctx_out: 0x%p phys: 0x%p\n", &iop->ctx_out, (char*)virt_to_phys(&iop->ctx_out));
3151 printk("\tnext: 0x%p\n"
3152 "\tsaved_data: 0x%p\n"
3153 "\tsaved_data_buf: 0x%p\n",
3154 iop->ctx_out.next,
3155 iop->ctx_out.saved_data,
3156 iop->ctx_out.saved_data_buf);
3157
3158 printk("\niop->ctx_in: 0x%p phys: 0x%p\n", &iop->ctx_in, (char*)virt_to_phys(&iop->ctx_in));
3159 printk("\tnext: 0x%p\n"
3160 "\tsaved_data: 0x%p\n"
3161 "\tsaved_data_buf: 0x%p\n",
3162 iop->ctx_in.next,
3163 iop->ctx_in.saved_data,
3164 iop->ctx_in.saved_data_buf);
3165
3166 i = 0;
3167 while (cdesc_out) {
3168 dma_descr_data *td;
3169 printk("cdesc_out %d, desc=0x%p\n", i, cdesc_out->dma_descr);
3170 printk("\n\tvirt_to_phys(desc): 0x%p\n", (char*)virt_to_phys(cdesc_out->dma_descr));
3171 td = cdesc_out->dma_descr;
3172 printk("\n\tbuf: 0x%p\n"
3173 "\tafter: 0x%p\n"
3174 "\tmd: 0x%04x\n"
3175 "\tnext: 0x%p\n",
3176 td->buf,
3177 td->after,
3178 td->md,
3179 td->next);
3180 printk("flags:\n"
3181 "\twait:\t%d\n"
3182 "\teol:\t%d\n"
3183 "\touteop:\t%d\n"
3184 "\tineop:\t%d\n"
3185 "\tintr:\t%d\n",
3186 td->wait,
3187 td->eol,
3188 td->out_eop,
3189 td->in_eop,
3190 td->intr);
3191 cdesc_out = cdesc_out->next;
3192 i++;
3193 }
3194 i = 0;
3195 while (cdesc_in) {
3196 dma_descr_data *td;
3197 printk("cdesc_in %d, desc=0x%p\n", i, cdesc_in->dma_descr);
3198 printk("\n\tvirt_to_phys(desc): 0x%p\n", (char*)virt_to_phys(cdesc_in->dma_descr));
3199 td = cdesc_in->dma_descr;
3200 printk("\n\tbuf: 0x%p\n"
3201 "\tafter: 0x%p\n"
3202 "\tmd: 0x%04x\n"
3203 "\tnext: 0x%p\n",
3204 td->buf,
3205 td->after,
3206 td->md,
3207 td->next);
3208 printk("flags:\n"
3209 "\twait:\t%d\n"
3210 "\teol:\t%d\n"
3211 "\touteop:\t%d\n"
3212 "\tineop:\t%d\n"
3213 "\tintr:\t%d\n",
3214 td->wait,
3215 td->eol,
3216 td->out_eop,
3217 td->in_eop,
3218 td->intr);
3219 cdesc_in = cdesc_in->next;
3220 i++;
3221 }
3222
3223 printk("print_dma_descriptors end\n");
3224 }
3225
3226
3227 static void print_strcop_crypto_op(struct strcop_crypto_op *cop)
3228 {
3229 printk("print_strcop_crypto_op, 0x%p\n", cop);
3230
3231 /* Indata. */
3232 printk("indata=0x%p\n"
3233 "inlen=%d\n"
3234 "do_cipher=%d\n"
3235 "decrypt=%d\n"
3236 "cipher_explicit=%d\n"
3237 "cipher_start=%d\n"
3238 "cipher_len=%d\n"
3239 "outdata=0x%p\n"
3240 "outlen=%d\n",
3241 cop->indata,
3242 cop->inlen,
3243 cop->do_cipher,
3244 cop->decrypt,
3245 cop->cipher_explicit,
3246 cop->cipher_start,
3247 cop->cipher_len,
3248 cop->cipher_outdata,
3249 cop->cipher_outlen);
3250
3251 printk("do_digest=%d\n"
3252 "digest_start=%d\n"
3253 "digest_len=%d\n",
3254 cop->do_digest,
3255 cop->digest_start,
3256 cop->digest_len);
3257
3258 printk("do_csum=%d\n"
3259 "csum_start=%d\n"
3260 "csum_len=%d\n",
3261 cop->do_csum,
3262 cop->csum_start,
3263 cop->csum_len);
3264 }
3265
3266 static void print_cryptocop_operation(struct cryptocop_operation *cop)
3267 {
3268 struct cryptocop_desc *d;
3269 struct cryptocop_tfrm_cfg *tc;
3270 struct cryptocop_desc_cfg *dc;
3271 int i;
3272
3273 printk("print_cryptocop_operation, cop=0x%p\n\n", cop);
3274 printk("sid: %lld\n", cop->sid);
3275 printk("operation_status=%d\n"
3276 "use_dmalists=%d\n"
3277 "in_interrupt=%d\n"
3278 "fast_callback=%d\n",
3279 cop->operation_status,
3280 cop->use_dmalists,
3281 cop->in_interrupt,
3282 cop->fast_callback);
3283
3284 if (cop->use_dmalists){
3285 print_user_dma_lists(&cop->list_op);
3286 } else {
3287 printk("cop->tfrm_op\n"
3288 "tfrm_cfg=0x%p\n"
3289 "desc=0x%p\n"
3290 "indata=0x%p\n"
3291 "incount=%d\n"
3292 "inlen=%d\n"
3293 "outdata=0x%p\n"
3294 "outcount=%d\n"
3295 "outlen=%d\n\n",
3296 cop->tfrm_op.tfrm_cfg,
3297 cop->tfrm_op.desc,
3298 cop->tfrm_op.indata,
3299 cop->tfrm_op.incount,
3300 cop->tfrm_op.inlen,
3301 cop->tfrm_op.outdata,
3302 cop->tfrm_op.outcount,
3303 cop->tfrm_op.outlen);
3304
3305 tc = cop->tfrm_op.tfrm_cfg;
3306 while (tc){
3307 printk("tfrm_cfg, 0x%p\n"
3308 "tid=%d\n"
3309 "flags=%d\n"
3310 "inject_ix=%d\n"
3311 "next=0x%p\n",
3312 tc,
3313 tc->tid,
3314 tc->flags,
3315 tc->inject_ix,
3316 tc->next);
3317 tc = tc->next;
3318 }
3319 d = cop->tfrm_op.desc;
3320 while (d){
3321 printk("\n======================desc, 0x%p\n"
3322 "length=%d\n"
3323 "cfg=0x%p\n"
3324 "next=0x%p\n",
3325 d,
3326 d->length,
3327 d->cfg,
3328 d->next);
3329 dc = d->cfg;
3330 while (dc){
3331 printk("=========desc_cfg, 0x%p\n"
3332 "tid=%d\n"
3333 "src=%d\n"
3334 "last=%d\n"
3335 "next=0x%p\n",
3336 dc,
3337 dc->tid,
3338 dc->src,
3339 dc->last,
3340 dc->next);
3341 dc = dc->next;
3342 }
3343 d = d->next;
3344 }
3345 printk("\n====iniov\n");
3346 for (i = 0; i < cop->tfrm_op.incount; i++){
3347 printk("indata[%d]\n"
3348 "base=0x%p\n"
3349 "len=%d\n",
3350 i,
3351 cop->tfrm_op.indata[i].iov_base,
3352 cop->tfrm_op.indata[i].iov_len);
3353 }
3354 printk("\n====outiov\n");
3355 for (i = 0; i < cop->tfrm_op.outcount; i++){
3356 printk("outdata[%d]\n"
3357 "base=0x%p\n"
3358 "len=%d\n",
3359 i,
3360 cop->tfrm_op.outdata[i].iov_base,
3361 cop->tfrm_op.outdata[i].iov_len);
3362 }
3363 }
3364 printk("------------end print_cryptocop_operation\n");
3365 }
3366
3367
3368 static void print_user_dma_lists(struct cryptocop_dma_list_operation *dma_op)
3369 {
3370 dma_descr_data *dd;
3371 int i;
3372
3373 printk("print_user_dma_lists, dma_op=0x%p\n", dma_op);
3374
3375 printk("out_data_buf = 0x%p, phys_to_virt(out_data_buf) = 0x%p\n", dma_op->out_data_buf, phys_to_virt((unsigned long int)dma_op->out_data_buf));
3376 printk("in_data_buf = 0x%p, phys_to_virt(in_data_buf) = 0x%p\n", dma_op->in_data_buf, phys_to_virt((unsigned long int)dma_op->in_data_buf));
3377
3378 printk("##############outlist\n");
3379 dd = phys_to_virt((unsigned long int)dma_op->outlist);
3380 i = 0;
3381 while (dd != NULL) {
3382 printk("#%d phys_to_virt(desc) 0x%p\n", i, dd);
3383 printk("\n\tbuf: 0x%p\n"
3384 "\tafter: 0x%p\n"
3385 "\tmd: 0x%04x\n"
3386 "\tnext: 0x%p\n",
3387 dd->buf,
3388 dd->after,
3389 dd->md,
3390 dd->next);
3391 printk("flags:\n"
3392 "\twait:\t%d\n"
3393 "\teol:\t%d\n"
3394 "\touteop:\t%d\n"
3395 "\tineop:\t%d\n"
3396 "\tintr:\t%d\n",
3397 dd->wait,
3398 dd->eol,
3399 dd->out_eop,
3400 dd->in_eop,
3401 dd->intr);
3402 if (dd->eol)
3403 dd = NULL;
3404 else
3405 dd = phys_to_virt((unsigned long int)dd->next);
3406 ++i;
3407 }
3408
3409 printk("##############inlist\n");
3410 dd = phys_to_virt((unsigned long int)dma_op->inlist);
3411 i = 0;
3412 while (dd != NULL) {
3413 printk("#%d phys_to_virt(desc) 0x%p\n", i, dd);
3414 printk("\n\tbuf: 0x%p\n"
3415 "\tafter: 0x%p\n"
3416 "\tmd: 0x%04x\n"
3417 "\tnext: 0x%p\n",
3418 dd->buf,
3419 dd->after,
3420 dd->md,
3421 dd->next);
3422 printk("flags:\n"
3423 "\twait:\t%d\n"
3424 "\teol:\t%d\n"
3425 "\touteop:\t%d\n"
3426 "\tineop:\t%d\n"
3427 "\tintr:\t%d\n",
3428 dd->wait,
3429 dd->eol,
3430 dd->out_eop,
3431 dd->in_eop,
3432 dd->intr);
3433 if (dd->eol)
3434 dd = NULL;
3435 else
3436 dd = phys_to_virt((unsigned long int)dd->next);
3437 ++i;
3438 }
3439 }
3440
3441
3442 static void print_lock_status(void)
3443 {
3444 printk("**********************print_lock_status\n");
3445 printk("cryptocop_completed_jobs_lock %d\n", spin_is_locked(&cryptocop_completed_jobs_lock));
3446 printk("cryptocop_job_queue_lock %d\n", spin_is_locked(&cryptocop_job_queue_lock));
3447 printk("descr_pool_lock %d\n", spin_is_locked(&descr_pool_lock));
3448 printk("cryptocop_sessions_lock %d\n", spin_is_locked(cryptocop_sessions_lock));
3449 printk("running_job_lock %d\n", spin_is_locked(running_job_lock));
3450 printk("cryptocop_process_lock %d\n", spin_is_locked(cryptocop_process_lock));
3451 }
3452 #endif /* LDEBUG */
3453
3454
3455 static const char cryptocop_name[] = "ETRAX FS stream co-processor";
3456
3457 static int init_stream_coprocessor(void)
3458 {
3459 int err;
3460 int i;
3461 static int initialized = 0;
3462
3463 if (initialized)
3464 return 0;
3465
3466 initialized = 1;
3467
3468 printk("ETRAX FS stream co-processor driver v0.01, (c) 2003 Axis Communications AB\n");
3469
3470 err = register_chrdev(CRYPTOCOP_MAJOR, cryptocop_name, &cryptocop_fops);
3471 if (err < 0) {
3472 printk(KERN_ERR "stream co-processor: could not get major number.\n");
3473 return err;
3474 }
3475
3476 err = init_cryptocop();
3477 if (err) {
3478 (void)unregister_chrdev(CRYPTOCOP_MAJOR, cryptocop_name);
3479 return err;
3480 }
3481 err = cryptocop_job_queue_init();
3482 if (err) {
3483 release_cryptocop();
3484 (void)unregister_chrdev(CRYPTOCOP_MAJOR, cryptocop_name);
3485 return err;
3486 }
3487 /* Init the descriptor pool. */
3488 for (i = 0; i < CRYPTOCOP_DESCRIPTOR_POOL_SIZE - 1; i++) {
3489 descr_pool[i].from_pool = 1;
3490 descr_pool[i].next = &descr_pool[i + 1];
3491 }
3492 descr_pool[i].from_pool = 1;
3493 descr_pool[i].next = NULL;
3494 descr_pool_free_list = &descr_pool[0];
3495 descr_pool_no_free = CRYPTOCOP_DESCRIPTOR_POOL_SIZE;
3496
3497 spin_lock_init(&cryptocop_completed_jobs_lock);
3498 spin_lock_init(&cryptocop_job_queue_lock);
3499 spin_lock_init(&descr_pool_lock);
3500 spin_lock_init(&cryptocop_sessions_lock);
3501 spin_lock_init(&running_job_lock);
3502 spin_lock_init(&cryptocop_process_lock);
3503
3504 cryptocop_sessions = NULL;
3505 next_sid = 1;
3506
3507 cryptocop_running_job = NULL;
3508
3509 printk("stream co-processor: init done.\n");
3510 return 0;
3511 }
3512
3513 static void __exit exit_stream_coprocessor(void)
3514 {
3515 release_cryptocop();
3516 cryptocop_job_queue_close();
3517 }
3518
3519 module_init(init_stream_coprocessor);
3520 module_exit(exit_stream_coprocessor);
3521
hh.org GIT migration