kernel: linux/version.h was removed in kernel 2.6.19 and is now replaced by generated...
[openwrt/svn-archive/archive.git] / target / linux / generic / files / crypto / ocf / cryptocteon / cryptocteon.c
1 /*
2 * Octeon Crypto for OCF
3 *
4 * Written by David McCullough <david_mccullough@mcafee.com>
5 * Copyright (C) 2009-2010 David McCullough
6 *
7 * LICENSE TERMS
8 *
9 * The free distribution and use of this software in both source and binary
10 * form is allowed (with or without changes) provided that:
11 *
12 * 1. distributions of this source code include the above copyright
13 * notice, this list of conditions and the following disclaimer;
14 *
15 * 2. distributions in binary form include the above copyright
16 * notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other associated materials;
18 *
19 * 3. the copyright holder's name is not used to endorse products
20 * built using this software without specific written permission.
21 *
22 * DISCLAIMER
23 *
24 * This software is provided 'as is' with no explicit or implied warranties
25 * in respect of its properties, including, but not limited to, correctness
26 * and/or fitness for purpose.
27 * ---------------------------------------------------------------------------
28 */
29
30 #include <linux/version.h>
31 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
32 #include <generated/autoconf.h>
33 #else
34 #include <linux/autoconf.h>
35 #endif
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/list.h>
39 #include <linux/slab.h>
40 #include <linux/sched.h>
41 #include <linux/wait.h>
42 #include <linux/crypto.h>
43 #include <linux/mm.h>
44 #include <linux/skbuff.h>
45 #include <linux/random.h>
46 #include <linux/scatterlist.h>
47
48 #include <cryptodev.h>
49 #include <uio.h>
50
51 struct {
52 softc_device_decl sc_dev;
53 } octo_softc;
54
55 #define offset_in_page(p) ((unsigned long)(p) & ~PAGE_MASK)
56
57 struct octo_sess {
58 int octo_encalg;
59 #define MAX_CIPHER_KEYLEN 64
60 char octo_enckey[MAX_CIPHER_KEYLEN];
61 int octo_encklen;
62
63 int octo_macalg;
64 #define MAX_HASH_KEYLEN 64
65 char octo_mackey[MAX_HASH_KEYLEN];
66 int octo_macklen;
67 int octo_mackey_set;
68
69 int octo_mlen;
70 int octo_ivsize;
71
72 #if 0
73 int (*octo_decrypt)(struct scatterlist *sg, int sg_len,
74 uint8_t *key, int key_len, uint8_t * iv,
75 uint64_t *hminner, uint64_t *hmouter);
76
77 int (*octo_encrypt)(struct scatterlist *sg, int sg_len,
78 uint8_t *key, int key_len, uint8_t * iv,
79 uint64_t *hminner, uint64_t *hmouter);
80 #else
81 int (*octo_encrypt)(struct octo_sess *od,
82 struct scatterlist *sg, int sg_len,
83 int auth_off, int auth_len,
84 int crypt_off, int crypt_len,
85 int icv_off, uint8_t *ivp);
86 int (*octo_decrypt)(struct octo_sess *od,
87 struct scatterlist *sg, int sg_len,
88 int auth_off, int auth_len,
89 int crypt_off, int crypt_len,
90 int icv_off, uint8_t *ivp);
91 #endif
92
93 uint64_t octo_hminner[3];
94 uint64_t octo_hmouter[3];
95 };
96
97 int32_t octo_id = -1;
98 module_param(octo_id, int, 0444);
99 MODULE_PARM_DESC(octo_id, "Read-Only OCF ID for cryptocteon driver");
100
101 static struct octo_sess **octo_sessions = NULL;
102 static u_int32_t octo_sesnum = 0;
103
104 static int octo_process(device_t, struct cryptop *, int);
105 static int octo_newsession(device_t, u_int32_t *, struct cryptoini *);
106 static int octo_freesession(device_t, u_int64_t);
107
108 static device_method_t octo_methods = {
109 /* crypto device methods */
110 DEVMETHOD(cryptodev_newsession, octo_newsession),
111 DEVMETHOD(cryptodev_freesession,octo_freesession),
112 DEVMETHOD(cryptodev_process, octo_process),
113 };
114
115 #define debug octo_debug
116 int octo_debug = 0;
117 module_param(octo_debug, int, 0644);
118 MODULE_PARM_DESC(octo_debug, "Enable debug");
119
120
121 #include "cavium_crypto.c"
122
123
124 /*
125 * Generate a new octo session. We artifically limit it to a single
126 * hash/cipher or hash-cipher combo just to make it easier, most callers
127 * do not expect more than this anyway.
128 */
129 static int
130 octo_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri)
131 {
132 struct cryptoini *c, *encini = NULL, *macini = NULL;
133 struct octo_sess **ocd;
134 int i;
135
136 dprintk("%s()\n", __FUNCTION__);
137 if (sid == NULL || cri == NULL) {
138 dprintk("%s,%d - EINVAL\n", __FILE__, __LINE__);
139 return EINVAL;
140 }
141
142 /*
143 * To keep it simple, we only handle hash, cipher or hash/cipher in a
144 * session, you cannot currently do multiple ciphers/hashes in one
145 * session even though it would be possibel to code this driver to
146 * handle it.
147 */
148 for (i = 0, c = cri; c && i < 2; i++) {
149 if (c->cri_alg == CRYPTO_MD5_HMAC ||
150 c->cri_alg == CRYPTO_SHA1_HMAC ||
151 c->cri_alg == CRYPTO_NULL_HMAC) {
152 if (macini) {
153 break;
154 }
155 macini = c;
156 }
157 if (c->cri_alg == CRYPTO_DES_CBC ||
158 c->cri_alg == CRYPTO_3DES_CBC ||
159 c->cri_alg == CRYPTO_AES_CBC ||
160 c->cri_alg == CRYPTO_NULL_CBC) {
161 if (encini) {
162 break;
163 }
164 encini = c;
165 }
166 c = c->cri_next;
167 }
168 if (!macini && !encini) {
169 dprintk("%s,%d - EINVAL bad cipher/hash or combination\n",
170 __FILE__, __LINE__);
171 return EINVAL;
172 }
173 if (c) {
174 dprintk("%s,%d - EINVAL cannot handle chained cipher/hash combos\n",
175 __FILE__, __LINE__);
176 return EINVAL;
177 }
178
179 /*
180 * So we have something we can do, lets setup the session
181 */
182
183 if (octo_sessions) {
184 for (i = 1; i < octo_sesnum; i++)
185 if (octo_sessions[i] == NULL)
186 break;
187 } else
188 i = 1; /* NB: to silence compiler warning */
189
190 if (octo_sessions == NULL || i == octo_sesnum) {
191 if (octo_sessions == NULL) {
192 i = 1; /* We leave octo_sessions[0] empty */
193 octo_sesnum = CRYPTO_SW_SESSIONS;
194 } else
195 octo_sesnum *= 2;
196
197 ocd = kmalloc(octo_sesnum * sizeof(struct octo_sess *), SLAB_ATOMIC);
198 if (ocd == NULL) {
199 /* Reset session number */
200 if (octo_sesnum == CRYPTO_SW_SESSIONS)
201 octo_sesnum = 0;
202 else
203 octo_sesnum /= 2;
204 dprintk("%s,%d: ENOBUFS\n", __FILE__, __LINE__);
205 return ENOBUFS;
206 }
207 memset(ocd, 0, octo_sesnum * sizeof(struct octo_sess *));
208
209 /* Copy existing sessions */
210 if (octo_sessions) {
211 memcpy(ocd, octo_sessions,
212 (octo_sesnum / 2) * sizeof(struct octo_sess *));
213 kfree(octo_sessions);
214 }
215
216 octo_sessions = ocd;
217 }
218
219 ocd = &octo_sessions[i];
220 *sid = i;
221
222
223 *ocd = (struct octo_sess *) kmalloc(sizeof(struct octo_sess), SLAB_ATOMIC);
224 if (*ocd == NULL) {
225 octo_freesession(NULL, i);
226 dprintk("%s,%d: ENOBUFS\n", __FILE__, __LINE__);
227 return ENOBUFS;
228 }
229 memset(*ocd, 0, sizeof(struct octo_sess));
230
231 if (encini && encini->cri_key) {
232 (*ocd)->octo_encklen = (encini->cri_klen + 7) / 8;
233 memcpy((*ocd)->octo_enckey, encini->cri_key, (*ocd)->octo_encklen);
234 }
235
236 if (macini && macini->cri_key) {
237 (*ocd)->octo_macklen = (macini->cri_klen + 7) / 8;
238 memcpy((*ocd)->octo_mackey, macini->cri_key, (*ocd)->octo_macklen);
239 }
240
241 (*ocd)->octo_mlen = 0;
242 if (encini && encini->cri_mlen)
243 (*ocd)->octo_mlen = encini->cri_mlen;
244 else if (macini && macini->cri_mlen)
245 (*ocd)->octo_mlen = macini->cri_mlen;
246 else
247 (*ocd)->octo_mlen = 12;
248
249 /*
250 * point c at the enc if it exists, otherwise the mac
251 */
252 c = encini ? encini : macini;
253
254 switch (c->cri_alg) {
255 case CRYPTO_DES_CBC:
256 case CRYPTO_3DES_CBC:
257 (*ocd)->octo_ivsize = 8;
258 switch (macini ? macini->cri_alg : -1) {
259 case CRYPTO_MD5_HMAC:
260 (*ocd)->octo_encrypt = octo_des_cbc_md5_encrypt;
261 (*ocd)->octo_decrypt = octo_des_cbc_md5_decrypt;
262 octo_calc_hash(0, macini->cri_key, (*ocd)->octo_hminner,
263 (*ocd)->octo_hmouter);
264 break;
265 case CRYPTO_SHA1_HMAC:
266 (*ocd)->octo_encrypt = octo_des_cbc_sha1_encrypt;
267 (*ocd)->octo_decrypt = octo_des_cbc_sha1_encrypt;
268 octo_calc_hash(1, macini->cri_key, (*ocd)->octo_hminner,
269 (*ocd)->octo_hmouter);
270 break;
271 case -1:
272 (*ocd)->octo_encrypt = octo_des_cbc_encrypt;
273 (*ocd)->octo_decrypt = octo_des_cbc_decrypt;
274 break;
275 default:
276 octo_freesession(NULL, i);
277 dprintk("%s,%d: EINVALn", __FILE__, __LINE__);
278 return EINVAL;
279 }
280 break;
281 case CRYPTO_AES_CBC:
282 (*ocd)->octo_ivsize = 16;
283 switch (macini ? macini->cri_alg : -1) {
284 case CRYPTO_MD5_HMAC:
285 (*ocd)->octo_encrypt = octo_aes_cbc_md5_encrypt;
286 (*ocd)->octo_decrypt = octo_aes_cbc_md5_decrypt;
287 octo_calc_hash(0, macini->cri_key, (*ocd)->octo_hminner,
288 (*ocd)->octo_hmouter);
289 break;
290 case CRYPTO_SHA1_HMAC:
291 (*ocd)->octo_encrypt = octo_aes_cbc_sha1_encrypt;
292 (*ocd)->octo_decrypt = octo_aes_cbc_sha1_decrypt;
293 octo_calc_hash(1, macini->cri_key, (*ocd)->octo_hminner,
294 (*ocd)->octo_hmouter);
295 break;
296 case -1:
297 (*ocd)->octo_encrypt = octo_aes_cbc_encrypt;
298 (*ocd)->octo_decrypt = octo_aes_cbc_decrypt;
299 break;
300 default:
301 octo_freesession(NULL, i);
302 dprintk("%s,%d: EINVALn", __FILE__, __LINE__);
303 return EINVAL;
304 }
305 break;
306 case CRYPTO_MD5_HMAC:
307 (*ocd)->octo_encrypt = octo_null_md5_encrypt;
308 (*ocd)->octo_decrypt = octo_null_md5_encrypt;
309 octo_calc_hash(0, macini->cri_key, (*ocd)->octo_hminner,
310 (*ocd)->octo_hmouter);
311 break;
312 case CRYPTO_SHA1_HMAC:
313 (*ocd)->octo_encrypt = octo_null_sha1_encrypt;
314 (*ocd)->octo_decrypt = octo_null_sha1_encrypt;
315 octo_calc_hash(1, macini->cri_key, (*ocd)->octo_hminner,
316 (*ocd)->octo_hmouter);
317 break;
318 default:
319 octo_freesession(NULL, i);
320 dprintk("%s,%d: EINVALn", __FILE__, __LINE__);
321 return EINVAL;
322 }
323
324 (*ocd)->octo_encalg = encini ? encini->cri_alg : -1;
325 (*ocd)->octo_macalg = macini ? macini->cri_alg : -1;
326
327 return 0;
328 }
329
330 /*
331 * Free a session.
332 */
333 static int
334 octo_freesession(device_t dev, u_int64_t tid)
335 {
336 u_int32_t sid = CRYPTO_SESID2LID(tid);
337
338 dprintk("%s()\n", __FUNCTION__);
339 if (sid > octo_sesnum || octo_sessions == NULL ||
340 octo_sessions[sid] == NULL) {
341 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
342 return(EINVAL);
343 }
344
345 /* Silently accept and return */
346 if (sid == 0)
347 return(0);
348
349 if (octo_sessions[sid])
350 kfree(octo_sessions[sid]);
351 octo_sessions[sid] = NULL;
352 return 0;
353 }
354
355 /*
356 * Process a request.
357 */
358 static int
359 octo_process(device_t dev, struct cryptop *crp, int hint)
360 {
361 struct cryptodesc *crd;
362 struct octo_sess *od;
363 u_int32_t lid;
364 #define SCATTERLIST_MAX 16
365 struct scatterlist sg[SCATTERLIST_MAX];
366 int sg_num, sg_len;
367 struct sk_buff *skb = NULL;
368 struct uio *uiop = NULL;
369 struct cryptodesc *enccrd = NULL, *maccrd = NULL;
370 unsigned char *ivp = NULL;
371 unsigned char iv_data[HASH_MAX_LEN];
372 int auth_off = 0, auth_len = 0, crypt_off = 0, crypt_len = 0, icv_off = 0;
373
374 dprintk("%s()\n", __FUNCTION__);
375 /* Sanity check */
376 if (crp == NULL) {
377 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
378 return EINVAL;
379 }
380
381 crp->crp_etype = 0;
382
383 if (crp->crp_desc == NULL || crp->crp_buf == NULL) {
384 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
385 crp->crp_etype = EINVAL;
386 goto done;
387 }
388
389 lid = crp->crp_sid & 0xffffffff;
390 if (lid >= octo_sesnum || lid == 0 || octo_sessions == NULL ||
391 octo_sessions[lid] == NULL) {
392 crp->crp_etype = ENOENT;
393 dprintk("%s,%d: ENOENT\n", __FILE__, __LINE__);
394 goto done;
395 }
396 od = octo_sessions[lid];
397
398 /*
399 * do some error checking outside of the loop for SKB and IOV processing
400 * this leaves us with valid skb or uiop pointers for later
401 */
402 if (crp->crp_flags & CRYPTO_F_SKBUF) {
403 skb = (struct sk_buff *) crp->crp_buf;
404 if (skb_shinfo(skb)->nr_frags >= SCATTERLIST_MAX) {
405 printk("%s,%d: %d nr_frags > SCATTERLIST_MAX", __FILE__, __LINE__,
406 skb_shinfo(skb)->nr_frags);
407 goto done;
408 }
409 } else if (crp->crp_flags & CRYPTO_F_IOV) {
410 uiop = (struct uio *) crp->crp_buf;
411 if (uiop->uio_iovcnt > SCATTERLIST_MAX) {
412 printk("%s,%d: %d uio_iovcnt > SCATTERLIST_MAX", __FILE__, __LINE__,
413 uiop->uio_iovcnt);
414 goto done;
415 }
416 }
417
418 /* point our enccrd and maccrd appropriately */
419 crd = crp->crp_desc;
420 if (crd->crd_alg == od->octo_encalg) enccrd = crd;
421 if (crd->crd_alg == od->octo_macalg) maccrd = crd;
422 crd = crd->crd_next;
423 if (crd) {
424 if (crd->crd_alg == od->octo_encalg) enccrd = crd;
425 if (crd->crd_alg == od->octo_macalg) maccrd = crd;
426 crd = crd->crd_next;
427 }
428 if (crd) {
429 crp->crp_etype = EINVAL;
430 dprintk("%s,%d: ENOENT - descriptors do not match session\n",
431 __FILE__, __LINE__);
432 goto done;
433 }
434
435 if (enccrd) {
436 if (enccrd->crd_flags & CRD_F_IV_EXPLICIT) {
437 ivp = enccrd->crd_iv;
438 } else {
439 ivp = iv_data;
440 crypto_copydata(crp->crp_flags, crp->crp_buf,
441 enccrd->crd_inject, od->octo_ivsize, (caddr_t) ivp);
442 }
443
444 if (maccrd) {
445 auth_off = maccrd->crd_skip;
446 auth_len = maccrd->crd_len;
447 icv_off = maccrd->crd_inject;
448 }
449
450 crypt_off = enccrd->crd_skip;
451 crypt_len = enccrd->crd_len;
452 } else { /* if (maccrd) */
453 auth_off = maccrd->crd_skip;
454 auth_len = maccrd->crd_len;
455 icv_off = maccrd->crd_inject;
456 }
457
458
459 /*
460 * setup the SG list to cover the buffer
461 */
462 memset(sg, 0, sizeof(sg));
463 if (crp->crp_flags & CRYPTO_F_SKBUF) {
464 int i, len;
465
466 sg_num = 0;
467 sg_len = 0;
468
469 len = skb_headlen(skb);
470 sg_set_page(&sg[sg_num], virt_to_page(skb->data), len,
471 offset_in_page(skb->data));
472 sg_len += len;
473 sg_num++;
474
475 for (i = 0; i < skb_shinfo(skb)->nr_frags && sg_num < SCATTERLIST_MAX;
476 i++) {
477 len = skb_shinfo(skb)->frags[i].size;
478 sg_set_page(&sg[sg_num], skb_shinfo(skb)->frags[i].page,
479 len, skb_shinfo(skb)->frags[i].page_offset);
480 sg_len += len;
481 sg_num++;
482 }
483 } else if (crp->crp_flags & CRYPTO_F_IOV) {
484 int len;
485
486 sg_len = 0;
487 for (sg_num = 0; sg_len < crp->crp_ilen &&
488 sg_num < uiop->uio_iovcnt &&
489 sg_num < SCATTERLIST_MAX; sg_num++) {
490 len = uiop->uio_iov[sg_num].iov_len;
491 sg_set_page(&sg[sg_num],
492 virt_to_page(uiop->uio_iov[sg_num].iov_base), len,
493 offset_in_page(uiop->uio_iov[sg_num].iov_base));
494 sg_len += len;
495 }
496 } else {
497 sg_len = crp->crp_ilen;
498 sg_set_page(&sg[0], virt_to_page(crp->crp_buf), sg_len,
499 offset_in_page(crp->crp_buf));
500 sg_num = 1;
501 }
502
503
504 /*
505 * setup a new explicit key
506 */
507 if (enccrd) {
508 if (enccrd->crd_flags & CRD_F_KEY_EXPLICIT) {
509 od->octo_encklen = (enccrd->crd_klen + 7) / 8;
510 memcpy(od->octo_enckey, enccrd->crd_key, od->octo_encklen);
511 }
512 }
513 if (maccrd) {
514 if (maccrd->crd_flags & CRD_F_KEY_EXPLICIT) {
515 od->octo_macklen = (maccrd->crd_klen + 7) / 8;
516 memcpy(od->octo_mackey, maccrd->crd_key, od->octo_macklen);
517 od->octo_mackey_set = 0;
518 }
519 if (!od->octo_mackey_set) {
520 octo_calc_hash(maccrd->crd_alg == CRYPTO_MD5_HMAC ? 0 : 1,
521 maccrd->crd_key, od->octo_hminner, od->octo_hmouter);
522 od->octo_mackey_set = 1;
523 }
524 }
525
526
527 if (!enccrd || (enccrd->crd_flags & CRD_F_ENCRYPT))
528 (*od->octo_encrypt)(od, sg, sg_len,
529 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
530 else
531 (*od->octo_decrypt)(od, sg, sg_len,
532 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
533
534 done:
535 crypto_done(crp);
536 return 0;
537 }
538
539 static int
540 cryptocteon_init(void)
541 {
542 dprintk("%s(%p)\n", __FUNCTION__, cryptocteon_init);
543
544 softc_device_init(&octo_softc, "cryptocteon", 0, octo_methods);
545
546 octo_id = crypto_get_driverid(softc_get_device(&octo_softc),
547 CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SYNC);
548 if (octo_id < 0) {
549 printk("Cryptocteon device cannot initialize!");
550 return -ENODEV;
551 }
552
553 crypto_register(octo_id, CRYPTO_MD5_HMAC, 0,0);
554 crypto_register(octo_id, CRYPTO_SHA1_HMAC, 0,0);
555 //crypto_register(octo_id, CRYPTO_MD5, 0,0);
556 //crypto_register(octo_id, CRYPTO_SHA1, 0,0);
557 crypto_register(octo_id, CRYPTO_DES_CBC, 0,0);
558 crypto_register(octo_id, CRYPTO_3DES_CBC, 0,0);
559 crypto_register(octo_id, CRYPTO_AES_CBC, 0,0);
560
561 return(0);
562 }
563
564 static void
565 cryptocteon_exit(void)
566 {
567 dprintk("%s()\n", __FUNCTION__);
568 crypto_unregister_all(octo_id);
569 octo_id = -1;
570 }
571
572 module_init(cryptocteon_init);
573 module_exit(cryptocteon_exit);
574
575 MODULE_LICENSE("BSD");
576 MODULE_AUTHOR("David McCullough <david_mccullough@mcafee.com>");
577 MODULE_DESCRIPTION("Cryptocteon (OCF module for Cavium OCTEON crypto)");