projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
kernel: move linux/ath9k_platform.h to generic files so that it can be reused from...
[openwrt.git] / target / linux / generic / files / crypto / ocf / cryptocteon / cavium_crypto.c
1 /*
2 * Copyright (c) 2009 David McCullough <david.mccullough@securecomputing.com>
3 *
4 * Copyright (c) 2003-2007 Cavium Networks (support@cavium.com). All rights
5 * reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are met:
9 * 1. Redistributions of source code must retain the above copyright notice,
10 * this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by Cavium Networks
17 * 4. Cavium Networks' name may not be used to endorse or promote products
18 * derived from this software without specific prior written permission.
19 *
20 * This Software, including technical data, may be subject to U.S. export
21 * control laws, including the U.S. Export Administration Act and its
22 * associated regulations, and may be subject to export or import regulations
23 * in other countries. You warrant that You will comply strictly in all
24 * respects with all such regulations and acknowledge that you have the
25 * responsibility to obtain licenses to export, re-export or import the
26 * Software.
27 *
28 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS" AND
29 * WITH ALL FAULTS AND CAVIUM MAKES NO PROMISES, REPRESENTATIONS OR WARRANTIES,
30 * EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO THE
31 * SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY REPRESENTATION OR
32 * DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT DEFECTS, AND CAVIUM
33 * SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES OF TITLE,
34 * MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF
35 * VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR
36 * CORRESPONDENCE TO DESCRIPTION. THE ENTIRE RISK ARISING OUT OF USE OR
37 * PERFORMANCE OF THE SOFTWARE LIES WITH YOU.
38 */
39 /****************************************************************************/
40
41 #include <linux/scatterlist.h>
42 #include <asm/octeon/octeon.h>
43 #include "octeon-asm.h"
44
45 /****************************************************************************/
46
47 extern unsigned long octeon_crypto_enable(struct octeon_cop2_state *);
48 extern void octeon_crypto_disable(struct octeon_cop2_state *, unsigned long);
49
50 #define SG_INIT(s, p, i, l) \
51 { \
52 (i) = 0; \
53 (l) = (s)[0].length; \
54 (p) = (typeof(p)) sg_virt((s)); \
55 CVMX_PREFETCH0((p)); \
56 }
57
58 #define SG_CONSUME(s, p, i, l) \
59 { \
60 (p)++; \
61 (l) -= sizeof(*(p)); \
62 if ((l) < 0) { \
63 dprintk("%s, %d: l = %d\n", __FILE__, __LINE__, l); \
64 } else if ((l) == 0) { \
65 (i)++; \
66 (l) = (s)[0].length; \
67 (p) = (typeof(p)) sg_virt(s); \
68 CVMX_PREFETCH0((p)); \
69 } \
70 }
71
72 #define ESP_HEADER_LENGTH 8
73 #define DES_CBC_IV_LENGTH 8
74 #define AES_CBC_IV_LENGTH 16
75 #define ESP_HMAC_LEN 12
76
77 #define ESP_HEADER_LENGTH 8
78 #define DES_CBC_IV_LENGTH 8
79
80 /****************************************************************************/
81
82 #define CVM_LOAD_SHA_UNIT(dat, next) { \
83 if (next == 0) { \
84 next = 1; \
85 CVMX_MT_HSH_DAT (dat, 0); \
86 } else if (next == 1) { \
87 next = 2; \
88 CVMX_MT_HSH_DAT (dat, 1); \
89 } else if (next == 2) { \
90 next = 3; \
91 CVMX_MT_HSH_DAT (dat, 2); \
92 } else if (next == 3) { \
93 next = 4; \
94 CVMX_MT_HSH_DAT (dat, 3); \
95 } else if (next == 4) { \
96 next = 5; \
97 CVMX_MT_HSH_DAT (dat, 4); \
98 } else if (next == 5) { \
99 next = 6; \
100 CVMX_MT_HSH_DAT (dat, 5); \
101 } else if (next == 6) { \
102 next = 7; \
103 CVMX_MT_HSH_DAT (dat, 6); \
104 } else { \
105 CVMX_MT_HSH_STARTSHA (dat); \
106 next = 0; \
107 } \
108 }
109
110 #define CVM_LOAD2_SHA_UNIT(dat1, dat2, next) { \
111 if (next == 0) { \
112 CVMX_MT_HSH_DAT (dat1, 0); \
113 CVMX_MT_HSH_DAT (dat2, 1); \
114 next = 2; \
115 } else if (next == 1) { \
116 CVMX_MT_HSH_DAT (dat1, 1); \
117 CVMX_MT_HSH_DAT (dat2, 2); \
118 next = 3; \
119 } else if (next == 2) { \
120 CVMX_MT_HSH_DAT (dat1, 2); \
121 CVMX_MT_HSH_DAT (dat2, 3); \
122 next = 4; \
123 } else if (next == 3) { \
124 CVMX_MT_HSH_DAT (dat1, 3); \
125 CVMX_MT_HSH_DAT (dat2, 4); \
126 next = 5; \
127 } else if (next == 4) { \
128 CVMX_MT_HSH_DAT (dat1, 4); \
129 CVMX_MT_HSH_DAT (dat2, 5); \
130 next = 6; \
131 } else if (next == 5) { \
132 CVMX_MT_HSH_DAT (dat1, 5); \
133 CVMX_MT_HSH_DAT (dat2, 6); \
134 next = 7; \
135 } else if (next == 6) { \
136 CVMX_MT_HSH_DAT (dat1, 6); \
137 CVMX_MT_HSH_STARTSHA (dat2); \
138 next = 0; \
139 } else { \
140 CVMX_MT_HSH_STARTSHA (dat1); \
141 CVMX_MT_HSH_DAT (dat2, 0); \
142 next = 1; \
143 } \
144 }
145
146 /****************************************************************************/
147
148 #define CVM_LOAD_MD5_UNIT(dat, next) { \
149 if (next == 0) { \
150 next = 1; \
151 CVMX_MT_HSH_DAT (dat, 0); \
152 } else if (next == 1) { \
153 next = 2; \
154 CVMX_MT_HSH_DAT (dat, 1); \
155 } else if (next == 2) { \
156 next = 3; \
157 CVMX_MT_HSH_DAT (dat, 2); \
158 } else if (next == 3) { \
159 next = 4; \
160 CVMX_MT_HSH_DAT (dat, 3); \
161 } else if (next == 4) { \
162 next = 5; \
163 CVMX_MT_HSH_DAT (dat, 4); \
164 } else if (next == 5) { \
165 next = 6; \
166 CVMX_MT_HSH_DAT (dat, 5); \
167 } else if (next == 6) { \
168 next = 7; \
169 CVMX_MT_HSH_DAT (dat, 6); \
170 } else { \
171 CVMX_MT_HSH_STARTMD5 (dat); \
172 next = 0; \
173 } \
174 }
175
176 #define CVM_LOAD2_MD5_UNIT(dat1, dat2, next) { \
177 if (next == 0) { \
178 CVMX_MT_HSH_DAT (dat1, 0); \
179 CVMX_MT_HSH_DAT (dat2, 1); \
180 next = 2; \
181 } else if (next == 1) { \
182 CVMX_MT_HSH_DAT (dat1, 1); \
183 CVMX_MT_HSH_DAT (dat2, 2); \
184 next = 3; \
185 } else if (next == 2) { \
186 CVMX_MT_HSH_DAT (dat1, 2); \
187 CVMX_MT_HSH_DAT (dat2, 3); \
188 next = 4; \
189 } else if (next == 3) { \
190 CVMX_MT_HSH_DAT (dat1, 3); \
191 CVMX_MT_HSH_DAT (dat2, 4); \
192 next = 5; \
193 } else if (next == 4) { \
194 CVMX_MT_HSH_DAT (dat1, 4); \
195 CVMX_MT_HSH_DAT (dat2, 5); \
196 next = 6; \
197 } else if (next == 5) { \
198 CVMX_MT_HSH_DAT (dat1, 5); \
199 CVMX_MT_HSH_DAT (dat2, 6); \
200 next = 7; \
201 } else if (next == 6) { \
202 CVMX_MT_HSH_DAT (dat1, 6); \
203 CVMX_MT_HSH_STARTMD5 (dat2); \
204 next = 0; \
205 } else { \
206 CVMX_MT_HSH_STARTMD5 (dat1); \
207 CVMX_MT_HSH_DAT (dat2, 0); \
208 next = 1; \
209 } \
210 }
211
212 /****************************************************************************/
213
214 static inline uint64_t
215 swap64(uint64_t a)
216 {
217 return ((a >> 56) |
218 (((a >> 48) & 0xfful) << 8) |
219 (((a >> 40) & 0xfful) << 16) |
220 (((a >> 32) & 0xfful) << 24) |
221 (((a >> 24) & 0xfful) << 32) |
222 (((a >> 16) & 0xfful) << 40) |
223 (((a >> 8) & 0xfful) << 48) | (((a >> 0) & 0xfful) << 56));
224 }
225
226 /****************************************************************************/
227
228 void
229 octo_calc_hash(__u8 auth, unsigned char *key, uint64_t *inner, uint64_t *outer)
230 {
231 uint8_t hash_key[64];
232 uint64_t *key1;
233 register uint64_t xor1 = 0x3636363636363636ULL;
234 register uint64_t xor2 = 0x5c5c5c5c5c5c5c5cULL;
235 struct octeon_cop2_state state;
236 unsigned long flags;
237
238 dprintk("%s()\n", __FUNCTION__);
239
240 memset(hash_key, 0, sizeof(hash_key));
241 memcpy(hash_key, (uint8_t *) key, (auth ? 20 : 16));
242 key1 = (uint64_t *) hash_key;
243 flags = octeon_crypto_enable(&state);
244 if (auth) {
245 CVMX_MT_HSH_IV(0x67452301EFCDAB89ULL, 0);
246 CVMX_MT_HSH_IV(0x98BADCFE10325476ULL, 1);
247 CVMX_MT_HSH_IV(0xC3D2E1F000000000ULL, 2);
248 } else {
249 CVMX_MT_HSH_IV(0x0123456789ABCDEFULL, 0);
250 CVMX_MT_HSH_IV(0xFEDCBA9876543210ULL, 1);
251 }
252
253 CVMX_MT_HSH_DAT((*key1 ^ xor1), 0);
254 key1++;
255 CVMX_MT_HSH_DAT((*key1 ^ xor1), 1);
256 key1++;
257 CVMX_MT_HSH_DAT((*key1 ^ xor1), 2);
258 key1++;
259 CVMX_MT_HSH_DAT((*key1 ^ xor1), 3);
260 key1++;
261 CVMX_MT_HSH_DAT((*key1 ^ xor1), 4);
262 key1++;
263 CVMX_MT_HSH_DAT((*key1 ^ xor1), 5);
264 key1++;
265 CVMX_MT_HSH_DAT((*key1 ^ xor1), 6);
266 key1++;
267 if (auth)
268 CVMX_MT_HSH_STARTSHA((*key1 ^ xor1));
269 else
270 CVMX_MT_HSH_STARTMD5((*key1 ^ xor1));
271
272 CVMX_MF_HSH_IV(inner[0], 0);
273 CVMX_MF_HSH_IV(inner[1], 1);
274 if (auth) {
275 inner[2] = 0;
276 CVMX_MF_HSH_IV(((uint64_t *) inner)[2], 2);
277 }
278
279 memset(hash_key, 0, sizeof(hash_key));
280 memcpy(hash_key, (uint8_t *) key, (auth ? 20 : 16));
281 key1 = (uint64_t *) hash_key;
282 if (auth) {
283 CVMX_MT_HSH_IV(0x67452301EFCDAB89ULL, 0);
284 CVMX_MT_HSH_IV(0x98BADCFE10325476ULL, 1);
285 CVMX_MT_HSH_IV(0xC3D2E1F000000000ULL, 2);
286 } else {
287 CVMX_MT_HSH_IV(0x0123456789ABCDEFULL, 0);
288 CVMX_MT_HSH_IV(0xFEDCBA9876543210ULL, 1);
289 }
290
291 CVMX_MT_HSH_DAT((*key1 ^ xor2), 0);
292 key1++;
293 CVMX_MT_HSH_DAT((*key1 ^ xor2), 1);
294 key1++;
295 CVMX_MT_HSH_DAT((*key1 ^ xor2), 2);
296 key1++;
297 CVMX_MT_HSH_DAT((*key1 ^ xor2), 3);
298 key1++;
299 CVMX_MT_HSH_DAT((*key1 ^ xor2), 4);
300 key1++;
301 CVMX_MT_HSH_DAT((*key1 ^ xor2), 5);
302 key1++;
303 CVMX_MT_HSH_DAT((*key1 ^ xor2), 6);
304 key1++;
305 if (auth)
306 CVMX_MT_HSH_STARTSHA((*key1 ^ xor2));
307 else
308 CVMX_MT_HSH_STARTMD5((*key1 ^ xor2));
309
310 CVMX_MF_HSH_IV(outer[0], 0);
311 CVMX_MF_HSH_IV(outer[1], 1);
312 if (auth) {
313 outer[2] = 0;
314 CVMX_MF_HSH_IV(outer[2], 2);
315 }
316 octeon_crypto_disable(&state, flags);
317 return;
318 }
319
320 /****************************************************************************/
321 /* DES functions */
322
323 int
324 octo_des_cbc_encrypt(
325 struct octo_sess *od,
326 struct scatterlist *sg, int sg_len,
327 int auth_off, int auth_len,
328 int crypt_off, int crypt_len,
329 int icv_off, uint8_t *ivp)
330 {
331 uint64_t *data;
332 int data_i, data_l;
333 struct octeon_cop2_state state;
334 unsigned long flags;
335
336 dprintk("%s()\n", __FUNCTION__);
337
338 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
339 (crypt_off & 0x7) || (crypt_off + crypt_len > sg_len))) {
340 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
341 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
342 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
343 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
344 return -EINVAL;
345 }
346
347 SG_INIT(sg, data, data_i, data_l);
348
349 CVMX_PREFETCH0(ivp);
350 CVMX_PREFETCH0(od->octo_enckey);
351
352 flags = octeon_crypto_enable(&state);
353
354 /* load 3DES Key */
355 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
356 if (od->octo_encklen == 24) {
357 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
358 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
359 } else if (od->octo_encklen == 8) {
360 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 1);
361 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 2);
362 } else {
363 octeon_crypto_disable(&state, flags);
364 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
365 return -EINVAL;
366 }
367
368 CVMX_MT_3DES_IV(* (uint64_t *) ivp);
369
370 while (crypt_off > 0) {
371 SG_CONSUME(sg, data, data_i, data_l);
372 crypt_off -= 8;
373 }
374
375 while (crypt_len > 0) {
376 CVMX_MT_3DES_ENC_CBC(*data);
377 CVMX_MF_3DES_RESULT(*data);
378 SG_CONSUME(sg, data, data_i, data_l);
379 crypt_len -= 8;
380 }
381
382 octeon_crypto_disable(&state, flags);
383 return 0;
384 }
385
386
387 int
388 octo_des_cbc_decrypt(
389 struct octo_sess *od,
390 struct scatterlist *sg, int sg_len,
391 int auth_off, int auth_len,
392 int crypt_off, int crypt_len,
393 int icv_off, uint8_t *ivp)
394 {
395 uint64_t *data;
396 int data_i, data_l;
397 struct octeon_cop2_state state;
398 unsigned long flags;
399
400 dprintk("%s()\n", __FUNCTION__);
401
402 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
403 (crypt_off & 0x7) || (crypt_off + crypt_len > sg_len))) {
404 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
405 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
406 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
407 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
408 return -EINVAL;
409 }
410
411 SG_INIT(sg, data, data_i, data_l);
412
413 CVMX_PREFETCH0(ivp);
414 CVMX_PREFETCH0(od->octo_enckey);
415
416 flags = octeon_crypto_enable(&state);
417
418 /* load 3DES Key */
419 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
420 if (od->octo_encklen == 24) {
421 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
422 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
423 } else if (od->octo_encklen == 8) {
424 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 1);
425 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 2);
426 } else {
427 octeon_crypto_disable(&state, flags);
428 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
429 return -EINVAL;
430 }
431
432 CVMX_MT_3DES_IV(* (uint64_t *) ivp);
433
434 while (crypt_off > 0) {
435 SG_CONSUME(sg, data, data_i, data_l);
436 crypt_off -= 8;
437 }
438
439 while (crypt_len > 0) {
440 CVMX_MT_3DES_DEC_CBC(*data);
441 CVMX_MF_3DES_RESULT(*data);
442 SG_CONSUME(sg, data, data_i, data_l);
443 crypt_len -= 8;
444 }
445
446 octeon_crypto_disable(&state, flags);
447 return 0;
448 }
449
450 /****************************************************************************/
451 /* AES functions */
452
453 int
454 octo_aes_cbc_encrypt(
455 struct octo_sess *od,
456 struct scatterlist *sg, int sg_len,
457 int auth_off, int auth_len,
458 int crypt_off, int crypt_len,
459 int icv_off, uint8_t *ivp)
460 {
461 uint64_t *data, *pdata;
462 int data_i, data_l;
463 struct octeon_cop2_state state;
464 unsigned long flags;
465
466 dprintk("%s()\n", __FUNCTION__);
467
468 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
469 (crypt_off & 0x7) || (crypt_off + crypt_len > sg_len))) {
470 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
471 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
472 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
473 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
474 return -EINVAL;
475 }
476
477 SG_INIT(sg, data, data_i, data_l);
478
479 CVMX_PREFETCH0(ivp);
480 CVMX_PREFETCH0(od->octo_enckey);
481
482 flags = octeon_crypto_enable(&state);
483
484 /* load AES Key */
485 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
486 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
487
488 if (od->octo_encklen == 16) {
489 CVMX_MT_AES_KEY(0x0, 2);
490 CVMX_MT_AES_KEY(0x0, 3);
491 } else if (od->octo_encklen == 24) {
492 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
493 CVMX_MT_AES_KEY(0x0, 3);
494 } else if (od->octo_encklen == 32) {
495 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
496 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[3], 3);
497 } else {
498 octeon_crypto_disable(&state, flags);
499 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
500 return -EINVAL;
501 }
502 CVMX_MT_AES_KEYLENGTH(od->octo_encklen / 8 - 1);
503
504 CVMX_MT_AES_IV(((uint64_t *) ivp)[0], 0);
505 CVMX_MT_AES_IV(((uint64_t *) ivp)[1], 1);
506
507 while (crypt_off > 0) {
508 SG_CONSUME(sg, data, data_i, data_l);
509 crypt_off -= 8;
510 }
511
512 while (crypt_len > 0) {
513 pdata = data;
514 CVMX_MT_AES_ENC_CBC0(*data);
515 SG_CONSUME(sg, data, data_i, data_l);
516 CVMX_MT_AES_ENC_CBC1(*data);
517 CVMX_MF_AES_RESULT(*pdata, 0);
518 CVMX_MF_AES_RESULT(*data, 1);
519 SG_CONSUME(sg, data, data_i, data_l);
520 crypt_len -= 16;
521 }
522
523 octeon_crypto_disable(&state, flags);
524 return 0;
525 }
526
527
528 int
529 octo_aes_cbc_decrypt(
530 struct octo_sess *od,
531 struct scatterlist *sg, int sg_len,
532 int auth_off, int auth_len,
533 int crypt_off, int crypt_len,
534 int icv_off, uint8_t *ivp)
535 {
536 uint64_t *data, *pdata;
537 int data_i, data_l;
538 struct octeon_cop2_state state;
539 unsigned long flags;
540
541 dprintk("%s()\n", __FUNCTION__);
542
543 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
544 (crypt_off & 0x7) || (crypt_off + crypt_len > sg_len))) {
545 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
546 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
547 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
548 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
549 return -EINVAL;
550 }
551
552 SG_INIT(sg, data, data_i, data_l);
553
554 CVMX_PREFETCH0(ivp);
555 CVMX_PREFETCH0(od->octo_enckey);
556
557 flags = octeon_crypto_enable(&state);
558
559 /* load AES Key */
560 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
561 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
562
563 if (od->octo_encklen == 16) {
564 CVMX_MT_AES_KEY(0x0, 2);
565 CVMX_MT_AES_KEY(0x0, 3);
566 } else if (od->octo_encklen == 24) {
567 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
568 CVMX_MT_AES_KEY(0x0, 3);
569 } else if (od->octo_encklen == 32) {
570 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
571 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[3], 3);
572 } else {
573 octeon_crypto_disable(&state, flags);
574 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
575 return -EINVAL;
576 }
577 CVMX_MT_AES_KEYLENGTH(od->octo_encklen / 8 - 1);
578
579 CVMX_MT_AES_IV(((uint64_t *) ivp)[0], 0);
580 CVMX_MT_AES_IV(((uint64_t *) ivp)[1], 1);
581
582 while (crypt_off > 0) {
583 SG_CONSUME(sg, data, data_i, data_l);
584 crypt_off -= 8;
585 }
586
587 while (crypt_len > 0) {
588 pdata = data;
589 CVMX_MT_AES_DEC_CBC0(*data);
590 SG_CONSUME(sg, data, data_i, data_l);
591 CVMX_MT_AES_DEC_CBC1(*data);
592 CVMX_MF_AES_RESULT(*pdata, 0);
593 CVMX_MF_AES_RESULT(*data, 1);
594 SG_CONSUME(sg, data, data_i, data_l);
595 crypt_len -= 16;
596 }
597
598 octeon_crypto_disable(&state, flags);
599 return 0;
600 }
601
602 /****************************************************************************/
603 /* MD5 */
604
605 int
606 octo_null_md5_encrypt(
607 struct octo_sess *od,
608 struct scatterlist *sg, int sg_len,
609 int auth_off, int auth_len,
610 int crypt_off, int crypt_len,
611 int icv_off, uint8_t *ivp)
612 {
613 register int next = 0;
614 uint64_t *data;
615 uint64_t tmp1, tmp2;
616 int data_i, data_l, alen = auth_len;
617 struct octeon_cop2_state state;
618 unsigned long flags;
619
620 dprintk("%s()\n", __FUNCTION__);
621
622 if (unlikely(od == NULL || sg==NULL || sg_len==0 ||
623 (auth_off & 0x7) || (auth_off + auth_len > sg_len))) {
624 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
625 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
626 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
627 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
628 return -EINVAL;
629 }
630
631 SG_INIT(sg, data, data_i, data_l);
632
633 flags = octeon_crypto_enable(&state);
634
635 /* Load MD5 IV */
636 CVMX_MT_HSH_IV(od->octo_hminner[0], 0);
637 CVMX_MT_HSH_IV(od->octo_hminner[1], 1);
638
639 while (auth_off > 0) {
640 SG_CONSUME(sg, data, data_i, data_l);
641 auth_off -= 8;
642 }
643
644 while (auth_len > 0) {
645 CVM_LOAD_MD5_UNIT(*data, next);
646 auth_len -= 8;
647 SG_CONSUME(sg, data, data_i, data_l);
648 }
649
650 /* finish the hash */
651 CVMX_PREFETCH0(od->octo_hmouter);
652 #if 0
653 if (unlikely(inplen)) {
654 uint64_t tmp = 0;
655 uint8_t *p = (uint8_t *) & tmp;
656 p[inplen] = 0x80;
657 do {
658 inplen--;
659 p[inplen] = ((uint8_t *) data)[inplen];
660 } while (inplen);
661 CVM_LOAD_MD5_UNIT(tmp, next);
662 } else {
663 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
664 }
665 #else
666 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
667 #endif
668
669 /* Finish Inner hash */
670 while (next != 7) {
671 CVM_LOAD_MD5_UNIT(((uint64_t) 0x0ULL), next);
672 }
673 CVMX_ES64(tmp1, ((alen + 64) << 3));
674 CVM_LOAD_MD5_UNIT(tmp1, next);
675
676 /* Get the inner hash of HMAC */
677 CVMX_MF_HSH_IV(tmp1, 0);
678 CVMX_MF_HSH_IV(tmp2, 1);
679
680 /* Initialize hash unit */
681 CVMX_MT_HSH_IV(od->octo_hmouter[0], 0);
682 CVMX_MT_HSH_IV(od->octo_hmouter[1], 1);
683
684 CVMX_MT_HSH_DAT(tmp1, 0);
685 CVMX_MT_HSH_DAT(tmp2, 1);
686 CVMX_MT_HSH_DAT(0x8000000000000000ULL, 2);
687 CVMX_MT_HSH_DATZ(3);
688 CVMX_MT_HSH_DATZ(4);
689 CVMX_MT_HSH_DATZ(5);
690 CVMX_MT_HSH_DATZ(6);
691 CVMX_ES64(tmp1, ((64 + 16) << 3));
692 CVMX_MT_HSH_STARTMD5(tmp1);
693
694 /* save the HMAC */
695 SG_INIT(sg, data, data_i, data_l);
696 while (icv_off > 0) {
697 SG_CONSUME(sg, data, data_i, data_l);
698 icv_off -= 8;
699 }
700 CVMX_MF_HSH_IV(*data, 0);
701 SG_CONSUME(sg, data, data_i, data_l);
702 CVMX_MF_HSH_IV(tmp1, 1);
703 *(uint32_t *)data = (uint32_t) (tmp1 >> 32);
704
705 octeon_crypto_disable(&state, flags);
706 return 0;
707 }
708
709 /****************************************************************************/
710 /* SHA1 */
711
712 int
713 octo_null_sha1_encrypt(
714 struct octo_sess *od,
715 struct scatterlist *sg, int sg_len,
716 int auth_off, int auth_len,
717 int crypt_off, int crypt_len,
718 int icv_off, uint8_t *ivp)
719 {
720 register int next = 0;
721 uint64_t *data;
722 uint64_t tmp1, tmp2, tmp3;
723 int data_i, data_l, alen = auth_len;
724 struct octeon_cop2_state state;
725 unsigned long flags;
726
727 dprintk("%s()\n", __FUNCTION__);
728
729 if (unlikely(od == NULL || sg==NULL || sg_len==0 ||
730 (auth_off & 0x7) || (auth_off + auth_len > sg_len))) {
731 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
732 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
733 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
734 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
735 return -EINVAL;
736 }
737
738 SG_INIT(sg, data, data_i, data_l);
739
740 flags = octeon_crypto_enable(&state);
741
742 /* Load SHA1 IV */
743 CVMX_MT_HSH_IV(od->octo_hminner[0], 0);
744 CVMX_MT_HSH_IV(od->octo_hminner[1], 1);
745 CVMX_MT_HSH_IV(od->octo_hminner[2], 2);
746
747 while (auth_off > 0) {
748 SG_CONSUME(sg, data, data_i, data_l);
749 auth_off -= 8;
750 }
751
752 while (auth_len > 0) {
753 CVM_LOAD_SHA_UNIT(*data, next);
754 auth_len -= 8;
755 SG_CONSUME(sg, data, data_i, data_l);
756 }
757
758 /* finish the hash */
759 CVMX_PREFETCH0(od->octo_hmouter);
760 #if 0
761 if (unlikely(inplen)) {
762 uint64_t tmp = 0;
763 uint8_t *p = (uint8_t *) & tmp;
764 p[inplen] = 0x80;
765 do {
766 inplen--;
767 p[inplen] = ((uint8_t *) data)[inplen];
768 } while (inplen);
769 CVM_LOAD_MD5_UNIT(tmp, next);
770 } else {
771 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
772 }
773 #else
774 CVM_LOAD_SHA_UNIT(0x8000000000000000ULL, next);
775 #endif
776
777 /* Finish Inner hash */
778 while (next != 7) {
779 CVM_LOAD_SHA_UNIT(((uint64_t) 0x0ULL), next);
780 }
781 CVM_LOAD_SHA_UNIT((uint64_t) ((alen + 64) << 3), next);
782
783 /* Get the inner hash of HMAC */
784 CVMX_MF_HSH_IV(tmp1, 0);
785 CVMX_MF_HSH_IV(tmp2, 1);
786 tmp3 = 0;
787 CVMX_MF_HSH_IV(tmp3, 2);
788
789 /* Initialize hash unit */
790 CVMX_MT_HSH_IV(od->octo_hmouter[0], 0);
791 CVMX_MT_HSH_IV(od->octo_hmouter[1], 1);
792 CVMX_MT_HSH_IV(od->octo_hmouter[2], 2);
793
794 CVMX_MT_HSH_DAT(tmp1, 0);
795 CVMX_MT_HSH_DAT(tmp2, 1);
796 tmp3 |= 0x0000000080000000;
797 CVMX_MT_HSH_DAT(tmp3, 2);
798 CVMX_MT_HSH_DATZ(3);
799 CVMX_MT_HSH_DATZ(4);
800 CVMX_MT_HSH_DATZ(5);
801 CVMX_MT_HSH_DATZ(6);
802 CVMX_MT_HSH_STARTSHA((uint64_t) ((64 + 20) << 3));
803
804 /* save the HMAC */
805 SG_INIT(sg, data, data_i, data_l);
806 while (icv_off > 0) {
807 SG_CONSUME(sg, data, data_i, data_l);
808 icv_off -= 8;
809 }
810 CVMX_MF_HSH_IV(*data, 0);
811 SG_CONSUME(sg, data, data_i, data_l);
812 CVMX_MF_HSH_IV(tmp1, 1);
813 *(uint32_t *)data = (uint32_t) (tmp1 >> 32);
814
815 octeon_crypto_disable(&state, flags);
816 return 0;
817 }
818
819 /****************************************************************************/
820 /* DES MD5 */
821
822 int
823 octo_des_cbc_md5_encrypt(
824 struct octo_sess *od,
825 struct scatterlist *sg, int sg_len,
826 int auth_off, int auth_len,
827 int crypt_off, int crypt_len,
828 int icv_off, uint8_t *ivp)
829 {
830 register int next = 0;
831 union {
832 uint32_t data32[2];
833 uint64_t data64[1];
834 } mydata;
835 uint64_t *data = &mydata.data64[0];
836 uint32_t *data32;
837 uint64_t tmp1, tmp2;
838 int data_i, data_l, alen = auth_len;
839 struct octeon_cop2_state state;
840 unsigned long flags;
841
842 dprintk("%s()\n", __FUNCTION__);
843
844 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
845 (crypt_off & 0x3) || (crypt_off + crypt_len > sg_len) ||
846 (crypt_len & 0x7) ||
847 (auth_len & 0x7) ||
848 (auth_off & 0x3) || (auth_off + auth_len > sg_len))) {
849 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
850 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
851 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
852 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
853 return -EINVAL;
854 }
855
856 SG_INIT(sg, data32, data_i, data_l);
857
858 CVMX_PREFETCH0(ivp);
859 CVMX_PREFETCH0(od->octo_enckey);
860
861 flags = octeon_crypto_enable(&state);
862
863 /* load 3DES Key */
864 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
865 if (od->octo_encklen == 24) {
866 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
867 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
868 } else if (od->octo_encklen == 8) {
869 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 1);
870 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 2);
871 } else {
872 octeon_crypto_disable(&state, flags);
873 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
874 return -EINVAL;
875 }
876
877 CVMX_MT_3DES_IV(* (uint64_t *) ivp);
878
879 /* Load MD5 IV */
880 CVMX_MT_HSH_IV(od->octo_hminner[0], 0);
881 CVMX_MT_HSH_IV(od->octo_hminner[1], 1);
882
883 while (crypt_off > 0 && auth_off > 0) {
884 SG_CONSUME(sg, data32, data_i, data_l);
885 crypt_off -= 4;
886 auth_off -= 4;
887 }
888
889 while (crypt_len > 0 || auth_len > 0) {
890 uint32_t *first = data32;
891 mydata.data32[0] = *first;
892 SG_CONSUME(sg, data32, data_i, data_l);
893 mydata.data32[1] = *data32;
894 if (crypt_off <= 0) {
895 if (crypt_len > 0) {
896 CVMX_MT_3DES_ENC_CBC(*data);
897 CVMX_MF_3DES_RESULT(*data);
898 crypt_len -= 8;
899 }
900 } else
901 crypt_off -= 8;
902 if (auth_off <= 0) {
903 if (auth_len > 0) {
904 CVM_LOAD_MD5_UNIT(*data, next);
905 auth_len -= 8;
906 }
907 } else
908 auth_off -= 8;
909 *first = mydata.data32[0];
910 *data32 = mydata.data32[1];
911 SG_CONSUME(sg, data32, data_i, data_l);
912 }
913
914 /* finish the hash */
915 CVMX_PREFETCH0(od->octo_hmouter);
916 #if 0
917 if (unlikely(inplen)) {
918 uint64_t tmp = 0;
919 uint8_t *p = (uint8_t *) & tmp;
920 p[inplen] = 0x80;
921 do {
922 inplen--;
923 p[inplen] = ((uint8_t *) data)[inplen];
924 } while (inplen);
925 CVM_LOAD_MD5_UNIT(tmp, next);
926 } else {
927 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
928 }
929 #else
930 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
931 #endif
932
933 /* Finish Inner hash */
934 while (next != 7) {
935 CVM_LOAD_MD5_UNIT(((uint64_t) 0x0ULL), next);
936 }
937 CVMX_ES64(tmp1, ((alen + 64) << 3));
938 CVM_LOAD_MD5_UNIT(tmp1, next);
939
940 /* Get the inner hash of HMAC */
941 CVMX_MF_HSH_IV(tmp1, 0);
942 CVMX_MF_HSH_IV(tmp2, 1);
943
944 /* Initialize hash unit */
945 CVMX_MT_HSH_IV(od->octo_hmouter[0], 0);
946 CVMX_MT_HSH_IV(od->octo_hmouter[1], 1);
947
948 CVMX_MT_HSH_DAT(tmp1, 0);
949 CVMX_MT_HSH_DAT(tmp2, 1);
950 CVMX_MT_HSH_DAT(0x8000000000000000ULL, 2);
951 CVMX_MT_HSH_DATZ(3);
952 CVMX_MT_HSH_DATZ(4);
953 CVMX_MT_HSH_DATZ(5);
954 CVMX_MT_HSH_DATZ(6);
955 CVMX_ES64(tmp1, ((64 + 16) << 3));
956 CVMX_MT_HSH_STARTMD5(tmp1);
957
958 /* save the HMAC */
959 SG_INIT(sg, data32, data_i, data_l);
960 while (icv_off > 0) {
961 SG_CONSUME(sg, data32, data_i, data_l);
962 icv_off -= 4;
963 }
964 CVMX_MF_HSH_IV(tmp1, 0);
965 *data32 = (uint32_t) (tmp1 >> 32);
966 SG_CONSUME(sg, data32, data_i, data_l);
967 *data32 = (uint32_t) tmp1;
968 SG_CONSUME(sg, data32, data_i, data_l);
969 CVMX_MF_HSH_IV(tmp1, 1);
970 *data32 = (uint32_t) (tmp1 >> 32);
971
972 octeon_crypto_disable(&state, flags);
973 return 0;
974 }
975
976 int
977 octo_des_cbc_md5_decrypt(
978 struct octo_sess *od,
979 struct scatterlist *sg, int sg_len,
980 int auth_off, int auth_len,
981 int crypt_off, int crypt_len,
982 int icv_off, uint8_t *ivp)
983 {
984 register int next = 0;
985 union {
986 uint32_t data32[2];
987 uint64_t data64[1];
988 } mydata;
989 uint64_t *data = &mydata.data64[0];
990 uint32_t *data32;
991 uint64_t tmp1, tmp2;
992 int data_i, data_l, alen = auth_len;
993 struct octeon_cop2_state state;
994 unsigned long flags;
995
996 dprintk("%s()\n", __FUNCTION__);
997
998 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
999 (crypt_off & 0x3) || (crypt_off + crypt_len > sg_len) ||
1000 (crypt_len & 0x7) ||
1001 (auth_len & 0x7) ||
1002 (auth_off & 0x3) || (auth_off + auth_len > sg_len))) {
1003 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
1004 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
1005 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
1006 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
1007 return -EINVAL;
1008 }
1009
1010 SG_INIT(sg, data32, data_i, data_l);
1011
1012 CVMX_PREFETCH0(ivp);
1013 CVMX_PREFETCH0(od->octo_enckey);
1014
1015 flags = octeon_crypto_enable(&state);
1016
1017 /* load 3DES Key */
1018 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
1019 if (od->octo_encklen == 24) {
1020 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
1021 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
1022 } else if (od->octo_encklen == 8) {
1023 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 1);
1024 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 2);
1025 } else {
1026 octeon_crypto_disable(&state, flags);
1027 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
1028 return -EINVAL;
1029 }
1030
1031 CVMX_MT_3DES_IV(* (uint64_t *) ivp);
1032
1033 /* Load MD5 IV */
1034 CVMX_MT_HSH_IV(od->octo_hminner[0], 0);
1035 CVMX_MT_HSH_IV(od->octo_hminner[1], 1);
1036
1037 while (crypt_off > 0 && auth_off > 0) {
1038 SG_CONSUME(sg, data32, data_i, data_l);
1039 crypt_off -= 4;
1040 auth_off -= 4;
1041 }
1042
1043 while (crypt_len > 0 || auth_len > 0) {
1044 uint32_t *first = data32;
1045 mydata.data32[0] = *first;
1046 SG_CONSUME(sg, data32, data_i, data_l);
1047 mydata.data32[1] = *data32;
1048 if (auth_off <= 0) {
1049 if (auth_len > 0) {
1050 CVM_LOAD_MD5_UNIT(*data, next);
1051 auth_len -= 8;
1052 }
1053 } else
1054 auth_off -= 8;
1055 if (crypt_off <= 0) {
1056 if (crypt_len > 0) {
1057 CVMX_MT_3DES_DEC_CBC(*data);
1058 CVMX_MF_3DES_RESULT(*data);
1059 crypt_len -= 8;
1060 }
1061 } else
1062 crypt_off -= 8;
1063 *first = mydata.data32[0];
1064 *data32 = mydata.data32[1];
1065 SG_CONSUME(sg, data32, data_i, data_l);
1066 }
1067
1068 /* finish the hash */
1069 CVMX_PREFETCH0(od->octo_hmouter);
1070 #if 0
1071 if (unlikely(inplen)) {
1072 uint64_t tmp = 0;
1073 uint8_t *p = (uint8_t *) & tmp;
1074 p[inplen] = 0x80;
1075 do {
1076 inplen--;
1077 p[inplen] = ((uint8_t *) data)[inplen];
1078 } while (inplen);
1079 CVM_LOAD_MD5_UNIT(tmp, next);
1080 } else {
1081 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
1082 }
1083 #else
1084 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
1085 #endif
1086
1087 /* Finish Inner hash */
1088 while (next != 7) {
1089 CVM_LOAD_MD5_UNIT(((uint64_t) 0x0ULL), next);
1090 }
1091 CVMX_ES64(tmp1, ((alen + 64) << 3));
1092 CVM_LOAD_MD5_UNIT(tmp1, next);
1093
1094 /* Get the inner hash of HMAC */
1095 CVMX_MF_HSH_IV(tmp1, 0);
1096 CVMX_MF_HSH_IV(tmp2, 1);
1097
1098 /* Initialize hash unit */
1099 CVMX_MT_HSH_IV(od->octo_hmouter[0], 0);
1100 CVMX_MT_HSH_IV(od->octo_hmouter[1], 1);
1101
1102 CVMX_MT_HSH_DAT(tmp1, 0);
1103 CVMX_MT_HSH_DAT(tmp2, 1);
1104 CVMX_MT_HSH_DAT(0x8000000000000000ULL, 2);
1105 CVMX_MT_HSH_DATZ(3);
1106 CVMX_MT_HSH_DATZ(4);
1107 CVMX_MT_HSH_DATZ(5);
1108 CVMX_MT_HSH_DATZ(6);
1109 CVMX_ES64(tmp1, ((64 + 16) << 3));
1110 CVMX_MT_HSH_STARTMD5(tmp1);
1111
1112 /* save the HMAC */
1113 SG_INIT(sg, data32, data_i, data_l);
1114 while (icv_off > 0) {
1115 SG_CONSUME(sg, data32, data_i, data_l);
1116 icv_off -= 4;
1117 }
1118 CVMX_MF_HSH_IV(tmp1, 0);
1119 *data32 = (uint32_t) (tmp1 >> 32);
1120 SG_CONSUME(sg, data32, data_i, data_l);
1121 *data32 = (uint32_t) tmp1;
1122 SG_CONSUME(sg, data32, data_i, data_l);
1123 CVMX_MF_HSH_IV(tmp1, 1);
1124 *data32 = (uint32_t) (tmp1 >> 32);
1125
1126 octeon_crypto_disable(&state, flags);
1127 return 0;
1128 }
1129
1130 /****************************************************************************/
1131 /* DES SHA */
1132
1133 int
1134 octo_des_cbc_sha1_encrypt(
1135 struct octo_sess *od,
1136 struct scatterlist *sg, int sg_len,
1137 int auth_off, int auth_len,
1138 int crypt_off, int crypt_len,
1139 int icv_off, uint8_t *ivp)
1140 {
1141 register int next = 0;
1142 union {
1143 uint32_t data32[2];
1144 uint64_t data64[1];
1145 } mydata;
1146 uint64_t *data = &mydata.data64[0];
1147 uint32_t *data32;
1148 uint64_t tmp1, tmp2, tmp3;
1149 int data_i, data_l, alen = auth_len;
1150 struct octeon_cop2_state state;
1151 unsigned long flags;
1152
1153 dprintk("%s()\n", __FUNCTION__);
1154
1155 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
1156 (crypt_off & 0x3) || (crypt_off + crypt_len > sg_len) ||
1157 (crypt_len & 0x7) ||
1158 (auth_len & 0x7) ||
1159 (auth_off & 0x3) || (auth_off + auth_len > sg_len))) {
1160 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
1161 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
1162 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
1163 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
1164 return -EINVAL;
1165 }
1166
1167 SG_INIT(sg, data32, data_i, data_l);
1168
1169 CVMX_PREFETCH0(ivp);
1170 CVMX_PREFETCH0(od->octo_enckey);
1171
1172 flags = octeon_crypto_enable(&state);
1173
1174 /* load 3DES Key */
1175 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
1176 if (od->octo_encklen == 24) {
1177 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
1178 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
1179 } else if (od->octo_encklen == 8) {
1180 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 1);
1181 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 2);
1182 } else {
1183 octeon_crypto_disable(&state, flags);
1184 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
1185 return -EINVAL;
1186 }
1187
1188 CVMX_MT_3DES_IV(* (uint64_t *) ivp);
1189
1190 /* Load SHA1 IV */
1191 CVMX_MT_HSH_IV(od->octo_hminner[0], 0);
1192 CVMX_MT_HSH_IV(od->octo_hminner[1], 1);
1193 CVMX_MT_HSH_IV(od->octo_hminner[2], 2);
1194
1195 while (crypt_off > 0 && auth_off > 0) {
1196 SG_CONSUME(sg, data32, data_i, data_l);
1197 crypt_off -= 4;
1198 auth_off -= 4;
1199 }
1200
1201 while (crypt_len > 0 || auth_len > 0) {
1202 uint32_t *first = data32;
1203 mydata.data32[0] = *first;
1204 SG_CONSUME(sg, data32, data_i, data_l);
1205 mydata.data32[1] = *data32;
1206 if (crypt_off <= 0) {
1207 if (crypt_len > 0) {
1208 CVMX_MT_3DES_ENC_CBC(*data);
1209 CVMX_MF_3DES_RESULT(*data);
1210 crypt_len -= 8;
1211 }
1212 } else
1213 crypt_off -= 8;
1214 if (auth_off <= 0) {
1215 if (auth_len > 0) {
1216 CVM_LOAD_SHA_UNIT(*data, next);
1217 auth_len -= 8;
1218 }
1219 } else
1220 auth_off -= 8;
1221 *first = mydata.data32[0];
1222 *data32 = mydata.data32[1];
1223 SG_CONSUME(sg, data32, data_i, data_l);
1224 }
1225
1226 /* finish the hash */
1227 CVMX_PREFETCH0(od->octo_hmouter);
1228 #if 0
1229 if (unlikely(inplen)) {
1230 uint64_t tmp = 0;
1231 uint8_t *p = (uint8_t *) & tmp;
1232 p[inplen] = 0x80;
1233 do {
1234 inplen--;
1235 p[inplen] = ((uint8_t *) data)[inplen];
1236 } while (inplen);
1237 CVM_LOAD_SHA_UNIT(tmp, next);
1238 } else {
1239 CVM_LOAD_SHA_UNIT(0x8000000000000000ULL, next);
1240 }
1241 #else
1242 CVM_LOAD_SHA_UNIT(0x8000000000000000ULL, next);
1243 #endif
1244
1245 /* Finish Inner hash */
1246 while (next != 7) {
1247 CVM_LOAD_SHA_UNIT(((uint64_t) 0x0ULL), next);
1248 }
1249 CVM_LOAD_SHA_UNIT((uint64_t) ((alen + 64) << 3), next);
1250
1251 /* Get the inner hash of HMAC */
1252 CVMX_MF_HSH_IV(tmp1, 0);
1253 CVMX_MF_HSH_IV(tmp2, 1);
1254 tmp3 = 0;
1255 CVMX_MF_HSH_IV(tmp3, 2);
1256
1257 /* Initialize hash unit */
1258 CVMX_MT_HSH_IV(od->octo_hmouter[0], 0);
1259 CVMX_MT_HSH_IV(od->octo_hmouter[1], 1);
1260 CVMX_MT_HSH_IV(od->octo_hmouter[2], 2);
1261
1262 CVMX_MT_HSH_DAT(tmp1, 0);
1263 CVMX_MT_HSH_DAT(tmp2, 1);
1264 tmp3 |= 0x0000000080000000;
1265 CVMX_MT_HSH_DAT(tmp3, 2);
1266 CVMX_MT_HSH_DATZ(3);
1267 CVMX_MT_HSH_DATZ(4);
1268 CVMX_MT_HSH_DATZ(5);
1269 CVMX_MT_HSH_DATZ(6);
1270 CVMX_MT_HSH_STARTSHA((uint64_t) ((64 + 20) << 3));
1271
1272 /* save the HMAC */
1273 SG_INIT(sg, data32, data_i, data_l);
1274 while (icv_off > 0) {
1275 SG_CONSUME(sg, data32, data_i, data_l);
1276 icv_off -= 4;
1277 }
1278 CVMX_MF_HSH_IV(tmp1, 0);
1279 *data32 = (uint32_t) (tmp1 >> 32);
1280 SG_CONSUME(sg, data32, data_i, data_l);
1281 *data32 = (uint32_t) tmp1;
1282 SG_CONSUME(sg, data32, data_i, data_l);
1283 CVMX_MF_HSH_IV(tmp1, 1);
1284 *data32 = (uint32_t) (tmp1 >> 32);
1285
1286 octeon_crypto_disable(&state, flags);
1287 return 0;
1288 }
1289
1290 int
1291 octo_des_cbc_sha1_decrypt(
1292 struct octo_sess *od,
1293 struct scatterlist *sg, int sg_len,
1294 int auth_off, int auth_len,
1295 int crypt_off, int crypt_len,
1296 int icv_off, uint8_t *ivp)
1297 {
1298 register int next = 0;
1299 union {
1300 uint32_t data32[2];
1301 uint64_t data64[1];
1302 } mydata;
1303 uint64_t *data = &mydata.data64[0];
1304 uint32_t *data32;
1305 uint64_t tmp1, tmp2, tmp3;
1306 int data_i, data_l, alen = auth_len;
1307 struct octeon_cop2_state state;
1308 unsigned long flags;
1309
1310 dprintk("%s()\n", __FUNCTION__);
1311
1312 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
1313 (crypt_off & 0x3) || (crypt_off + crypt_len > sg_len) ||
1314 (crypt_len & 0x7) ||
1315 (auth_len & 0x7) ||
1316 (auth_off & 0x3) || (auth_off + auth_len > sg_len))) {
1317 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
1318 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
1319 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
1320 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
1321 return -EINVAL;
1322 }
1323
1324 SG_INIT(sg, data32, data_i, data_l);
1325
1326 CVMX_PREFETCH0(ivp);
1327 CVMX_PREFETCH0(od->octo_enckey);
1328
1329 flags = octeon_crypto_enable(&state);
1330
1331 /* load 3DES Key */
1332 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
1333 if (od->octo_encklen == 24) {
1334 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
1335 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
1336 } else if (od->octo_encklen == 8) {
1337 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 1);
1338 CVMX_MT_3DES_KEY(((uint64_t *) od->octo_enckey)[0], 2);
1339 } else {
1340 octeon_crypto_disable(&state, flags);
1341 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
1342 return -EINVAL;
1343 }
1344
1345 CVMX_MT_3DES_IV(* (uint64_t *) ivp);
1346
1347 /* Load SHA1 IV */
1348 CVMX_MT_HSH_IV(od->octo_hminner[0], 0);
1349 CVMX_MT_HSH_IV(od->octo_hminner[1], 1);
1350 CVMX_MT_HSH_IV(od->octo_hminner[2], 2);
1351
1352 while (crypt_off > 0 && auth_off > 0) {
1353 SG_CONSUME(sg, data32, data_i, data_l);
1354 crypt_off -= 4;
1355 auth_off -= 4;
1356 }
1357
1358 while (crypt_len > 0 || auth_len > 0) {
1359 uint32_t *first = data32;
1360 mydata.data32[0] = *first;
1361 SG_CONSUME(sg, data32, data_i, data_l);
1362 mydata.data32[1] = *data32;
1363 if (auth_off <= 0) {
1364 if (auth_len > 0) {
1365 CVM_LOAD_SHA_UNIT(*data, next);
1366 auth_len -= 8;
1367 }
1368 } else
1369 auth_off -= 8;
1370 if (crypt_off <= 0) {
1371 if (crypt_len > 0) {
1372 CVMX_MT_3DES_DEC_CBC(*data);
1373 CVMX_MF_3DES_RESULT(*data);
1374 crypt_len -= 8;
1375 }
1376 } else
1377 crypt_off -= 8;
1378 *first = mydata.data32[0];
1379 *data32 = mydata.data32[1];
1380 SG_CONSUME(sg, data32, data_i, data_l);
1381 }
1382
1383 /* finish the hash */
1384 CVMX_PREFETCH0(od->octo_hmouter);
1385 #if 0
1386 if (unlikely(inplen)) {
1387 uint64_t tmp = 0;
1388 uint8_t *p = (uint8_t *) & tmp;
1389 p[inplen] = 0x80;
1390 do {
1391 inplen--;
1392 p[inplen] = ((uint8_t *) data)[inplen];
1393 } while (inplen);
1394 CVM_LOAD_SHA_UNIT(tmp, next);
1395 } else {
1396 CVM_LOAD_SHA_UNIT(0x8000000000000000ULL, next);
1397 }
1398 #else
1399 CVM_LOAD_SHA_UNIT(0x8000000000000000ULL, next);
1400 #endif
1401
1402 /* Finish Inner hash */
1403 while (next != 7) {
1404 CVM_LOAD_SHA_UNIT(((uint64_t) 0x0ULL), next);
1405 }
1406 CVM_LOAD_SHA_UNIT((uint64_t) ((alen + 64) << 3), next);
1407
1408 /* Get the inner hash of HMAC */
1409 CVMX_MF_HSH_IV(tmp1, 0);
1410 CVMX_MF_HSH_IV(tmp2, 1);
1411 tmp3 = 0;
1412 CVMX_MF_HSH_IV(tmp3, 2);
1413
1414 /* Initialize hash unit */
1415 CVMX_MT_HSH_IV(od->octo_hmouter[0], 0);
1416 CVMX_MT_HSH_IV(od->octo_hmouter[1], 1);
1417 CVMX_MT_HSH_IV(od->octo_hmouter[2], 2);
1418
1419 CVMX_MT_HSH_DAT(tmp1, 0);
1420 CVMX_MT_HSH_DAT(tmp2, 1);
1421 tmp3 |= 0x0000000080000000;
1422 CVMX_MT_HSH_DAT(tmp3, 2);
1423 CVMX_MT_HSH_DATZ(3);
1424 CVMX_MT_HSH_DATZ(4);
1425 CVMX_MT_HSH_DATZ(5);
1426 CVMX_MT_HSH_DATZ(6);
1427 CVMX_MT_HSH_STARTSHA((uint64_t) ((64 + 20) << 3));
1428 /* save the HMAC */
1429 SG_INIT(sg, data32, data_i, data_l);
1430 while (icv_off > 0) {
1431 SG_CONSUME(sg, data32, data_i, data_l);
1432 icv_off -= 4;
1433 }
1434 CVMX_MF_HSH_IV(tmp1, 0);
1435 *data32 = (uint32_t) (tmp1 >> 32);
1436 SG_CONSUME(sg, data32, data_i, data_l);
1437 *data32 = (uint32_t) tmp1;
1438 SG_CONSUME(sg, data32, data_i, data_l);
1439 CVMX_MF_HSH_IV(tmp1, 1);
1440 *data32 = (uint32_t) (tmp1 >> 32);
1441
1442 octeon_crypto_disable(&state, flags);
1443 return 0;
1444 }
1445
1446 /****************************************************************************/
1447 /* AES MD5 */
1448
1449 int
1450 octo_aes_cbc_md5_encrypt(
1451 struct octo_sess *od,
1452 struct scatterlist *sg, int sg_len,
1453 int auth_off, int auth_len,
1454 int crypt_off, int crypt_len,
1455 int icv_off, uint8_t *ivp)
1456 {
1457 register int next = 0;
1458 union {
1459 uint32_t data32[2];
1460 uint64_t data64[1];
1461 } mydata[2];
1462 uint64_t *pdata = &mydata[0].data64[0];
1463 uint64_t *data = &mydata[1].data64[0];
1464 uint32_t *data32;
1465 uint64_t tmp1, tmp2;
1466 int data_i, data_l, alen = auth_len;
1467 struct octeon_cop2_state state;
1468 unsigned long flags;
1469
1470 dprintk("%s()\n", __FUNCTION__);
1471
1472 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
1473 (crypt_off & 0x3) || (crypt_off + crypt_len > sg_len) ||
1474 (crypt_len & 0x7) ||
1475 (auth_len & 0x7) ||
1476 (auth_off & 0x3) || (auth_off + auth_len > sg_len))) {
1477 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
1478 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
1479 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
1480 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
1481 return -EINVAL;
1482 }
1483
1484 SG_INIT(sg, data32, data_i, data_l);
1485
1486 CVMX_PREFETCH0(ivp);
1487 CVMX_PREFETCH0(od->octo_enckey);
1488
1489 flags = octeon_crypto_enable(&state);
1490
1491 /* load AES Key */
1492 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
1493 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
1494
1495 if (od->octo_encklen == 16) {
1496 CVMX_MT_AES_KEY(0x0, 2);
1497 CVMX_MT_AES_KEY(0x0, 3);
1498 } else if (od->octo_encklen == 24) {
1499 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
1500 CVMX_MT_AES_KEY(0x0, 3);
1501 } else if (od->octo_encklen == 32) {
1502 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
1503 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[3], 3);
1504 } else {
1505 octeon_crypto_disable(&state, flags);
1506 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
1507 return -EINVAL;
1508 }
1509 CVMX_MT_AES_KEYLENGTH(od->octo_encklen / 8 - 1);
1510
1511 CVMX_MT_AES_IV(((uint64_t *) ivp)[0], 0);
1512 CVMX_MT_AES_IV(((uint64_t *) ivp)[1], 1);
1513
1514 /* Load MD5 IV */
1515 CVMX_MT_HSH_IV(od->octo_hminner[0], 0);
1516 CVMX_MT_HSH_IV(od->octo_hminner[1], 1);
1517
1518 while (crypt_off > 0 && auth_off > 0) {
1519 SG_CONSUME(sg, data32, data_i, data_l);
1520 crypt_off -= 4;
1521 auth_off -= 4;
1522 }
1523
1524 /* align auth and crypt */
1525 while (crypt_off > 0 && auth_len > 0) {
1526 mydata[0].data32[0] = *data32;
1527 SG_CONSUME(sg, data32, data_i, data_l);
1528 mydata[0].data32[1] = *data32;
1529 SG_CONSUME(sg, data32, data_i, data_l);
1530 CVM_LOAD_MD5_UNIT(*pdata, next);
1531 crypt_off -= 8;
1532 auth_len -= 8;
1533 }
1534
1535 while (crypt_len > 0) {
1536 uint32_t *pdata32[3];
1537
1538 pdata32[0] = data32;
1539 mydata[0].data32[0] = *data32;
1540 SG_CONSUME(sg, data32, data_i, data_l);
1541
1542 pdata32[1] = data32;
1543 mydata[0].data32[1] = *data32;
1544 SG_CONSUME(sg, data32, data_i, data_l);
1545
1546 pdata32[2] = data32;
1547 mydata[1].data32[0] = *data32;
1548 SG_CONSUME(sg, data32, data_i, data_l);
1549
1550 mydata[1].data32[1] = *data32;
1551
1552 CVMX_MT_AES_ENC_CBC0(*pdata);
1553 CVMX_MT_AES_ENC_CBC1(*data);
1554 CVMX_MF_AES_RESULT(*pdata, 0);
1555 CVMX_MF_AES_RESULT(*data, 1);
1556 crypt_len -= 16;
1557
1558 if (auth_len > 0) {
1559 CVM_LOAD_MD5_UNIT(*pdata, next);
1560 auth_len -= 8;
1561 }
1562 if (auth_len > 0) {
1563 CVM_LOAD_MD5_UNIT(*data, next);
1564 auth_len -= 8;
1565 }
1566
1567 *pdata32[0] = mydata[0].data32[0];
1568 *pdata32[1] = mydata[0].data32[1];
1569 *pdata32[2] = mydata[1].data32[0];
1570 *data32 = mydata[1].data32[1];
1571
1572 SG_CONSUME(sg, data32, data_i, data_l);
1573 }
1574
1575 /* finish any left over hashing */
1576 while (auth_len > 0) {
1577 mydata[0].data32[0] = *data32;
1578 SG_CONSUME(sg, data32, data_i, data_l);
1579 mydata[0].data32[1] = *data32;
1580 SG_CONSUME(sg, data32, data_i, data_l);
1581 CVM_LOAD_MD5_UNIT(*pdata, next);
1582 auth_len -= 8;
1583 }
1584
1585 /* finish the hash */
1586 CVMX_PREFETCH0(od->octo_hmouter);
1587 #if 0
1588 if (unlikely(inplen)) {
1589 uint64_t tmp = 0;
1590 uint8_t *p = (uint8_t *) & tmp;
1591 p[inplen] = 0x80;
1592 do {
1593 inplen--;
1594 p[inplen] = ((uint8_t *) data)[inplen];
1595 } while (inplen);
1596 CVM_LOAD_MD5_UNIT(tmp, next);
1597 } else {
1598 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
1599 }
1600 #else
1601 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
1602 #endif
1603
1604 /* Finish Inner hash */
1605 while (next != 7) {
1606 CVM_LOAD_MD5_UNIT(((uint64_t) 0x0ULL), next);
1607 }
1608 CVMX_ES64(tmp1, ((alen + 64) << 3));
1609 CVM_LOAD_MD5_UNIT(tmp1, next);
1610
1611 /* Get the inner hash of HMAC */
1612 CVMX_MF_HSH_IV(tmp1, 0);
1613 CVMX_MF_HSH_IV(tmp2, 1);
1614
1615 /* Initialize hash unit */
1616 CVMX_MT_HSH_IV(od->octo_hmouter[0], 0);
1617 CVMX_MT_HSH_IV(od->octo_hmouter[1], 1);
1618
1619 CVMX_MT_HSH_DAT(tmp1, 0);
1620 CVMX_MT_HSH_DAT(tmp2, 1);
1621 CVMX_MT_HSH_DAT(0x8000000000000000ULL, 2);
1622 CVMX_MT_HSH_DATZ(3);
1623 CVMX_MT_HSH_DATZ(4);
1624 CVMX_MT_HSH_DATZ(5);
1625 CVMX_MT_HSH_DATZ(6);
1626 CVMX_ES64(tmp1, ((64 + 16) << 3));
1627 CVMX_MT_HSH_STARTMD5(tmp1);
1628
1629 /* save the HMAC */
1630 SG_INIT(sg, data32, data_i, data_l);
1631 while (icv_off > 0) {
1632 SG_CONSUME(sg, data32, data_i, data_l);
1633 icv_off -= 4;
1634 }
1635 CVMX_MF_HSH_IV(tmp1, 0);
1636 *data32 = (uint32_t) (tmp1 >> 32);
1637 SG_CONSUME(sg, data32, data_i, data_l);
1638 *data32 = (uint32_t) tmp1;
1639 SG_CONSUME(sg, data32, data_i, data_l);
1640 CVMX_MF_HSH_IV(tmp1, 1);
1641 *data32 = (uint32_t) (tmp1 >> 32);
1642
1643 octeon_crypto_disable(&state, flags);
1644 return 0;
1645 }
1646
1647 int
1648 octo_aes_cbc_md5_decrypt(
1649 struct octo_sess *od,
1650 struct scatterlist *sg, int sg_len,
1651 int auth_off, int auth_len,
1652 int crypt_off, int crypt_len,
1653 int icv_off, uint8_t *ivp)
1654 {
1655 register int next = 0;
1656 union {
1657 uint32_t data32[2];
1658 uint64_t data64[1];
1659 } mydata[2];
1660 uint64_t *pdata = &mydata[0].data64[0];
1661 uint64_t *data = &mydata[1].data64[0];
1662 uint32_t *data32;
1663 uint64_t tmp1, tmp2;
1664 int data_i, data_l, alen = auth_len;
1665 struct octeon_cop2_state state;
1666 unsigned long flags;
1667
1668 dprintk("%s()\n", __FUNCTION__);
1669
1670 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
1671 (crypt_off & 0x3) || (crypt_off + crypt_len > sg_len) ||
1672 (crypt_len & 0x7) ||
1673 (auth_len & 0x7) ||
1674 (auth_off & 0x3) || (auth_off + auth_len > sg_len))) {
1675 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
1676 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
1677 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
1678 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
1679 return -EINVAL;
1680 }
1681
1682 SG_INIT(sg, data32, data_i, data_l);
1683
1684 CVMX_PREFETCH0(ivp);
1685 CVMX_PREFETCH0(od->octo_enckey);
1686
1687 flags = octeon_crypto_enable(&state);
1688
1689 /* load AES Key */
1690 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
1691 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
1692
1693 if (od->octo_encklen == 16) {
1694 CVMX_MT_AES_KEY(0x0, 2);
1695 CVMX_MT_AES_KEY(0x0, 3);
1696 } else if (od->octo_encklen == 24) {
1697 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
1698 CVMX_MT_AES_KEY(0x0, 3);
1699 } else if (od->octo_encklen == 32) {
1700 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
1701 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[3], 3);
1702 } else {
1703 octeon_crypto_disable(&state, flags);
1704 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
1705 return -EINVAL;
1706 }
1707 CVMX_MT_AES_KEYLENGTH(od->octo_encklen / 8 - 1);
1708
1709 CVMX_MT_AES_IV(((uint64_t *) ivp)[0], 0);
1710 CVMX_MT_AES_IV(((uint64_t *) ivp)[1], 1);
1711
1712 /* Load MD5 IV */
1713 CVMX_MT_HSH_IV(od->octo_hminner[0], 0);
1714 CVMX_MT_HSH_IV(od->octo_hminner[1], 1);
1715
1716 while (crypt_off > 0 && auth_off > 0) {
1717 SG_CONSUME(sg, data32, data_i, data_l);
1718 crypt_off -= 4;
1719 auth_off -= 4;
1720 }
1721
1722 /* align auth and crypt */
1723 while (crypt_off > 0 && auth_len > 0) {
1724 mydata[0].data32[0] = *data32;
1725 SG_CONSUME(sg, data32, data_i, data_l);
1726 mydata[0].data32[1] = *data32;
1727 SG_CONSUME(sg, data32, data_i, data_l);
1728 CVM_LOAD_MD5_UNIT(*pdata, next);
1729 crypt_off -= 8;
1730 auth_len -= 8;
1731 }
1732
1733 while (crypt_len > 0) {
1734 uint32_t *pdata32[3];
1735
1736 pdata32[0] = data32;
1737 mydata[0].data32[0] = *data32;
1738 SG_CONSUME(sg, data32, data_i, data_l);
1739 pdata32[1] = data32;
1740 mydata[0].data32[1] = *data32;
1741 SG_CONSUME(sg, data32, data_i, data_l);
1742 pdata32[2] = data32;
1743 mydata[1].data32[0] = *data32;
1744 SG_CONSUME(sg, data32, data_i, data_l);
1745 mydata[1].data32[1] = *data32;
1746
1747 if (auth_len > 0) {
1748 CVM_LOAD_MD5_UNIT(*pdata, next);
1749 auth_len -= 8;
1750 }
1751
1752 if (auth_len > 0) {
1753 CVM_LOAD_MD5_UNIT(*data, next);
1754 auth_len -= 8;
1755 }
1756
1757 CVMX_MT_AES_DEC_CBC0(*pdata);
1758 CVMX_MT_AES_DEC_CBC1(*data);
1759 CVMX_MF_AES_RESULT(*pdata, 0);
1760 CVMX_MF_AES_RESULT(*data, 1);
1761 crypt_len -= 16;
1762
1763 *pdata32[0] = mydata[0].data32[0];
1764 *pdata32[1] = mydata[0].data32[1];
1765 *pdata32[2] = mydata[1].data32[0];
1766 *data32 = mydata[1].data32[1];
1767
1768 SG_CONSUME(sg, data32, data_i, data_l);
1769 }
1770
1771 /* finish left over hash if any */
1772 while (auth_len > 0) {
1773 mydata[0].data32[0] = *data32;
1774 SG_CONSUME(sg, data32, data_i, data_l);
1775 mydata[0].data32[1] = *data32;
1776 SG_CONSUME(sg, data32, data_i, data_l);
1777 CVM_LOAD_MD5_UNIT(*pdata, next);
1778 auth_len -= 8;
1779 }
1780
1781
1782 /* finish the hash */
1783 CVMX_PREFETCH0(od->octo_hmouter);
1784 #if 0
1785 if (unlikely(inplen)) {
1786 uint64_t tmp = 0;
1787 uint8_t *p = (uint8_t *) & tmp;
1788 p[inplen] = 0x80;
1789 do {
1790 inplen--;
1791 p[inplen] = ((uint8_t *) data)[inplen];
1792 } while (inplen);
1793 CVM_LOAD_MD5_UNIT(tmp, next);
1794 } else {
1795 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
1796 }
1797 #else
1798 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
1799 #endif
1800
1801 /* Finish Inner hash */
1802 while (next != 7) {
1803 CVM_LOAD_MD5_UNIT(((uint64_t) 0x0ULL), next);
1804 }
1805 CVMX_ES64(tmp1, ((alen + 64) << 3));
1806 CVM_LOAD_MD5_UNIT(tmp1, next);
1807
1808 /* Get the inner hash of HMAC */
1809 CVMX_MF_HSH_IV(tmp1, 0);
1810 CVMX_MF_HSH_IV(tmp2, 1);
1811
1812 /* Initialize hash unit */
1813 CVMX_MT_HSH_IV(od->octo_hmouter[0], 0);
1814 CVMX_MT_HSH_IV(od->octo_hmouter[1], 1);
1815
1816 CVMX_MT_HSH_DAT(tmp1, 0);
1817 CVMX_MT_HSH_DAT(tmp2, 1);
1818 CVMX_MT_HSH_DAT(0x8000000000000000ULL, 2);
1819 CVMX_MT_HSH_DATZ(3);
1820 CVMX_MT_HSH_DATZ(4);
1821 CVMX_MT_HSH_DATZ(5);
1822 CVMX_MT_HSH_DATZ(6);
1823 CVMX_ES64(tmp1, ((64 + 16) << 3));
1824 CVMX_MT_HSH_STARTMD5(tmp1);
1825
1826 /* save the HMAC */
1827 SG_INIT(sg, data32, data_i, data_l);
1828 while (icv_off > 0) {
1829 SG_CONSUME(sg, data32, data_i, data_l);
1830 icv_off -= 4;
1831 }
1832 CVMX_MF_HSH_IV(tmp1, 0);
1833 *data32 = (uint32_t) (tmp1 >> 32);
1834 SG_CONSUME(sg, data32, data_i, data_l);
1835 *data32 = (uint32_t) tmp1;
1836 SG_CONSUME(sg, data32, data_i, data_l);
1837 CVMX_MF_HSH_IV(tmp1, 1);
1838 *data32 = (uint32_t) (tmp1 >> 32);
1839
1840 octeon_crypto_disable(&state, flags);
1841 return 0;
1842 }
1843
1844 /****************************************************************************/
1845 /* AES SHA1 */
1846
1847 int
1848 octo_aes_cbc_sha1_encrypt(
1849 struct octo_sess *od,
1850 struct scatterlist *sg, int sg_len,
1851 int auth_off, int auth_len,
1852 int crypt_off, int crypt_len,
1853 int icv_off, uint8_t *ivp)
1854 {
1855 register int next = 0;
1856 union {
1857 uint32_t data32[2];
1858 uint64_t data64[1];
1859 } mydata[2];
1860 uint64_t *pdata = &mydata[0].data64[0];
1861 uint64_t *data = &mydata[1].data64[0];
1862 uint32_t *data32;
1863 uint64_t tmp1, tmp2, tmp3;
1864 int data_i, data_l, alen = auth_len;
1865 struct octeon_cop2_state state;
1866 unsigned long flags;
1867
1868 dprintk("%s(a_off=%d a_len=%d c_off=%d c_len=%d icv_off=%d)\n",
1869 __FUNCTION__, auth_off, auth_len, crypt_off, crypt_len, icv_off);
1870
1871 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
1872 (crypt_off & 0x3) || (crypt_off + crypt_len > sg_len) ||
1873 (crypt_len & 0x7) ||
1874 (auth_len & 0x7) ||
1875 (auth_off & 0x3) || (auth_off + auth_len > sg_len))) {
1876 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
1877 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
1878 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
1879 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
1880 return -EINVAL;
1881 }
1882
1883 SG_INIT(sg, data32, data_i, data_l);
1884
1885 CVMX_PREFETCH0(ivp);
1886 CVMX_PREFETCH0(od->octo_enckey);
1887
1888 flags = octeon_crypto_enable(&state);
1889
1890 /* load AES Key */
1891 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
1892 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
1893
1894 if (od->octo_encklen == 16) {
1895 CVMX_MT_AES_KEY(0x0, 2);
1896 CVMX_MT_AES_KEY(0x0, 3);
1897 } else if (od->octo_encklen == 24) {
1898 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
1899 CVMX_MT_AES_KEY(0x0, 3);
1900 } else if (od->octo_encklen == 32) {
1901 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
1902 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[3], 3);
1903 } else {
1904 octeon_crypto_disable(&state, flags);
1905 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
1906 return -EINVAL;
1907 }
1908 CVMX_MT_AES_KEYLENGTH(od->octo_encklen / 8 - 1);
1909
1910 CVMX_MT_AES_IV(((uint64_t *) ivp)[0], 0);
1911 CVMX_MT_AES_IV(((uint64_t *) ivp)[1], 1);
1912
1913 /* Load SHA IV */
1914 CVMX_MT_HSH_IV(od->octo_hminner[0], 0);
1915 CVMX_MT_HSH_IV(od->octo_hminner[1], 1);
1916 CVMX_MT_HSH_IV(od->octo_hminner[2], 2);
1917
1918 while (crypt_off > 0 && auth_off > 0) {
1919 SG_CONSUME(sg, data32, data_i, data_l);
1920 crypt_off -= 4;
1921 auth_off -= 4;
1922 }
1923
1924 /* align auth and crypt */
1925 while (crypt_off > 0 && auth_len > 0) {
1926 mydata[0].data32[0] = *data32;
1927 SG_CONSUME(sg, data32, data_i, data_l);
1928 mydata[0].data32[1] = *data32;
1929 SG_CONSUME(sg, data32, data_i, data_l);
1930 CVM_LOAD_SHA_UNIT(*pdata, next);
1931 crypt_off -= 8;
1932 auth_len -= 8;
1933 }
1934
1935 while (crypt_len > 0) {
1936 uint32_t *pdata32[3];
1937
1938 pdata32[0] = data32;
1939 mydata[0].data32[0] = *data32;
1940 SG_CONSUME(sg, data32, data_i, data_l);
1941 pdata32[1] = data32;
1942 mydata[0].data32[1] = *data32;
1943 SG_CONSUME(sg, data32, data_i, data_l);
1944 pdata32[2] = data32;
1945 mydata[1].data32[0] = *data32;
1946 SG_CONSUME(sg, data32, data_i, data_l);
1947 mydata[1].data32[1] = *data32;
1948
1949 CVMX_MT_AES_ENC_CBC0(*pdata);
1950 CVMX_MT_AES_ENC_CBC1(*data);
1951 CVMX_MF_AES_RESULT(*pdata, 0);
1952 CVMX_MF_AES_RESULT(*data, 1);
1953 crypt_len -= 16;
1954
1955 if (auth_len > 0) {
1956 CVM_LOAD_SHA_UNIT(*pdata, next);
1957 auth_len -= 8;
1958 }
1959 if (auth_len > 0) {
1960 CVM_LOAD_SHA_UNIT(*data, next);
1961 auth_len -= 8;
1962 }
1963
1964 *pdata32[0] = mydata[0].data32[0];
1965 *pdata32[1] = mydata[0].data32[1];
1966 *pdata32[2] = mydata[1].data32[0];
1967 *data32 = mydata[1].data32[1];
1968
1969 SG_CONSUME(sg, data32, data_i, data_l);
1970 }
1971
1972 /* finish and hashing */
1973 while (auth_len > 0) {
1974 mydata[0].data32[0] = *data32;
1975 SG_CONSUME(sg, data32, data_i, data_l);
1976 mydata[0].data32[1] = *data32;
1977 SG_CONSUME(sg, data32, data_i, data_l);
1978 CVM_LOAD_SHA_UNIT(*pdata, next);
1979 auth_len -= 8;
1980 }
1981
1982 /* finish the hash */
1983 CVMX_PREFETCH0(od->octo_hmouter);
1984 #if 0
1985 if (unlikely(inplen)) {
1986 uint64_t tmp = 0;
1987 uint8_t *p = (uint8_t *) & tmp;
1988 p[inplen] = 0x80;
1989 do {
1990 inplen--;
1991 p[inplen] = ((uint8_t *) data)[inplen];
1992 } while (inplen);
1993 CVM_LOAD_SHA_UNIT(tmp, next);
1994 } else {
1995 CVM_LOAD_SHA_UNIT(0x8000000000000000ULL, next);
1996 }
1997 #else
1998 CVM_LOAD_SHA_UNIT(0x8000000000000000ULL, next);
1999 #endif
2000
2001 /* Finish Inner hash */
2002 while (next != 7) {
2003 CVM_LOAD_SHA_UNIT(((uint64_t) 0x0ULL), next);
2004 }
2005 CVM_LOAD_SHA_UNIT((uint64_t) ((alen + 64) << 3), next);
2006
2007 /* Get the inner hash of HMAC */
2008 CVMX_MF_HSH_IV(tmp1, 0);
2009 CVMX_MF_HSH_IV(tmp2, 1);
2010 tmp3 = 0;
2011 CVMX_MF_HSH_IV(tmp3, 2);
2012
2013 /* Initialize hash unit */
2014 CVMX_MT_HSH_IV(od->octo_hmouter[0], 0);
2015 CVMX_MT_HSH_IV(od->octo_hmouter[1], 1);
2016 CVMX_MT_HSH_IV(od->octo_hmouter[2], 2);
2017
2018 CVMX_MT_HSH_DAT(tmp1, 0);
2019 CVMX_MT_HSH_DAT(tmp2, 1);
2020 tmp3 |= 0x0000000080000000;
2021 CVMX_MT_HSH_DAT(tmp3, 2);
2022 CVMX_MT_HSH_DATZ(3);
2023 CVMX_MT_HSH_DATZ(4);
2024 CVMX_MT_HSH_DATZ(5);
2025 CVMX_MT_HSH_DATZ(6);
2026 CVMX_MT_HSH_STARTSHA((uint64_t) ((64 + 20) << 3));
2027
2028 /* finish the hash */
2029 CVMX_PREFETCH0(od->octo_hmouter);
2030 #if 0
2031 if (unlikely(inplen)) {
2032 uint64_t tmp = 0;
2033 uint8_t *p = (uint8_t *) & tmp;
2034 p[inplen] = 0x80;
2035 do {
2036 inplen--;
2037 p[inplen] = ((uint8_t *) data)[inplen];
2038 } while (inplen);
2039 CVM_LOAD_MD5_UNIT(tmp, next);
2040 } else {
2041 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
2042 }
2043 #else
2044 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
2045 #endif
2046
2047 /* save the HMAC */
2048 SG_INIT(sg, data32, data_i, data_l);
2049 while (icv_off > 0) {
2050 SG_CONSUME(sg, data32, data_i, data_l);
2051 icv_off -= 4;
2052 }
2053 CVMX_MF_HSH_IV(tmp1, 0);
2054 *data32 = (uint32_t) (tmp1 >> 32);
2055 SG_CONSUME(sg, data32, data_i, data_l);
2056 *data32 = (uint32_t) tmp1;
2057 SG_CONSUME(sg, data32, data_i, data_l);
2058 CVMX_MF_HSH_IV(tmp1, 1);
2059 *data32 = (uint32_t) (tmp1 >> 32);
2060
2061 octeon_crypto_disable(&state, flags);
2062 return 0;
2063 }
2064
2065 int
2066 octo_aes_cbc_sha1_decrypt(
2067 struct octo_sess *od,
2068 struct scatterlist *sg, int sg_len,
2069 int auth_off, int auth_len,
2070 int crypt_off, int crypt_len,
2071 int icv_off, uint8_t *ivp)
2072 {
2073 register int next = 0;
2074 union {
2075 uint32_t data32[2];
2076 uint64_t data64[1];
2077 } mydata[2];
2078 uint64_t *pdata = &mydata[0].data64[0];
2079 uint64_t *data = &mydata[1].data64[0];
2080 uint32_t *data32;
2081 uint64_t tmp1, tmp2, tmp3;
2082 int data_i, data_l, alen = auth_len;
2083 struct octeon_cop2_state state;
2084 unsigned long flags;
2085
2086 dprintk("%s(a_off=%d a_len=%d c_off=%d c_len=%d icv_off=%d)\n",
2087 __FUNCTION__, auth_off, auth_len, crypt_off, crypt_len, icv_off);
2088
2089 if (unlikely(od == NULL || sg==NULL || sg_len==0 || ivp==NULL ||
2090 (crypt_off & 0x3) || (crypt_off + crypt_len > sg_len) ||
2091 (crypt_len & 0x7) ||
2092 (auth_len & 0x7) ||
2093 (auth_off & 0x3) || (auth_off + auth_len > sg_len))) {
2094 dprintk("%s: Bad parameters od=%p sg=%p sg_len=%d "
2095 "auth_off=%d auth_len=%d crypt_off=%d crypt_len=%d "
2096 "icv_off=%d ivp=%p\n", __FUNCTION__, od, sg, sg_len,
2097 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
2098 return -EINVAL;
2099 }
2100
2101 SG_INIT(sg, data32, data_i, data_l);
2102
2103 CVMX_PREFETCH0(ivp);
2104 CVMX_PREFETCH0(od->octo_enckey);
2105
2106 flags = octeon_crypto_enable(&state);
2107
2108 /* load AES Key */
2109 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[0], 0);
2110 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[1], 1);
2111
2112 if (od->octo_encklen == 16) {
2113 CVMX_MT_AES_KEY(0x0, 2);
2114 CVMX_MT_AES_KEY(0x0, 3);
2115 } else if (od->octo_encklen == 24) {
2116 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
2117 CVMX_MT_AES_KEY(0x0, 3);
2118 } else if (od->octo_encklen == 32) {
2119 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[2], 2);
2120 CVMX_MT_AES_KEY(((uint64_t *) od->octo_enckey)[3], 3);
2121 } else {
2122 octeon_crypto_disable(&state, flags);
2123 dprintk("%s: Bad key length %d\n", __FUNCTION__, od->octo_encklen);
2124 return -EINVAL;
2125 }
2126 CVMX_MT_AES_KEYLENGTH(od->octo_encklen / 8 - 1);
2127
2128 CVMX_MT_AES_IV(((uint64_t *) ivp)[0], 0);
2129 CVMX_MT_AES_IV(((uint64_t *) ivp)[1], 1);
2130
2131 /* Load SHA1 IV */
2132 CVMX_MT_HSH_IV(od->octo_hminner[0], 0);
2133 CVMX_MT_HSH_IV(od->octo_hminner[1], 1);
2134 CVMX_MT_HSH_IV(od->octo_hminner[2], 2);
2135
2136 while (crypt_off > 0 && auth_off > 0) {
2137 SG_CONSUME(sg, data32, data_i, data_l);
2138 crypt_off -= 4;
2139 auth_off -= 4;
2140 }
2141
2142 /* align auth and crypt */
2143 while (crypt_off > 0 && auth_len > 0) {
2144 mydata[0].data32[0] = *data32;
2145 SG_CONSUME(sg, data32, data_i, data_l);
2146 mydata[0].data32[1] = *data32;
2147 SG_CONSUME(sg, data32, data_i, data_l);
2148 CVM_LOAD_SHA_UNIT(*pdata, next);
2149 crypt_off -= 8;
2150 auth_len -= 8;
2151 }
2152
2153 while (crypt_len > 0) {
2154 uint32_t *pdata32[3];
2155
2156 pdata32[0] = data32;
2157 mydata[0].data32[0] = *data32;
2158 SG_CONSUME(sg, data32, data_i, data_l);
2159 pdata32[1] = data32;
2160 mydata[0].data32[1] = *data32;
2161 SG_CONSUME(sg, data32, data_i, data_l);
2162 pdata32[2] = data32;
2163 mydata[1].data32[0] = *data32;
2164 SG_CONSUME(sg, data32, data_i, data_l);
2165 mydata[1].data32[1] = *data32;
2166
2167 if (auth_len > 0) {
2168 CVM_LOAD_SHA_UNIT(*pdata, next);
2169 auth_len -= 8;
2170 }
2171 if (auth_len > 0) {
2172 CVM_LOAD_SHA_UNIT(*data, next);
2173 auth_len -= 8;
2174 }
2175
2176 CVMX_MT_AES_DEC_CBC0(*pdata);
2177 CVMX_MT_AES_DEC_CBC1(*data);
2178 CVMX_MF_AES_RESULT(*pdata, 0);
2179 CVMX_MF_AES_RESULT(*data, 1);
2180 crypt_len -= 16;
2181
2182 *pdata32[0] = mydata[0].data32[0];
2183 *pdata32[1] = mydata[0].data32[1];
2184 *pdata32[2] = mydata[1].data32[0];
2185 *data32 = mydata[1].data32[1];
2186
2187 SG_CONSUME(sg, data32, data_i, data_l);
2188 }
2189
2190 /* finish and leftover hashing */
2191 while (auth_len > 0) {
2192 mydata[0].data32[0] = *data32;
2193 SG_CONSUME(sg, data32, data_i, data_l);
2194 mydata[0].data32[1] = *data32;
2195 SG_CONSUME(sg, data32, data_i, data_l);
2196 CVM_LOAD_SHA_UNIT(*pdata, next);
2197 auth_len -= 8;
2198 }
2199
2200 /* finish the hash */
2201 CVMX_PREFETCH0(od->octo_hmouter);
2202 #if 0
2203 if (unlikely(inplen)) {
2204 uint64_t tmp = 0;
2205 uint8_t *p = (uint8_t *) & tmp;
2206 p[inplen] = 0x80;
2207 do {
2208 inplen--;
2209 p[inplen] = ((uint8_t *) data)[inplen];
2210 } while (inplen);
2211 CVM_LOAD_SHA_UNIT(tmp, next);
2212 } else {
2213 CVM_LOAD_SHA_UNIT(0x8000000000000000ULL, next);
2214 }
2215 #else
2216 CVM_LOAD_SHA_UNIT(0x8000000000000000ULL, next);
2217 #endif
2218
2219 /* Finish Inner hash */
2220 while (next != 7) {
2221 CVM_LOAD_SHA_UNIT(((uint64_t) 0x0ULL), next);
2222 }
2223 CVM_LOAD_SHA_UNIT((uint64_t) ((alen + 64) << 3), next);
2224
2225 /* Get the inner hash of HMAC */
2226 CVMX_MF_HSH_IV(tmp1, 0);
2227 CVMX_MF_HSH_IV(tmp2, 1);
2228 tmp3 = 0;
2229 CVMX_MF_HSH_IV(tmp3, 2);
2230
2231 /* Initialize hash unit */
2232 CVMX_MT_HSH_IV(od->octo_hmouter[0], 0);
2233 CVMX_MT_HSH_IV(od->octo_hmouter[1], 1);
2234 CVMX_MT_HSH_IV(od->octo_hmouter[2], 2);
2235
2236 CVMX_MT_HSH_DAT(tmp1, 0);
2237 CVMX_MT_HSH_DAT(tmp2, 1);
2238 tmp3 |= 0x0000000080000000;
2239 CVMX_MT_HSH_DAT(tmp3, 2);
2240 CVMX_MT_HSH_DATZ(3);
2241 CVMX_MT_HSH_DATZ(4);
2242 CVMX_MT_HSH_DATZ(5);
2243 CVMX_MT_HSH_DATZ(6);
2244 CVMX_MT_HSH_STARTSHA((uint64_t) ((64 + 20) << 3));
2245
2246 /* finish the hash */
2247 CVMX_PREFETCH0(od->octo_hmouter);
2248 #if 0
2249 if (unlikely(inplen)) {
2250 uint64_t tmp = 0;
2251 uint8_t *p = (uint8_t *) & tmp;
2252 p[inplen] = 0x80;
2253 do {
2254 inplen--;
2255 p[inplen] = ((uint8_t *) data)[inplen];
2256 } while (inplen);
2257 CVM_LOAD_MD5_UNIT(tmp, next);
2258 } else {
2259 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
2260 }
2261 #else
2262 CVM_LOAD_MD5_UNIT(0x8000000000000000ULL, next);
2263 #endif
2264
2265 /* save the HMAC */
2266 SG_INIT(sg, data32, data_i, data_l);
2267 while (icv_off > 0) {
2268 SG_CONSUME(sg, data32, data_i, data_l);
2269 icv_off -= 4;
2270 }
2271 CVMX_MF_HSH_IV(tmp1, 0);
2272 *data32 = (uint32_t) (tmp1 >> 32);
2273 SG_CONSUME(sg, data32, data_i, data_l);
2274 *data32 = (uint32_t) tmp1;
2275 SG_CONSUME(sg, data32, data_i, data_l);
2276 CVMX_MF_HSH_IV(tmp1, 1);
2277 *data32 = (uint32_t) (tmp1 >> 32);
2278
2279 octeon_crypto_disable(&state, flags);
2280 return 0;
2281 }
2282
2283 /****************************************************************************/
Personal OpenWRT clone
This page took 0.202796 seconds and 5 git commands to generate.