?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'regmap-fix-v5.11-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux/fpc-iii.git] / drivers / crypto / inside-secure / safexcel_cipher.c
blobd68ef16650d47da360eefaeb044e833c755af2bd
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2017 Marvell
4 *
5 * Antoine Tenart <antoine.tenart@free-electrons.com>
6 */
7
8 #include <asm/unaligned.h>
9 #include <linux/device.h>
10 #include <linux/dma-mapping.h>
11 #include <linux/dmapool.h>
12 #include <crypto/aead.h>
13 #include <crypto/aes.h>
14 #include <crypto/authenc.h>
15 #include <crypto/chacha.h>
16 #include <crypto/ctr.h>
17 #include <crypto/internal/des.h>
18 #include <crypto/gcm.h>
19 #include <crypto/ghash.h>
20 #include <crypto/poly1305.h>
21 #include <crypto/sha1.h>
22 #include <crypto/sha2.h>
23 #include <crypto/sm3.h>
24 #include <crypto/sm4.h>
25 #include <crypto/xts.h>
26 #include <crypto/skcipher.h>
27 #include <crypto/internal/aead.h>
28 #include <crypto/internal/skcipher.h>
29
30 #include "safexcel.h"
31
32 enum safexcel_cipher_direction {
33 SAFEXCEL_ENCRYPT,
34 SAFEXCEL_DECRYPT,
35 };
36
37 enum safexcel_cipher_alg {
38 SAFEXCEL_DES,
39 SAFEXCEL_3DES,
40 SAFEXCEL_AES,
41 SAFEXCEL_CHACHA20,
42 SAFEXCEL_SM4,
43 };
44
45 struct safexcel_cipher_ctx {
46 struct safexcel_context base;
47 struct safexcel_crypto_priv *priv;
48
49 u32 mode;
50 enum safexcel_cipher_alg alg;
51 u8 aead; /* !=0=AEAD, 2=IPSec ESP AEAD, 3=IPsec ESP GMAC */
52 u8 xcm; /* 0=authenc, 1=GCM, 2 reserved for CCM */
53 u8 aadskip;
54 u8 blocksz;
55 u32 ivmask;
56 u32 ctrinit;
57
58 __le32 key[16];
59 u32 nonce;
60 unsigned int key_len, xts;
61
62 /* All the below is AEAD specific */
63 u32 hash_alg;
64 u32 state_sz;
65
66 struct crypto_cipher *hkaes;
67 struct crypto_aead *fback;
68 };
69
70 struct safexcel_cipher_req {
71 enum safexcel_cipher_direction direction;
72 /* Number of result descriptors associated to the request */
73 unsigned int rdescs;
74 bool needs_inv;
75 int nr_src, nr_dst;
76 };
77
78 static int safexcel_skcipher_iv(struct safexcel_cipher_ctx *ctx, u8 *iv,
79 struct safexcel_command_desc *cdesc)
80 {
81 if (ctx->mode == CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD) {
82 cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
83 /* 32 bit nonce */
84 cdesc->control_data.token[0] = ctx->nonce;
85 /* 64 bit IV part */
86 memcpy(&cdesc->control_data.token[1], iv, 8);
87 /* 32 bit counter, start at 0 or 1 (big endian!) */
88 cdesc->control_data.token[3] =
89 (__force u32)cpu_to_be32(ctx->ctrinit);
90 return 4;
91 }
92 if (ctx->alg == SAFEXCEL_CHACHA20) {
93 cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
94 /* 96 bit nonce part */
95 memcpy(&cdesc->control_data.token[0], &iv[4], 12);
96 /* 32 bit counter */
97 cdesc->control_data.token[3] = *(u32 *)iv;
98 return 4;
99 }
100
101 cdesc->control_data.options |= ctx->ivmask;
102 memcpy(cdesc->control_data.token, iv, ctx->blocksz);
103 return ctx->blocksz / sizeof(u32);
104 }
105
106 static void safexcel_skcipher_token(struct safexcel_cipher_ctx *ctx, u8 *iv,
107 struct safexcel_command_desc *cdesc,
108 struct safexcel_token *atoken,
109 u32 length)
110 {
111 struct safexcel_token *token;
112 int ivlen;
113
114 ivlen = safexcel_skcipher_iv(ctx, iv, cdesc);
115 if (ivlen == 4) {
116 /* No space in cdesc, instruction moves to atoken */
117 cdesc->additional_cdata_size = 1;
118 token = atoken;
119 } else {
120 /* Everything fits in cdesc */
121 token = (struct safexcel_token *)(cdesc->control_data.token + 2);
122 /* Need to pad with NOP */
123 eip197_noop_token(&token[1]);
124 }
125
126 token->opcode = EIP197_TOKEN_OPCODE_DIRECTION;
127 token->packet_length = length;
128 token->stat = EIP197_TOKEN_STAT_LAST_PACKET |
129 EIP197_TOKEN_STAT_LAST_HASH;
130 token->instructions = EIP197_TOKEN_INS_LAST |
131 EIP197_TOKEN_INS_TYPE_CRYPTO |
132 EIP197_TOKEN_INS_TYPE_OUTPUT;
133 }
134
135 static void safexcel_aead_iv(struct safexcel_cipher_ctx *ctx, u8 *iv,
136 struct safexcel_command_desc *cdesc)
137 {
138 if (ctx->mode == CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD ||
139 ctx->aead & EIP197_AEAD_TYPE_IPSEC_ESP) { /* _ESP and _ESP_GMAC */
140 /* 32 bit nonce */
141 cdesc->control_data.token[0] = ctx->nonce;
142 /* 64 bit IV part */
143 memcpy(&cdesc->control_data.token[1], iv, 8);
144 /* 32 bit counter, start at 0 or 1 (big endian!) */
145 cdesc->control_data.token[3] =
146 (__force u32)cpu_to_be32(ctx->ctrinit);
147 return;
148 }
149 if (ctx->xcm == EIP197_XCM_MODE_GCM || ctx->alg == SAFEXCEL_CHACHA20) {
150 /* 96 bit IV part */
151 memcpy(&cdesc->control_data.token[0], iv, 12);
152 /* 32 bit counter, start at 0 or 1 (big endian!) */
153 cdesc->control_data.token[3] =
154 (__force u32)cpu_to_be32(ctx->ctrinit);
155 return;
156 }
157 /* CBC */
158 memcpy(cdesc->control_data.token, iv, ctx->blocksz);
159 }
160
161 static void safexcel_aead_token(struct safexcel_cipher_ctx *ctx, u8 *iv,
162 struct safexcel_command_desc *cdesc,
163 struct safexcel_token *atoken,
164 enum safexcel_cipher_direction direction,
165 u32 cryptlen, u32 assoclen, u32 digestsize)
166 {
167 struct safexcel_token *aadref;
168 int atoksize = 2; /* Start with minimum size */
169 int assocadj = assoclen - ctx->aadskip, aadalign;
170
171 /* Always 4 dwords of embedded IV for AEAD modes */
172 cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
173
174 if (direction == SAFEXCEL_DECRYPT)
175 cryptlen -= digestsize;
176
177 if (unlikely(ctx->xcm == EIP197_XCM_MODE_CCM)) {
178 /* Construct IV block B0 for the CBC-MAC */
179 u8 *final_iv = (u8 *)cdesc->control_data.token;
180 u8 *cbcmaciv = (u8 *)&atoken[1];
181 __le32 *aadlen = (__le32 *)&atoken[5];
182
183 if (ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP) {
184 /* Length + nonce */
185 cdesc->control_data.token[0] = ctx->nonce;
186 /* Fixup flags byte */
187 *(__le32 *)cbcmaciv =
188 cpu_to_le32(ctx->nonce |
189 ((assocadj > 0) << 6) |
190 ((digestsize - 2) << 2));
191 /* 64 bit IV part */
192 memcpy(&cdesc->control_data.token[1], iv, 8);
193 memcpy(cbcmaciv + 4, iv, 8);
194 /* Start counter at 0 */
195 cdesc->control_data.token[3] = 0;
196 /* Message length */
197 *(__be32 *)(cbcmaciv + 12) = cpu_to_be32(cryptlen);
198 } else {
199 /* Variable length IV part */
200 memcpy(final_iv, iv, 15 - iv[0]);
201 memcpy(cbcmaciv, iv, 15 - iv[0]);
202 /* Start variable length counter at 0 */
203 memset(final_iv + 15 - iv[0], 0, iv[0] + 1);
204 memset(cbcmaciv + 15 - iv[0], 0, iv[0] - 1);
205 /* fixup flags byte */
206 cbcmaciv[0] |= ((assocadj > 0) << 6) |
207 ((digestsize - 2) << 2);
208 /* insert lower 2 bytes of message length */
209 cbcmaciv[14] = cryptlen >> 8;
210 cbcmaciv[15] = cryptlen & 255;
211 }
212
213 atoken->opcode = EIP197_TOKEN_OPCODE_INSERT;
214 atoken->packet_length = AES_BLOCK_SIZE +
215 ((assocadj > 0) << 1);
216 atoken->stat = 0;
217 atoken->instructions = EIP197_TOKEN_INS_ORIGIN_TOKEN |
218 EIP197_TOKEN_INS_TYPE_HASH;
219
220 if (likely(assocadj)) {
221 *aadlen = cpu_to_le32((assocadj >> 8) |
222 (assocadj & 255) << 8);
223 atoken += 6;
224 atoksize += 7;
225 } else {
226 atoken += 5;
227 atoksize += 6;
228 }
229
230 /* Process AAD data */
231 aadref = atoken;
232 atoken->opcode = EIP197_TOKEN_OPCODE_DIRECTION;
233 atoken->packet_length = assocadj;
234 atoken->stat = 0;
235 atoken->instructions = EIP197_TOKEN_INS_TYPE_HASH;
236 atoken++;
237
238 /* For CCM only, align AAD data towards hash engine */
239 atoken->opcode = EIP197_TOKEN_OPCODE_INSERT;
240 aadalign = (assocadj + 2) & 15;
241 atoken->packet_length = assocadj && aadalign ?
242 16 - aadalign :
243 0;
244 if (likely(cryptlen)) {
245 atoken->stat = 0;
246 atoken->instructions = EIP197_TOKEN_INS_TYPE_HASH;
247 } else {
248 atoken->stat = EIP197_TOKEN_STAT_LAST_HASH;
249 atoken->instructions = EIP197_TOKEN_INS_LAST |
250 EIP197_TOKEN_INS_TYPE_HASH;
251 }
252 } else {
253 safexcel_aead_iv(ctx, iv, cdesc);
254
255 /* Process AAD data */
256 aadref = atoken;
257 atoken->opcode = EIP197_TOKEN_OPCODE_DIRECTION;
258 atoken->packet_length = assocadj;
259 atoken->stat = EIP197_TOKEN_STAT_LAST_HASH;
260 atoken->instructions = EIP197_TOKEN_INS_LAST |
261 EIP197_TOKEN_INS_TYPE_HASH;
262 }
263 atoken++;
264
265 if (ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP) {
266 /* For ESP mode (and not GMAC), skip over the IV */
267 atoken->opcode = EIP197_TOKEN_OPCODE_DIRECTION;
268 atoken->packet_length = EIP197_AEAD_IPSEC_IV_SIZE;
269 atoken->stat = 0;
270 atoken->instructions = 0;
271 atoken++;
272 atoksize++;
273 } else if (unlikely(ctx->alg == SAFEXCEL_CHACHA20 &&
274 direction == SAFEXCEL_DECRYPT)) {
275 /* Poly-chacha decryption needs a dummy NOP here ... */
276 atoken->opcode = EIP197_TOKEN_OPCODE_INSERT;
277 atoken->packet_length = 16; /* According to Op Manual */
278 atoken->stat = 0;
279 atoken->instructions = 0;
280 atoken++;
281 atoksize++;
282 }
283
284 if (ctx->xcm) {
285 /* For GCM and CCM, obtain enc(Y0) */
286 atoken->opcode = EIP197_TOKEN_OPCODE_INSERT_REMRES;
287 atoken->packet_length = 0;
288 atoken->stat = 0;
289 atoken->instructions = AES_BLOCK_SIZE;
290 atoken++;
291
292 atoken->opcode = EIP197_TOKEN_OPCODE_INSERT;
293 atoken->packet_length = AES_BLOCK_SIZE;
294 atoken->stat = 0;
295 atoken->instructions = EIP197_TOKEN_INS_TYPE_OUTPUT |
296 EIP197_TOKEN_INS_TYPE_CRYPTO;
297 atoken++;
298 atoksize += 2;
299 }
300
301 if (likely(cryptlen || ctx->alg == SAFEXCEL_CHACHA20)) {
302 /* Fixup stat field for AAD direction instruction */
303 aadref->stat = 0;
304
305 /* Process crypto data */
306 atoken->opcode = EIP197_TOKEN_OPCODE_DIRECTION;
307 atoken->packet_length = cryptlen;
308
309 if (unlikely(ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP_GMAC)) {
310 /* Fixup instruction field for AAD dir instruction */
311 aadref->instructions = EIP197_TOKEN_INS_TYPE_HASH;
312
313 /* Do not send to crypt engine in case of GMAC */
314 atoken->instructions = EIP197_TOKEN_INS_LAST |
315 EIP197_TOKEN_INS_TYPE_HASH |
316 EIP197_TOKEN_INS_TYPE_OUTPUT;
317 } else {
318 atoken->instructions = EIP197_TOKEN_INS_LAST |
319 EIP197_TOKEN_INS_TYPE_CRYPTO |
320 EIP197_TOKEN_INS_TYPE_HASH |
321 EIP197_TOKEN_INS_TYPE_OUTPUT;
322 }
323
324 cryptlen &= 15;
325 if (unlikely(ctx->xcm == EIP197_XCM_MODE_CCM && cryptlen)) {
326 atoken->stat = 0;
327 /* For CCM only, pad crypto data to the hash engine */
328 atoken++;
329 atoksize++;
330 atoken->opcode = EIP197_TOKEN_OPCODE_INSERT;
331 atoken->packet_length = 16 - cryptlen;
332 atoken->stat = EIP197_TOKEN_STAT_LAST_HASH;
333 atoken->instructions = EIP197_TOKEN_INS_TYPE_HASH;
334 } else {
335 atoken->stat = EIP197_TOKEN_STAT_LAST_HASH;
336 }
337 atoken++;
338 atoksize++;
339 }
340
341 if (direction == SAFEXCEL_ENCRYPT) {
342 /* Append ICV */
343 atoken->opcode = EIP197_TOKEN_OPCODE_INSERT;
344 atoken->packet_length = digestsize;
345 atoken->stat = EIP197_TOKEN_STAT_LAST_HASH |
346 EIP197_TOKEN_STAT_LAST_PACKET;
347 atoken->instructions = EIP197_TOKEN_INS_TYPE_OUTPUT |
348 EIP197_TOKEN_INS_INSERT_HASH_DIGEST;
349 } else {
350 /* Extract ICV */
351 atoken->opcode = EIP197_TOKEN_OPCODE_RETRIEVE;
352 atoken->packet_length = digestsize;
353 atoken->stat = EIP197_TOKEN_STAT_LAST_HASH |
354 EIP197_TOKEN_STAT_LAST_PACKET;
355 atoken->instructions = EIP197_TOKEN_INS_INSERT_HASH_DIGEST;
356 atoken++;
357 atoksize++;
358
359 /* Verify ICV */
360 atoken->opcode = EIP197_TOKEN_OPCODE_VERIFY;
361 atoken->packet_length = digestsize |
362 EIP197_TOKEN_HASH_RESULT_VERIFY;
363 atoken->stat = EIP197_TOKEN_STAT_LAST_HASH |
364 EIP197_TOKEN_STAT_LAST_PACKET;
365 atoken->instructions = EIP197_TOKEN_INS_TYPE_OUTPUT;
366 }
367
368 /* Fixup length of the token in the command descriptor */
369 cdesc->additional_cdata_size = atoksize;
370 }
371
372 static int safexcel_skcipher_aes_setkey(struct crypto_skcipher *ctfm,
373 const u8 *key, unsigned int len)
374 {
375 struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
376 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
377 struct safexcel_crypto_priv *priv = ctx->base.priv;
378 struct crypto_aes_ctx aes;
379 int ret, i;
380
381 ret = aes_expandkey(&aes, key, len);
382 if (ret)
383 return ret;
384
385 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
386 for (i = 0; i < len / sizeof(u32); i++) {
387 if (le32_to_cpu(ctx->key[i]) != aes.key_enc[i]) {
388 ctx->base.needs_inv = true;
389 break;
390 }
391 }
392 }
393
394 for (i = 0; i < len / sizeof(u32); i++)
395 ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
396
397 ctx->key_len = len;
398
399 memzero_explicit(&aes, sizeof(aes));
400 return 0;
401 }
402
403 static int safexcel_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
404 unsigned int len)
405 {
406 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
407 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
408 struct safexcel_crypto_priv *priv = ctx->base.priv;
409 struct crypto_authenc_keys keys;
410 struct crypto_aes_ctx aes;
411 int err = -EINVAL, i;
412 const char *alg;
413
414 if (unlikely(crypto_authenc_extractkeys(&keys, key, len)))
415 goto badkey;
416
417 if (ctx->mode == CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD) {
418 /* Must have at least space for the nonce here */
419 if (unlikely(keys.enckeylen < CTR_RFC3686_NONCE_SIZE))
420 goto badkey;
421 /* last 4 bytes of key are the nonce! */
422 ctx->nonce = *(u32 *)(keys.enckey + keys.enckeylen -
423 CTR_RFC3686_NONCE_SIZE);
424 /* exclude the nonce here */
425 keys.enckeylen -= CTR_RFC3686_NONCE_SIZE;
426 }
427
428 /* Encryption key */
429 switch (ctx->alg) {
430 case SAFEXCEL_DES:
431 err = verify_aead_des_key(ctfm, keys.enckey, keys.enckeylen);
432 if (unlikely(err))
433 goto badkey;
434 break;
435 case SAFEXCEL_3DES:
436 err = verify_aead_des3_key(ctfm, keys.enckey, keys.enckeylen);
437 if (unlikely(err))
438 goto badkey;
439 break;
440 case SAFEXCEL_AES:
441 err = aes_expandkey(&aes, keys.enckey, keys.enckeylen);
442 if (unlikely(err))
443 goto badkey;
444 break;
445 case SAFEXCEL_SM4:
446 if (unlikely(keys.enckeylen != SM4_KEY_SIZE))
447 goto badkey;
448 break;
449 default:
450 dev_err(priv->dev, "aead: unsupported cipher algorithm\n");
451 goto badkey;
452 }
453
454 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
455 for (i = 0; i < keys.enckeylen / sizeof(u32); i++) {
456 if (le32_to_cpu(ctx->key[i]) !=
457 ((u32 *)keys.enckey)[i]) {
458 ctx->base.needs_inv = true;
459 break;
460 }
461 }
462 }
463
464 /* Auth key */
465 switch (ctx->hash_alg) {
466 case CONTEXT_CONTROL_CRYPTO_ALG_SHA1:
467 alg = "safexcel-sha1";
468 break;
469 case CONTEXT_CONTROL_CRYPTO_ALG_SHA224:
470 alg = "safexcel-sha224";
471 break;
472 case CONTEXT_CONTROL_CRYPTO_ALG_SHA256:
473 alg = "safexcel-sha256";
474 break;
475 case CONTEXT_CONTROL_CRYPTO_ALG_SHA384:
476 alg = "safexcel-sha384";
477 break;
478 case CONTEXT_CONTROL_CRYPTO_ALG_SHA512:
479 alg = "safexcel-sha512";
480 break;
481 case CONTEXT_CONTROL_CRYPTO_ALG_SM3:
482 alg = "safexcel-sm3";
483 break;
484 default:
485 dev_err(priv->dev, "aead: unsupported hash algorithm\n");
486 goto badkey;
487 }
488
489 if (safexcel_hmac_setkey(&ctx->base, keys.authkey, keys.authkeylen,
490 alg, ctx->state_sz))
491 goto badkey;
492
493 /* Now copy the keys into the context */
494 for (i = 0; i < keys.enckeylen / sizeof(u32); i++)
495 ctx->key[i] = cpu_to_le32(((u32 *)keys.enckey)[i]);
496 ctx->key_len = keys.enckeylen;
497
498 memzero_explicit(&keys, sizeof(keys));
499 return 0;
500
501 badkey:
502 memzero_explicit(&keys, sizeof(keys));
503 return err;
504 }
505
506 static int safexcel_context_control(struct safexcel_cipher_ctx *ctx,
507 struct crypto_async_request *async,
508 struct safexcel_cipher_req *sreq,
509 struct safexcel_command_desc *cdesc)
510 {
511 struct safexcel_crypto_priv *priv = ctx->base.priv;
512 int ctrl_size = ctx->key_len / sizeof(u32);
513
514 cdesc->control_data.control1 = ctx->mode;
515
516 if (ctx->aead) {
517 /* Take in account the ipad+opad digests */
518 if (ctx->xcm) {
519 ctrl_size += ctx->state_sz / sizeof(u32);
520 cdesc->control_data.control0 =
521 CONTEXT_CONTROL_KEY_EN |
522 CONTEXT_CONTROL_DIGEST_XCM |
523 ctx->hash_alg |
524 CONTEXT_CONTROL_SIZE(ctrl_size);
525 } else if (ctx->alg == SAFEXCEL_CHACHA20) {
526 /* Chacha20-Poly1305 */
527 cdesc->control_data.control0 =
528 CONTEXT_CONTROL_KEY_EN |
529 CONTEXT_CONTROL_CRYPTO_ALG_CHACHA20 |
530 (sreq->direction == SAFEXCEL_ENCRYPT ?
531 CONTEXT_CONTROL_TYPE_ENCRYPT_HASH_OUT :
532 CONTEXT_CONTROL_TYPE_HASH_DECRYPT_IN) |
533 ctx->hash_alg |
534 CONTEXT_CONTROL_SIZE(ctrl_size);
535 return 0;
536 } else {
537 ctrl_size += ctx->state_sz / sizeof(u32) * 2;
538 cdesc->control_data.control0 =
539 CONTEXT_CONTROL_KEY_EN |
540 CONTEXT_CONTROL_DIGEST_HMAC |
541 ctx->hash_alg |
542 CONTEXT_CONTROL_SIZE(ctrl_size);
543 }
544
545 if (sreq->direction == SAFEXCEL_ENCRYPT &&
546 (ctx->xcm == EIP197_XCM_MODE_CCM ||
547 ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP_GMAC))
548 cdesc->control_data.control0 |=
549 CONTEXT_CONTROL_TYPE_HASH_ENCRYPT_OUT;
550 else if (sreq->direction == SAFEXCEL_ENCRYPT)
551 cdesc->control_data.control0 |=
552 CONTEXT_CONTROL_TYPE_ENCRYPT_HASH_OUT;
553 else if (ctx->xcm == EIP197_XCM_MODE_CCM)
554 cdesc->control_data.control0 |=
555 CONTEXT_CONTROL_TYPE_DECRYPT_HASH_IN;
556 else
557 cdesc->control_data.control0 |=
558 CONTEXT_CONTROL_TYPE_HASH_DECRYPT_IN;
559 } else {
560 if (sreq->direction == SAFEXCEL_ENCRYPT)
561 cdesc->control_data.control0 =
562 CONTEXT_CONTROL_TYPE_CRYPTO_OUT |
563 CONTEXT_CONTROL_KEY_EN |
564 CONTEXT_CONTROL_SIZE(ctrl_size);
565 else
566 cdesc->control_data.control0 =
567 CONTEXT_CONTROL_TYPE_CRYPTO_IN |
568 CONTEXT_CONTROL_KEY_EN |
569 CONTEXT_CONTROL_SIZE(ctrl_size);
570 }
571
572 if (ctx->alg == SAFEXCEL_DES) {
573 cdesc->control_data.control0 |=
574 CONTEXT_CONTROL_CRYPTO_ALG_DES;
575 } else if (ctx->alg == SAFEXCEL_3DES) {
576 cdesc->control_data.control0 |=
577 CONTEXT_CONTROL_CRYPTO_ALG_3DES;
578 } else if (ctx->alg == SAFEXCEL_AES) {
579 switch (ctx->key_len >> ctx->xts) {
580 case AES_KEYSIZE_128:
581 cdesc->control_data.control0 |=
582 CONTEXT_CONTROL_CRYPTO_ALG_AES128;
583 break;
584 case AES_KEYSIZE_192:
585 cdesc->control_data.control0 |=
586 CONTEXT_CONTROL_CRYPTO_ALG_AES192;
587 break;
588 case AES_KEYSIZE_256:
589 cdesc->control_data.control0 |=
590 CONTEXT_CONTROL_CRYPTO_ALG_AES256;
591 break;
592 default:
593 dev_err(priv->dev, "aes keysize not supported: %u\n",
594 ctx->key_len >> ctx->xts);
595 return -EINVAL;
596 }
597 } else if (ctx->alg == SAFEXCEL_CHACHA20) {
598 cdesc->control_data.control0 |=
599 CONTEXT_CONTROL_CRYPTO_ALG_CHACHA20;
600 } else if (ctx->alg == SAFEXCEL_SM4) {
601 cdesc->control_data.control0 |=
602 CONTEXT_CONTROL_CRYPTO_ALG_SM4;
603 }
604
605 return 0;
606 }
607
608 static int safexcel_handle_req_result(struct safexcel_crypto_priv *priv, int ring,
609 struct crypto_async_request *async,
610 struct scatterlist *src,
611 struct scatterlist *dst,
612 unsigned int cryptlen,
613 struct safexcel_cipher_req *sreq,
614 bool *should_complete, int *ret)
615 {
616 struct skcipher_request *areq = skcipher_request_cast(async);
617 struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(areq);
618 struct safexcel_cipher_ctx *ctx = crypto_skcipher_ctx(skcipher);
619 struct safexcel_result_desc *rdesc;
620 int ndesc = 0;
621
622 *ret = 0;
623
624 if (unlikely(!sreq->rdescs))
625 return 0;
626
627 while (sreq->rdescs--) {
628 rdesc = safexcel_ring_next_rptr(priv, &priv->ring[ring].rdr);
629 if (IS_ERR(rdesc)) {
630 dev_err(priv->dev,
631 "cipher: result: could not retrieve the result descriptor\n");
632 *ret = PTR_ERR(rdesc);
633 break;
634 }
635
636 if (likely(!*ret))
637 *ret = safexcel_rdesc_check_errors(priv, rdesc);
638
639 ndesc++;
640 }
641
642 safexcel_complete(priv, ring);
643
644 if (src == dst) {
645 dma_unmap_sg(priv->dev, src, sreq->nr_src, DMA_BIDIRECTIONAL);
646 } else {
647 dma_unmap_sg(priv->dev, src, sreq->nr_src, DMA_TO_DEVICE);
648 dma_unmap_sg(priv->dev, dst, sreq->nr_dst, DMA_FROM_DEVICE);
649 }
650
651 /*
652 * Update IV in req from last crypto output word for CBC modes
653 */
654 if ((!ctx->aead) && (ctx->mode == CONTEXT_CONTROL_CRYPTO_MODE_CBC) &&
655 (sreq->direction == SAFEXCEL_ENCRYPT)) {
656 /* For encrypt take the last output word */
657 sg_pcopy_to_buffer(dst, sreq->nr_dst, areq->iv,
658 crypto_skcipher_ivsize(skcipher),
659 (cryptlen -
660 crypto_skcipher_ivsize(skcipher)));
661 }
662
663 *should_complete = true;
664
665 return ndesc;
666 }
667
668 static int safexcel_send_req(struct crypto_async_request *base, int ring,
669 struct safexcel_cipher_req *sreq,
670 struct scatterlist *src, struct scatterlist *dst,
671 unsigned int cryptlen, unsigned int assoclen,
672 unsigned int digestsize, u8 *iv, int *commands,
673 int *results)
674 {
675 struct skcipher_request *areq = skcipher_request_cast(base);
676 struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(areq);
677 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(base->tfm);
678 struct safexcel_crypto_priv *priv = ctx->base.priv;
679 struct safexcel_command_desc *cdesc;
680 struct safexcel_command_desc *first_cdesc = NULL;
681 struct safexcel_result_desc *rdesc, *first_rdesc = NULL;
682 struct scatterlist *sg;
683 unsigned int totlen;
684 unsigned int totlen_src = cryptlen + assoclen;
685 unsigned int totlen_dst = totlen_src;
686 struct safexcel_token *atoken;
687 int n_cdesc = 0, n_rdesc = 0;
688 int queued, i, ret = 0;
689 bool first = true;
690
691 sreq->nr_src = sg_nents_for_len(src, totlen_src);
692
693 if (ctx->aead) {
694 /*
695 * AEAD has auth tag appended to output for encrypt and
696 * removed from the output for decrypt!
697 */
698 if (sreq->direction == SAFEXCEL_DECRYPT)
699 totlen_dst -= digestsize;
700 else
701 totlen_dst += digestsize;
702
703 memcpy(ctx->base.ctxr->data + ctx->key_len / sizeof(u32),
704 &ctx->base.ipad, ctx->state_sz);
705 if (!ctx->xcm)
706 memcpy(ctx->base.ctxr->data + (ctx->key_len +
707 ctx->state_sz) / sizeof(u32), &ctx->base.opad,
708 ctx->state_sz);
709 } else if ((ctx->mode == CONTEXT_CONTROL_CRYPTO_MODE_CBC) &&
710 (sreq->direction == SAFEXCEL_DECRYPT)) {
711 /*
712 * Save IV from last crypto input word for CBC modes in decrypt
713 * direction. Need to do this first in case of inplace operation
714 * as it will be overwritten.
715 */
716 sg_pcopy_to_buffer(src, sreq->nr_src, areq->iv,
717 crypto_skcipher_ivsize(skcipher),
718 (totlen_src -
719 crypto_skcipher_ivsize(skcipher)));
720 }
721
722 sreq->nr_dst = sg_nents_for_len(dst, totlen_dst);
723
724 /*
725 * Remember actual input length, source buffer length may be
726 * updated in case of inline operation below.
727 */
728 totlen = totlen_src;
729 queued = totlen_src;
730
731 if (src == dst) {
732 sreq->nr_src = max(sreq->nr_src, sreq->nr_dst);
733 sreq->nr_dst = sreq->nr_src;
734 if (unlikely((totlen_src || totlen_dst) &&
735 (sreq->nr_src <= 0))) {
736 dev_err(priv->dev, "In-place buffer not large enough (need %d bytes)!",
737 max(totlen_src, totlen_dst));
738 return -EINVAL;
739 }
740 dma_map_sg(priv->dev, src, sreq->nr_src, DMA_BIDIRECTIONAL);
741 } else {
742 if (unlikely(totlen_src && (sreq->nr_src <= 0))) {
743 dev_err(priv->dev, "Source buffer not large enough (need %d bytes)!",
744 totlen_src);
745 return -EINVAL;
746 }
747 dma_map_sg(priv->dev, src, sreq->nr_src, DMA_TO_DEVICE);
748
749 if (unlikely(totlen_dst && (sreq->nr_dst <= 0))) {
750 dev_err(priv->dev, "Dest buffer not large enough (need %d bytes)!",
751 totlen_dst);
752 dma_unmap_sg(priv->dev, src, sreq->nr_src,
753 DMA_TO_DEVICE);
754 return -EINVAL;
755 }
756 dma_map_sg(priv->dev, dst, sreq->nr_dst, DMA_FROM_DEVICE);
757 }
758
759 memcpy(ctx->base.ctxr->data, ctx->key, ctx->key_len);
760
761 if (!totlen) {
762 /*
763 * The EIP97 cannot deal with zero length input packets!
764 * So stuff a dummy command descriptor indicating a 1 byte
765 * (dummy) input packet, using the context record as source.
766 */
767 first_cdesc = safexcel_add_cdesc(priv, ring,
768 1, 1, ctx->base.ctxr_dma,
769 1, 1, ctx->base.ctxr_dma,
770 &atoken);
771 if (IS_ERR(first_cdesc)) {
772 /* No space left in the command descriptor ring */
773 ret = PTR_ERR(first_cdesc);
774 goto cdesc_rollback;
775 }
776 n_cdesc = 1;
777 goto skip_cdesc;
778 }
779
780 /* command descriptors */
781 for_each_sg(src, sg, sreq->nr_src, i) {
782 int len = sg_dma_len(sg);
783
784 /* Do not overflow the request */
785 if (queued < len)
786 len = queued;
787
788 cdesc = safexcel_add_cdesc(priv, ring, !n_cdesc,
789 !(queued - len),
790 sg_dma_address(sg), len, totlen,
791 ctx->base.ctxr_dma, &atoken);
792 if (IS_ERR(cdesc)) {
793 /* No space left in the command descriptor ring */
794 ret = PTR_ERR(cdesc);
795 goto cdesc_rollback;
796 }
797
798 if (!n_cdesc)
799 first_cdesc = cdesc;
800
801 n_cdesc++;
802 queued -= len;
803 if (!queued)
804 break;
805 }
806 skip_cdesc:
807 /* Add context control words and token to first command descriptor */
808 safexcel_context_control(ctx, base, sreq, first_cdesc);
809 if (ctx->aead)
810 safexcel_aead_token(ctx, iv, first_cdesc, atoken,
811 sreq->direction, cryptlen,
812 assoclen, digestsize);
813 else
814 safexcel_skcipher_token(ctx, iv, first_cdesc, atoken,
815 cryptlen);
816
817 /* result descriptors */
818 for_each_sg(dst, sg, sreq->nr_dst, i) {
819 bool last = (i == sreq->nr_dst - 1);
820 u32 len = sg_dma_len(sg);
821
822 /* only allow the part of the buffer we know we need */
823 if (len > totlen_dst)
824 len = totlen_dst;
825 if (unlikely(!len))
826 break;
827 totlen_dst -= len;
828
829 /* skip over AAD space in buffer - not written */
830 if (assoclen) {
831 if (assoclen >= len) {
832 assoclen -= len;
833 continue;
834 }
835 rdesc = safexcel_add_rdesc(priv, ring, first, last,
836 sg_dma_address(sg) +
837 assoclen,
838 len - assoclen);
839 assoclen = 0;
840 } else {
841 rdesc = safexcel_add_rdesc(priv, ring, first, last,
842 sg_dma_address(sg),
843 len);
844 }
845 if (IS_ERR(rdesc)) {
846 /* No space left in the result descriptor ring */
847 ret = PTR_ERR(rdesc);
848 goto rdesc_rollback;
849 }
850 if (first) {
851 first_rdesc = rdesc;
852 first = false;
853 }
854 n_rdesc++;
855 }
856
857 if (unlikely(first)) {
858 /*
859 * Special case: AEAD decrypt with only AAD data.
860 * In this case there is NO output data from the engine,
861 * but the engine still needs a result descriptor!
862 * Create a dummy one just for catching the result token.
863 */
864 rdesc = safexcel_add_rdesc(priv, ring, true, true, 0, 0);
865 if (IS_ERR(rdesc)) {
866 /* No space left in the result descriptor ring */
867 ret = PTR_ERR(rdesc);
868 goto rdesc_rollback;
869 }
870 first_rdesc = rdesc;
871 n_rdesc = 1;
872 }
873
874 safexcel_rdr_req_set(priv, ring, first_rdesc, base);
875
876 *commands = n_cdesc;
877 *results = n_rdesc;
878 return 0;
879
880 rdesc_rollback:
881 for (i = 0; i < n_rdesc; i++)
882 safexcel_ring_rollback_wptr(priv, &priv->ring[ring].rdr);
883 cdesc_rollback:
884 for (i = 0; i < n_cdesc; i++)
885 safexcel_ring_rollback_wptr(priv, &priv->ring[ring].cdr);
886
887 if (src == dst) {
888 dma_unmap_sg(priv->dev, src, sreq->nr_src, DMA_BIDIRECTIONAL);
889 } else {
890 dma_unmap_sg(priv->dev, src, sreq->nr_src, DMA_TO_DEVICE);
891 dma_unmap_sg(priv->dev, dst, sreq->nr_dst, DMA_FROM_DEVICE);
892 }
893
894 return ret;
895 }
896
897 static int safexcel_handle_inv_result(struct safexcel_crypto_priv *priv,
898 int ring,
899 struct crypto_async_request *base,
900 struct safexcel_cipher_req *sreq,
901 bool *should_complete, int *ret)
902 {
903 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(base->tfm);
904 struct safexcel_result_desc *rdesc;
905 int ndesc = 0, enq_ret;
906
907 *ret = 0;
908
909 if (unlikely(!sreq->rdescs))
910 return 0;
911
912 while (sreq->rdescs--) {
913 rdesc = safexcel_ring_next_rptr(priv, &priv->ring[ring].rdr);
914 if (IS_ERR(rdesc)) {
915 dev_err(priv->dev,
916 "cipher: invalidate: could not retrieve the result descriptor\n");
917 *ret = PTR_ERR(rdesc);
918 break;
919 }
920
921 if (likely(!*ret))
922 *ret = safexcel_rdesc_check_errors(priv, rdesc);
923
924 ndesc++;
925 }
926
927 safexcel_complete(priv, ring);
928
929 if (ctx->base.exit_inv) {
930 dma_pool_free(priv->context_pool, ctx->base.ctxr,
931 ctx->base.ctxr_dma);
932
933 *should_complete = true;
934
935 return ndesc;
936 }
937
938 ring = safexcel_select_ring(priv);
939 ctx->base.ring = ring;
940
941 spin_lock_bh(&priv->ring[ring].queue_lock);
942 enq_ret = crypto_enqueue_request(&priv->ring[ring].queue, base);
943 spin_unlock_bh(&priv->ring[ring].queue_lock);
944
945 if (enq_ret != -EINPROGRESS)
946 *ret = enq_ret;
947
948 queue_work(priv->ring[ring].workqueue,
949 &priv->ring[ring].work_data.work);
950
951 *should_complete = false;
952
953 return ndesc;
954 }
955
956 static int safexcel_skcipher_handle_result(struct safexcel_crypto_priv *priv,
957 int ring,
958 struct crypto_async_request *async,
959 bool *should_complete, int *ret)
960 {
961 struct skcipher_request *req = skcipher_request_cast(async);
962 struct safexcel_cipher_req *sreq = skcipher_request_ctx(req);
963 int err;
964
965 if (sreq->needs_inv) {
966 sreq->needs_inv = false;
967 err = safexcel_handle_inv_result(priv, ring, async, sreq,
968 should_complete, ret);
969 } else {
970 err = safexcel_handle_req_result(priv, ring, async, req->src,
971 req->dst, req->cryptlen, sreq,
972 should_complete, ret);
973 }
974
975 return err;
976 }
977
978 static int safexcel_aead_handle_result(struct safexcel_crypto_priv *priv,
979 int ring,
980 struct crypto_async_request *async,
981 bool *should_complete, int *ret)
982 {
983 struct aead_request *req = aead_request_cast(async);
984 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
985 struct safexcel_cipher_req *sreq = aead_request_ctx(req);
986 int err;
987
988 if (sreq->needs_inv) {
989 sreq->needs_inv = false;
990 err = safexcel_handle_inv_result(priv, ring, async, sreq,
991 should_complete, ret);
992 } else {
993 err = safexcel_handle_req_result(priv, ring, async, req->src,
994 req->dst,
995 req->cryptlen + crypto_aead_authsize(tfm),
996 sreq, should_complete, ret);
997 }
998
999 return err;
1000 }
1001
1002 static int safexcel_cipher_send_inv(struct crypto_async_request *base,
1003 int ring, int *commands, int *results)
1004 {
1005 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(base->tfm);
1006 struct safexcel_crypto_priv *priv = ctx->base.priv;
1007 int ret;
1008
1009 ret = safexcel_invalidate_cache(base, priv, ctx->base.ctxr_dma, ring);
1010 if (unlikely(ret))
1011 return ret;
1012
1013 *commands = 1;
1014 *results = 1;
1015
1016 return 0;
1017 }
1018
1019 static int safexcel_skcipher_send(struct crypto_async_request *async, int ring,
1020 int *commands, int *results)
1021 {
1022 struct skcipher_request *req = skcipher_request_cast(async);
1023 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
1024 struct safexcel_cipher_req *sreq = skcipher_request_ctx(req);
1025 struct safexcel_crypto_priv *priv = ctx->base.priv;
1026 int ret;
1027
1028 BUG_ON(!(priv->flags & EIP197_TRC_CACHE) && sreq->needs_inv);
1029
1030 if (sreq->needs_inv) {
1031 ret = safexcel_cipher_send_inv(async, ring, commands, results);
1032 } else {
1033 struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
1034 u8 input_iv[AES_BLOCK_SIZE];
1035
1036 /*
1037 * Save input IV in case of CBC decrypt mode
1038 * Will be overwritten with output IV prior to use!
1039 */
1040 memcpy(input_iv, req->iv, crypto_skcipher_ivsize(skcipher));
1041
1042 ret = safexcel_send_req(async, ring, sreq, req->src,
1043 req->dst, req->cryptlen, 0, 0, input_iv,
1044 commands, results);
1045 }
1046
1047 sreq->rdescs = *results;
1048 return ret;
1049 }
1050
1051 static int safexcel_aead_send(struct crypto_async_request *async, int ring,
1052 int *commands, int *results)
1053 {
1054 struct aead_request *req = aead_request_cast(async);
1055 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
1056 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
1057 struct safexcel_cipher_req *sreq = aead_request_ctx(req);
1058 struct safexcel_crypto_priv *priv = ctx->base.priv;
1059 int ret;
1060
1061 BUG_ON(!(priv->flags & EIP197_TRC_CACHE) && sreq->needs_inv);
1062
1063 if (sreq->needs_inv)
1064 ret = safexcel_cipher_send_inv(async, ring, commands, results);
1065 else
1066 ret = safexcel_send_req(async, ring, sreq, req->src, req->dst,
1067 req->cryptlen, req->assoclen,
1068 crypto_aead_authsize(tfm), req->iv,
1069 commands, results);
1070 sreq->rdescs = *results;
1071 return ret;
1072 }
1073
1074 static int safexcel_cipher_exit_inv(struct crypto_tfm *tfm,
1075 struct crypto_async_request *base,
1076 struct safexcel_cipher_req *sreq,
1077 struct safexcel_inv_result *result)
1078 {
1079 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1080 struct safexcel_crypto_priv *priv = ctx->base.priv;
1081 int ring = ctx->base.ring;
1082
1083 init_completion(&result->completion);
1084
1085 ctx = crypto_tfm_ctx(base->tfm);
1086 ctx->base.exit_inv = true;
1087 sreq->needs_inv = true;
1088
1089 spin_lock_bh(&priv->ring[ring].queue_lock);
1090 crypto_enqueue_request(&priv->ring[ring].queue, base);
1091 spin_unlock_bh(&priv->ring[ring].queue_lock);
1092
1093 queue_work(priv->ring[ring].workqueue,
1094 &priv->ring[ring].work_data.work);
1095
1096 wait_for_completion(&result->completion);
1097
1098 if (result->error) {
1099 dev_warn(priv->dev,
1100 "cipher: sync: invalidate: completion error %d\n",
1101 result->error);
1102 return result->error;
1103 }
1104
1105 return 0;
1106 }
1107
1108 static int safexcel_skcipher_exit_inv(struct crypto_tfm *tfm)
1109 {
1110 EIP197_REQUEST_ON_STACK(req, skcipher, EIP197_SKCIPHER_REQ_SIZE);
1111 struct safexcel_cipher_req *sreq = skcipher_request_ctx(req);
1112 struct safexcel_inv_result result = {};
1113
1114 memset(req, 0, sizeof(struct skcipher_request));
1115
1116 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1117 safexcel_inv_complete, &result);
1118 skcipher_request_set_tfm(req, __crypto_skcipher_cast(tfm));
1119
1120 return safexcel_cipher_exit_inv(tfm, &req->base, sreq, &result);
1121 }
1122
1123 static int safexcel_aead_exit_inv(struct crypto_tfm *tfm)
1124 {
1125 EIP197_REQUEST_ON_STACK(req, aead, EIP197_AEAD_REQ_SIZE);
1126 struct safexcel_cipher_req *sreq = aead_request_ctx(req);
1127 struct safexcel_inv_result result = {};
1128
1129 memset(req, 0, sizeof(struct aead_request));
1130
1131 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1132 safexcel_inv_complete, &result);
1133 aead_request_set_tfm(req, __crypto_aead_cast(tfm));
1134
1135 return safexcel_cipher_exit_inv(tfm, &req->base, sreq, &result);
1136 }
1137
1138 static int safexcel_queue_req(struct crypto_async_request *base,
1139 struct safexcel_cipher_req *sreq,
1140 enum safexcel_cipher_direction dir)
1141 {
1142 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(base->tfm);
1143 struct safexcel_crypto_priv *priv = ctx->base.priv;
1144 int ret, ring;
1145
1146 sreq->needs_inv = false;
1147 sreq->direction = dir;
1148
1149 if (ctx->base.ctxr) {
1150 if (priv->flags & EIP197_TRC_CACHE && ctx->base.needs_inv) {
1151 sreq->needs_inv = true;
1152 ctx->base.needs_inv = false;
1153 }
1154 } else {
1155 ctx->base.ring = safexcel_select_ring(priv);
1156 ctx->base.ctxr = dma_pool_zalloc(priv->context_pool,
1157 EIP197_GFP_FLAGS(*base),
1158 &ctx->base.ctxr_dma);
1159 if (!ctx->base.ctxr)
1160 return -ENOMEM;
1161 }
1162
1163 ring = ctx->base.ring;
1164
1165 spin_lock_bh(&priv->ring[ring].queue_lock);
1166 ret = crypto_enqueue_request(&priv->ring[ring].queue, base);
1167 spin_unlock_bh(&priv->ring[ring].queue_lock);
1168
1169 queue_work(priv->ring[ring].workqueue,
1170 &priv->ring[ring].work_data.work);
1171
1172 return ret;
1173 }
1174
1175 static int safexcel_encrypt(struct skcipher_request *req)
1176 {
1177 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
1178 SAFEXCEL_ENCRYPT);
1179 }
1180
1181 static int safexcel_decrypt(struct skcipher_request *req)
1182 {
1183 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
1184 SAFEXCEL_DECRYPT);
1185 }
1186
1187 static int safexcel_skcipher_cra_init(struct crypto_tfm *tfm)
1188 {
1189 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1190 struct safexcel_alg_template *tmpl =
1191 container_of(tfm->__crt_alg, struct safexcel_alg_template,
1192 alg.skcipher.base);
1193
1194 crypto_skcipher_set_reqsize(__crypto_skcipher_cast(tfm),
1195 sizeof(struct safexcel_cipher_req));
1196
1197 ctx->base.priv = tmpl->priv;
1198
1199 ctx->base.send = safexcel_skcipher_send;
1200 ctx->base.handle_result = safexcel_skcipher_handle_result;
1201 ctx->ivmask = EIP197_OPTION_4_TOKEN_IV_CMD;
1202 ctx->ctrinit = 1;
1203 return 0;
1204 }
1205
1206 static int safexcel_cipher_cra_exit(struct crypto_tfm *tfm)
1207 {
1208 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1209
1210 memzero_explicit(ctx->key, sizeof(ctx->key));
1211
1212 /* context not allocated, skip invalidation */
1213 if (!ctx->base.ctxr)
1214 return -ENOMEM;
1215
1216 memzero_explicit(ctx->base.ctxr->data, sizeof(ctx->base.ctxr->data));
1217 return 0;
1218 }
1219
1220 static void safexcel_skcipher_cra_exit(struct crypto_tfm *tfm)
1221 {
1222 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1223 struct safexcel_crypto_priv *priv = ctx->base.priv;
1224 int ret;
1225
1226 if (safexcel_cipher_cra_exit(tfm))
1227 return;
1228
1229 if (priv->flags & EIP197_TRC_CACHE) {
1230 ret = safexcel_skcipher_exit_inv(tfm);
1231 if (ret)
1232 dev_warn(priv->dev, "skcipher: invalidation error %d\n",
1233 ret);
1234 } else {
1235 dma_pool_free(priv->context_pool, ctx->base.ctxr,
1236 ctx->base.ctxr_dma);
1237 }
1238 }
1239
1240 static void safexcel_aead_cra_exit(struct crypto_tfm *tfm)
1241 {
1242 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1243 struct safexcel_crypto_priv *priv = ctx->base.priv;
1244 int ret;
1245
1246 if (safexcel_cipher_cra_exit(tfm))
1247 return;
1248
1249 if (priv->flags & EIP197_TRC_CACHE) {
1250 ret = safexcel_aead_exit_inv(tfm);
1251 if (ret)
1252 dev_warn(priv->dev, "aead: invalidation error %d\n",
1253 ret);
1254 } else {
1255 dma_pool_free(priv->context_pool, ctx->base.ctxr,
1256 ctx->base.ctxr_dma);
1257 }
1258 }
1259
1260 static int safexcel_skcipher_aes_ecb_cra_init(struct crypto_tfm *tfm)
1261 {
1262 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1263
1264 safexcel_skcipher_cra_init(tfm);
1265 ctx->alg = SAFEXCEL_AES;
1266 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_ECB;
1267 ctx->blocksz = 0;
1268 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
1269 return 0;
1270 }
1271
1272 struct safexcel_alg_template safexcel_alg_ecb_aes = {
1273 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1274 .algo_mask = SAFEXCEL_ALG_AES,
1275 .alg.skcipher = {
1276 .setkey = safexcel_skcipher_aes_setkey,
1277 .encrypt = safexcel_encrypt,
1278 .decrypt = safexcel_decrypt,
1279 .min_keysize = AES_MIN_KEY_SIZE,
1280 .max_keysize = AES_MAX_KEY_SIZE,
1281 .base = {
1282 .cra_name = "ecb(aes)",
1283 .cra_driver_name = "safexcel-ecb-aes",
1284 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1285 .cra_flags = CRYPTO_ALG_ASYNC |
1286 CRYPTO_ALG_ALLOCATES_MEMORY |
1287 CRYPTO_ALG_KERN_DRIVER_ONLY,
1288 .cra_blocksize = AES_BLOCK_SIZE,
1289 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1290 .cra_alignmask = 0,
1291 .cra_init = safexcel_skcipher_aes_ecb_cra_init,
1292 .cra_exit = safexcel_skcipher_cra_exit,
1293 .cra_module = THIS_MODULE,
1294 },
1295 },
1296 };
1297
1298 static int safexcel_skcipher_aes_cbc_cra_init(struct crypto_tfm *tfm)
1299 {
1300 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1301
1302 safexcel_skcipher_cra_init(tfm);
1303 ctx->alg = SAFEXCEL_AES;
1304 ctx->blocksz = AES_BLOCK_SIZE;
1305 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CBC;
1306 return 0;
1307 }
1308
1309 struct safexcel_alg_template safexcel_alg_cbc_aes = {
1310 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1311 .algo_mask = SAFEXCEL_ALG_AES,
1312 .alg.skcipher = {
1313 .setkey = safexcel_skcipher_aes_setkey,
1314 .encrypt = safexcel_encrypt,
1315 .decrypt = safexcel_decrypt,
1316 .min_keysize = AES_MIN_KEY_SIZE,
1317 .max_keysize = AES_MAX_KEY_SIZE,
1318 .ivsize = AES_BLOCK_SIZE,
1319 .base = {
1320 .cra_name = "cbc(aes)",
1321 .cra_driver_name = "safexcel-cbc-aes",
1322 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1323 .cra_flags = CRYPTO_ALG_ASYNC |
1324 CRYPTO_ALG_ALLOCATES_MEMORY |
1325 CRYPTO_ALG_KERN_DRIVER_ONLY,
1326 .cra_blocksize = AES_BLOCK_SIZE,
1327 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1328 .cra_alignmask = 0,
1329 .cra_init = safexcel_skcipher_aes_cbc_cra_init,
1330 .cra_exit = safexcel_skcipher_cra_exit,
1331 .cra_module = THIS_MODULE,
1332 },
1333 },
1334 };
1335
1336 static int safexcel_skcipher_aes_cfb_cra_init(struct crypto_tfm *tfm)
1337 {
1338 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1339
1340 safexcel_skcipher_cra_init(tfm);
1341 ctx->alg = SAFEXCEL_AES;
1342 ctx->blocksz = AES_BLOCK_SIZE;
1343 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CFB;
1344 return 0;
1345 }
1346
1347 struct safexcel_alg_template safexcel_alg_cfb_aes = {
1348 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1349 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_AES_XFB,
1350 .alg.skcipher = {
1351 .setkey = safexcel_skcipher_aes_setkey,
1352 .encrypt = safexcel_encrypt,
1353 .decrypt = safexcel_decrypt,
1354 .min_keysize = AES_MIN_KEY_SIZE,
1355 .max_keysize = AES_MAX_KEY_SIZE,
1356 .ivsize = AES_BLOCK_SIZE,
1357 .base = {
1358 .cra_name = "cfb(aes)",
1359 .cra_driver_name = "safexcel-cfb-aes",
1360 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1361 .cra_flags = CRYPTO_ALG_ASYNC |
1362 CRYPTO_ALG_ALLOCATES_MEMORY |
1363 CRYPTO_ALG_KERN_DRIVER_ONLY,
1364 .cra_blocksize = 1,
1365 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1366 .cra_alignmask = 0,
1367 .cra_init = safexcel_skcipher_aes_cfb_cra_init,
1368 .cra_exit = safexcel_skcipher_cra_exit,
1369 .cra_module = THIS_MODULE,
1370 },
1371 },
1372 };
1373
1374 static int safexcel_skcipher_aes_ofb_cra_init(struct crypto_tfm *tfm)
1375 {
1376 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1377
1378 safexcel_skcipher_cra_init(tfm);
1379 ctx->alg = SAFEXCEL_AES;
1380 ctx->blocksz = AES_BLOCK_SIZE;
1381 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_OFB;
1382 return 0;
1383 }
1384
1385 struct safexcel_alg_template safexcel_alg_ofb_aes = {
1386 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1387 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_AES_XFB,
1388 .alg.skcipher = {
1389 .setkey = safexcel_skcipher_aes_setkey,
1390 .encrypt = safexcel_encrypt,
1391 .decrypt = safexcel_decrypt,
1392 .min_keysize = AES_MIN_KEY_SIZE,
1393 .max_keysize = AES_MAX_KEY_SIZE,
1394 .ivsize = AES_BLOCK_SIZE,
1395 .base = {
1396 .cra_name = "ofb(aes)",
1397 .cra_driver_name = "safexcel-ofb-aes",
1398 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1399 .cra_flags = CRYPTO_ALG_ASYNC |
1400 CRYPTO_ALG_ALLOCATES_MEMORY |
1401 CRYPTO_ALG_KERN_DRIVER_ONLY,
1402 .cra_blocksize = 1,
1403 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1404 .cra_alignmask = 0,
1405 .cra_init = safexcel_skcipher_aes_ofb_cra_init,
1406 .cra_exit = safexcel_skcipher_cra_exit,
1407 .cra_module = THIS_MODULE,
1408 },
1409 },
1410 };
1411
1412 static int safexcel_skcipher_aesctr_setkey(struct crypto_skcipher *ctfm,
1413 const u8 *key, unsigned int len)
1414 {
1415 struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
1416 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1417 struct safexcel_crypto_priv *priv = ctx->base.priv;
1418 struct crypto_aes_ctx aes;
1419 int ret, i;
1420 unsigned int keylen;
1421
1422 /* last 4 bytes of key are the nonce! */
1423 ctx->nonce = *(u32 *)(key + len - CTR_RFC3686_NONCE_SIZE);
1424 /* exclude the nonce here */
1425 keylen = len - CTR_RFC3686_NONCE_SIZE;
1426 ret = aes_expandkey(&aes, key, keylen);
1427 if (ret)
1428 return ret;
1429
1430 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
1431 for (i = 0; i < keylen / sizeof(u32); i++) {
1432 if (le32_to_cpu(ctx->key[i]) != aes.key_enc[i]) {
1433 ctx->base.needs_inv = true;
1434 break;
1435 }
1436 }
1437 }
1438
1439 for (i = 0; i < keylen / sizeof(u32); i++)
1440 ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
1441
1442 ctx->key_len = keylen;
1443
1444 memzero_explicit(&aes, sizeof(aes));
1445 return 0;
1446 }
1447
1448 static int safexcel_skcipher_aes_ctr_cra_init(struct crypto_tfm *tfm)
1449 {
1450 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1451
1452 safexcel_skcipher_cra_init(tfm);
1453 ctx->alg = SAFEXCEL_AES;
1454 ctx->blocksz = AES_BLOCK_SIZE;
1455 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD;
1456 return 0;
1457 }
1458
1459 struct safexcel_alg_template safexcel_alg_ctr_aes = {
1460 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1461 .algo_mask = SAFEXCEL_ALG_AES,
1462 .alg.skcipher = {
1463 .setkey = safexcel_skcipher_aesctr_setkey,
1464 .encrypt = safexcel_encrypt,
1465 .decrypt = safexcel_decrypt,
1466 /* Add nonce size */
1467 .min_keysize = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
1468 .max_keysize = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
1469 .ivsize = CTR_RFC3686_IV_SIZE,
1470 .base = {
1471 .cra_name = "rfc3686(ctr(aes))",
1472 .cra_driver_name = "safexcel-ctr-aes",
1473 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1474 .cra_flags = CRYPTO_ALG_ASYNC |
1475 CRYPTO_ALG_ALLOCATES_MEMORY |
1476 CRYPTO_ALG_KERN_DRIVER_ONLY,
1477 .cra_blocksize = 1,
1478 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1479 .cra_alignmask = 0,
1480 .cra_init = safexcel_skcipher_aes_ctr_cra_init,
1481 .cra_exit = safexcel_skcipher_cra_exit,
1482 .cra_module = THIS_MODULE,
1483 },
1484 },
1485 };
1486
1487 static int safexcel_des_setkey(struct crypto_skcipher *ctfm, const u8 *key,
1488 unsigned int len)
1489 {
1490 struct safexcel_cipher_ctx *ctx = crypto_skcipher_ctx(ctfm);
1491 struct safexcel_crypto_priv *priv = ctx->base.priv;
1492 int ret;
1493
1494 ret = verify_skcipher_des_key(ctfm, key);
1495 if (ret)
1496 return ret;
1497
1498 /* if context exits and key changed, need to invalidate it */
1499 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma)
1500 if (memcmp(ctx->key, key, len))
1501 ctx->base.needs_inv = true;
1502
1503 memcpy(ctx->key, key, len);
1504 ctx->key_len = len;
1505
1506 return 0;
1507 }
1508
1509 static int safexcel_skcipher_des_cbc_cra_init(struct crypto_tfm *tfm)
1510 {
1511 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1512
1513 safexcel_skcipher_cra_init(tfm);
1514 ctx->alg = SAFEXCEL_DES;
1515 ctx->blocksz = DES_BLOCK_SIZE;
1516 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
1517 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CBC;
1518 return 0;
1519 }
1520
1521 struct safexcel_alg_template safexcel_alg_cbc_des = {
1522 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1523 .algo_mask = SAFEXCEL_ALG_DES,
1524 .alg.skcipher = {
1525 .setkey = safexcel_des_setkey,
1526 .encrypt = safexcel_encrypt,
1527 .decrypt = safexcel_decrypt,
1528 .min_keysize = DES_KEY_SIZE,
1529 .max_keysize = DES_KEY_SIZE,
1530 .ivsize = DES_BLOCK_SIZE,
1531 .base = {
1532 .cra_name = "cbc(des)",
1533 .cra_driver_name = "safexcel-cbc-des",
1534 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1535 .cra_flags = CRYPTO_ALG_ASYNC |
1536 CRYPTO_ALG_ALLOCATES_MEMORY |
1537 CRYPTO_ALG_KERN_DRIVER_ONLY,
1538 .cra_blocksize = DES_BLOCK_SIZE,
1539 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1540 .cra_alignmask = 0,
1541 .cra_init = safexcel_skcipher_des_cbc_cra_init,
1542 .cra_exit = safexcel_skcipher_cra_exit,
1543 .cra_module = THIS_MODULE,
1544 },
1545 },
1546 };
1547
1548 static int safexcel_skcipher_des_ecb_cra_init(struct crypto_tfm *tfm)
1549 {
1550 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1551
1552 safexcel_skcipher_cra_init(tfm);
1553 ctx->alg = SAFEXCEL_DES;
1554 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_ECB;
1555 ctx->blocksz = 0;
1556 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
1557 return 0;
1558 }
1559
1560 struct safexcel_alg_template safexcel_alg_ecb_des = {
1561 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1562 .algo_mask = SAFEXCEL_ALG_DES,
1563 .alg.skcipher = {
1564 .setkey = safexcel_des_setkey,
1565 .encrypt = safexcel_encrypt,
1566 .decrypt = safexcel_decrypt,
1567 .min_keysize = DES_KEY_SIZE,
1568 .max_keysize = DES_KEY_SIZE,
1569 .base = {
1570 .cra_name = "ecb(des)",
1571 .cra_driver_name = "safexcel-ecb-des",
1572 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1573 .cra_flags = CRYPTO_ALG_ASYNC |
1574 CRYPTO_ALG_ALLOCATES_MEMORY |
1575 CRYPTO_ALG_KERN_DRIVER_ONLY,
1576 .cra_blocksize = DES_BLOCK_SIZE,
1577 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1578 .cra_alignmask = 0,
1579 .cra_init = safexcel_skcipher_des_ecb_cra_init,
1580 .cra_exit = safexcel_skcipher_cra_exit,
1581 .cra_module = THIS_MODULE,
1582 },
1583 },
1584 };
1585
1586 static int safexcel_des3_ede_setkey(struct crypto_skcipher *ctfm,
1587 const u8 *key, unsigned int len)
1588 {
1589 struct safexcel_cipher_ctx *ctx = crypto_skcipher_ctx(ctfm);
1590 struct safexcel_crypto_priv *priv = ctx->base.priv;
1591 int err;
1592
1593 err = verify_skcipher_des3_key(ctfm, key);
1594 if (err)
1595 return err;
1596
1597 /* if context exits and key changed, need to invalidate it */
1598 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma)
1599 if (memcmp(ctx->key, key, len))
1600 ctx->base.needs_inv = true;
1601
1602 memcpy(ctx->key, key, len);
1603 ctx->key_len = len;
1604
1605 return 0;
1606 }
1607
1608 static int safexcel_skcipher_des3_cbc_cra_init(struct crypto_tfm *tfm)
1609 {
1610 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1611
1612 safexcel_skcipher_cra_init(tfm);
1613 ctx->alg = SAFEXCEL_3DES;
1614 ctx->blocksz = DES3_EDE_BLOCK_SIZE;
1615 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
1616 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CBC;
1617 return 0;
1618 }
1619
1620 struct safexcel_alg_template safexcel_alg_cbc_des3_ede = {
1621 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1622 .algo_mask = SAFEXCEL_ALG_DES,
1623 .alg.skcipher = {
1624 .setkey = safexcel_des3_ede_setkey,
1625 .encrypt = safexcel_encrypt,
1626 .decrypt = safexcel_decrypt,
1627 .min_keysize = DES3_EDE_KEY_SIZE,
1628 .max_keysize = DES3_EDE_KEY_SIZE,
1629 .ivsize = DES3_EDE_BLOCK_SIZE,
1630 .base = {
1631 .cra_name = "cbc(des3_ede)",
1632 .cra_driver_name = "safexcel-cbc-des3_ede",
1633 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1634 .cra_flags = CRYPTO_ALG_ASYNC |
1635 CRYPTO_ALG_ALLOCATES_MEMORY |
1636 CRYPTO_ALG_KERN_DRIVER_ONLY,
1637 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1638 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1639 .cra_alignmask = 0,
1640 .cra_init = safexcel_skcipher_des3_cbc_cra_init,
1641 .cra_exit = safexcel_skcipher_cra_exit,
1642 .cra_module = THIS_MODULE,
1643 },
1644 },
1645 };
1646
1647 static int safexcel_skcipher_des3_ecb_cra_init(struct crypto_tfm *tfm)
1648 {
1649 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1650
1651 safexcel_skcipher_cra_init(tfm);
1652 ctx->alg = SAFEXCEL_3DES;
1653 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_ECB;
1654 ctx->blocksz = 0;
1655 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
1656 return 0;
1657 }
1658
1659 struct safexcel_alg_template safexcel_alg_ecb_des3_ede = {
1660 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1661 .algo_mask = SAFEXCEL_ALG_DES,
1662 .alg.skcipher = {
1663 .setkey = safexcel_des3_ede_setkey,
1664 .encrypt = safexcel_encrypt,
1665 .decrypt = safexcel_decrypt,
1666 .min_keysize = DES3_EDE_KEY_SIZE,
1667 .max_keysize = DES3_EDE_KEY_SIZE,
1668 .base = {
1669 .cra_name = "ecb(des3_ede)",
1670 .cra_driver_name = "safexcel-ecb-des3_ede",
1671 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1672 .cra_flags = CRYPTO_ALG_ASYNC |
1673 CRYPTO_ALG_ALLOCATES_MEMORY |
1674 CRYPTO_ALG_KERN_DRIVER_ONLY,
1675 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1676 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1677 .cra_alignmask = 0,
1678 .cra_init = safexcel_skcipher_des3_ecb_cra_init,
1679 .cra_exit = safexcel_skcipher_cra_exit,
1680 .cra_module = THIS_MODULE,
1681 },
1682 },
1683 };
1684
1685 static int safexcel_aead_encrypt(struct aead_request *req)
1686 {
1687 struct safexcel_cipher_req *creq = aead_request_ctx(req);
1688
1689 return safexcel_queue_req(&req->base, creq, SAFEXCEL_ENCRYPT);
1690 }
1691
1692 static int safexcel_aead_decrypt(struct aead_request *req)
1693 {
1694 struct safexcel_cipher_req *creq = aead_request_ctx(req);
1695
1696 return safexcel_queue_req(&req->base, creq, SAFEXCEL_DECRYPT);
1697 }
1698
1699 static int safexcel_aead_cra_init(struct crypto_tfm *tfm)
1700 {
1701 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1702 struct safexcel_alg_template *tmpl =
1703 container_of(tfm->__crt_alg, struct safexcel_alg_template,
1704 alg.aead.base);
1705
1706 crypto_aead_set_reqsize(__crypto_aead_cast(tfm),
1707 sizeof(struct safexcel_cipher_req));
1708
1709 ctx->base.priv = tmpl->priv;
1710
1711 ctx->alg = SAFEXCEL_AES; /* default */
1712 ctx->blocksz = AES_BLOCK_SIZE;
1713 ctx->ivmask = EIP197_OPTION_4_TOKEN_IV_CMD;
1714 ctx->ctrinit = 1;
1715 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CBC; /* default */
1716 ctx->aead = true;
1717 ctx->base.send = safexcel_aead_send;
1718 ctx->base.handle_result = safexcel_aead_handle_result;
1719 return 0;
1720 }
1721
1722 static int safexcel_aead_sha1_cra_init(struct crypto_tfm *tfm)
1723 {
1724 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1725
1726 safexcel_aead_cra_init(tfm);
1727 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA1;
1728 ctx->state_sz = SHA1_DIGEST_SIZE;
1729 return 0;
1730 }
1731
1732 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_cbc_aes = {
1733 .type = SAFEXCEL_ALG_TYPE_AEAD,
1734 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA1,
1735 .alg.aead = {
1736 .setkey = safexcel_aead_setkey,
1737 .encrypt = safexcel_aead_encrypt,
1738 .decrypt = safexcel_aead_decrypt,
1739 .ivsize = AES_BLOCK_SIZE,
1740 .maxauthsize = SHA1_DIGEST_SIZE,
1741 .base = {
1742 .cra_name = "authenc(hmac(sha1),cbc(aes))",
1743 .cra_driver_name = "safexcel-authenc-hmac-sha1-cbc-aes",
1744 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1745 .cra_flags = CRYPTO_ALG_ASYNC |
1746 CRYPTO_ALG_ALLOCATES_MEMORY |
1747 CRYPTO_ALG_KERN_DRIVER_ONLY,
1748 .cra_blocksize = AES_BLOCK_SIZE,
1749 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1750 .cra_alignmask = 0,
1751 .cra_init = safexcel_aead_sha1_cra_init,
1752 .cra_exit = safexcel_aead_cra_exit,
1753 .cra_module = THIS_MODULE,
1754 },
1755 },
1756 };
1757
1758 static int safexcel_aead_sha256_cra_init(struct crypto_tfm *tfm)
1759 {
1760 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1761
1762 safexcel_aead_cra_init(tfm);
1763 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA256;
1764 ctx->state_sz = SHA256_DIGEST_SIZE;
1765 return 0;
1766 }
1767
1768 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha256_cbc_aes = {
1769 .type = SAFEXCEL_ALG_TYPE_AEAD,
1770 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_256,
1771 .alg.aead = {
1772 .setkey = safexcel_aead_setkey,
1773 .encrypt = safexcel_aead_encrypt,
1774 .decrypt = safexcel_aead_decrypt,
1775 .ivsize = AES_BLOCK_SIZE,
1776 .maxauthsize = SHA256_DIGEST_SIZE,
1777 .base = {
1778 .cra_name = "authenc(hmac(sha256),cbc(aes))",
1779 .cra_driver_name = "safexcel-authenc-hmac-sha256-cbc-aes",
1780 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1781 .cra_flags = CRYPTO_ALG_ASYNC |
1782 CRYPTO_ALG_ALLOCATES_MEMORY |
1783 CRYPTO_ALG_KERN_DRIVER_ONLY,
1784 .cra_blocksize = AES_BLOCK_SIZE,
1785 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1786 .cra_alignmask = 0,
1787 .cra_init = safexcel_aead_sha256_cra_init,
1788 .cra_exit = safexcel_aead_cra_exit,
1789 .cra_module = THIS_MODULE,
1790 },
1791 },
1792 };
1793
1794 static int safexcel_aead_sha224_cra_init(struct crypto_tfm *tfm)
1795 {
1796 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1797
1798 safexcel_aead_cra_init(tfm);
1799 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA224;
1800 ctx->state_sz = SHA256_DIGEST_SIZE;
1801 return 0;
1802 }
1803
1804 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha224_cbc_aes = {
1805 .type = SAFEXCEL_ALG_TYPE_AEAD,
1806 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_256,
1807 .alg.aead = {
1808 .setkey = safexcel_aead_setkey,
1809 .encrypt = safexcel_aead_encrypt,
1810 .decrypt = safexcel_aead_decrypt,
1811 .ivsize = AES_BLOCK_SIZE,
1812 .maxauthsize = SHA224_DIGEST_SIZE,
1813 .base = {
1814 .cra_name = "authenc(hmac(sha224),cbc(aes))",
1815 .cra_driver_name = "safexcel-authenc-hmac-sha224-cbc-aes",
1816 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1817 .cra_flags = CRYPTO_ALG_ASYNC |
1818 CRYPTO_ALG_ALLOCATES_MEMORY |
1819 CRYPTO_ALG_KERN_DRIVER_ONLY,
1820 .cra_blocksize = AES_BLOCK_SIZE,
1821 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1822 .cra_alignmask = 0,
1823 .cra_init = safexcel_aead_sha224_cra_init,
1824 .cra_exit = safexcel_aead_cra_exit,
1825 .cra_module = THIS_MODULE,
1826 },
1827 },
1828 };
1829
1830 static int safexcel_aead_sha512_cra_init(struct crypto_tfm *tfm)
1831 {
1832 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1833
1834 safexcel_aead_cra_init(tfm);
1835 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA512;
1836 ctx->state_sz = SHA512_DIGEST_SIZE;
1837 return 0;
1838 }
1839
1840 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha512_cbc_aes = {
1841 .type = SAFEXCEL_ALG_TYPE_AEAD,
1842 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_512,
1843 .alg.aead = {
1844 .setkey = safexcel_aead_setkey,
1845 .encrypt = safexcel_aead_encrypt,
1846 .decrypt = safexcel_aead_decrypt,
1847 .ivsize = AES_BLOCK_SIZE,
1848 .maxauthsize = SHA512_DIGEST_SIZE,
1849 .base = {
1850 .cra_name = "authenc(hmac(sha512),cbc(aes))",
1851 .cra_driver_name = "safexcel-authenc-hmac-sha512-cbc-aes",
1852 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1853 .cra_flags = CRYPTO_ALG_ASYNC |
1854 CRYPTO_ALG_ALLOCATES_MEMORY |
1855 CRYPTO_ALG_KERN_DRIVER_ONLY,
1856 .cra_blocksize = AES_BLOCK_SIZE,
1857 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1858 .cra_alignmask = 0,
1859 .cra_init = safexcel_aead_sha512_cra_init,
1860 .cra_exit = safexcel_aead_cra_exit,
1861 .cra_module = THIS_MODULE,
1862 },
1863 },
1864 };
1865
1866 static int safexcel_aead_sha384_cra_init(struct crypto_tfm *tfm)
1867 {
1868 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1869
1870 safexcel_aead_cra_init(tfm);
1871 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA384;
1872 ctx->state_sz = SHA512_DIGEST_SIZE;
1873 return 0;
1874 }
1875
1876 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha384_cbc_aes = {
1877 .type = SAFEXCEL_ALG_TYPE_AEAD,
1878 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_512,
1879 .alg.aead = {
1880 .setkey = safexcel_aead_setkey,
1881 .encrypt = safexcel_aead_encrypt,
1882 .decrypt = safexcel_aead_decrypt,
1883 .ivsize = AES_BLOCK_SIZE,
1884 .maxauthsize = SHA384_DIGEST_SIZE,
1885 .base = {
1886 .cra_name = "authenc(hmac(sha384),cbc(aes))",
1887 .cra_driver_name = "safexcel-authenc-hmac-sha384-cbc-aes",
1888 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1889 .cra_flags = CRYPTO_ALG_ASYNC |
1890 CRYPTO_ALG_ALLOCATES_MEMORY |
1891 CRYPTO_ALG_KERN_DRIVER_ONLY,
1892 .cra_blocksize = AES_BLOCK_SIZE,
1893 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1894 .cra_alignmask = 0,
1895 .cra_init = safexcel_aead_sha384_cra_init,
1896 .cra_exit = safexcel_aead_cra_exit,
1897 .cra_module = THIS_MODULE,
1898 },
1899 },
1900 };
1901
1902 static int safexcel_aead_sha1_des3_cra_init(struct crypto_tfm *tfm)
1903 {
1904 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1905
1906 safexcel_aead_sha1_cra_init(tfm);
1907 ctx->alg = SAFEXCEL_3DES; /* override default */
1908 ctx->blocksz = DES3_EDE_BLOCK_SIZE;
1909 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
1910 return 0;
1911 }
1912
1913 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_cbc_des3_ede = {
1914 .type = SAFEXCEL_ALG_TYPE_AEAD,
1915 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA1,
1916 .alg.aead = {
1917 .setkey = safexcel_aead_setkey,
1918 .encrypt = safexcel_aead_encrypt,
1919 .decrypt = safexcel_aead_decrypt,
1920 .ivsize = DES3_EDE_BLOCK_SIZE,
1921 .maxauthsize = SHA1_DIGEST_SIZE,
1922 .base = {
1923 .cra_name = "authenc(hmac(sha1),cbc(des3_ede))",
1924 .cra_driver_name = "safexcel-authenc-hmac-sha1-cbc-des3_ede",
1925 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1926 .cra_flags = CRYPTO_ALG_ASYNC |
1927 CRYPTO_ALG_ALLOCATES_MEMORY |
1928 CRYPTO_ALG_KERN_DRIVER_ONLY,
1929 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1930 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1931 .cra_alignmask = 0,
1932 .cra_init = safexcel_aead_sha1_des3_cra_init,
1933 .cra_exit = safexcel_aead_cra_exit,
1934 .cra_module = THIS_MODULE,
1935 },
1936 },
1937 };
1938
1939 static int safexcel_aead_sha256_des3_cra_init(struct crypto_tfm *tfm)
1940 {
1941 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1942
1943 safexcel_aead_sha256_cra_init(tfm);
1944 ctx->alg = SAFEXCEL_3DES; /* override default */
1945 ctx->blocksz = DES3_EDE_BLOCK_SIZE;
1946 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
1947 return 0;
1948 }
1949
1950 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha256_cbc_des3_ede = {
1951 .type = SAFEXCEL_ALG_TYPE_AEAD,
1952 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_256,
1953 .alg.aead = {
1954 .setkey = safexcel_aead_setkey,
1955 .encrypt = safexcel_aead_encrypt,
1956 .decrypt = safexcel_aead_decrypt,
1957 .ivsize = DES3_EDE_BLOCK_SIZE,
1958 .maxauthsize = SHA256_DIGEST_SIZE,
1959 .base = {
1960 .cra_name = "authenc(hmac(sha256),cbc(des3_ede))",
1961 .cra_driver_name = "safexcel-authenc-hmac-sha256-cbc-des3_ede",
1962 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1963 .cra_flags = CRYPTO_ALG_ASYNC |
1964 CRYPTO_ALG_ALLOCATES_MEMORY |
1965 CRYPTO_ALG_KERN_DRIVER_ONLY,
1966 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1967 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1968 .cra_alignmask = 0,
1969 .cra_init = safexcel_aead_sha256_des3_cra_init,
1970 .cra_exit = safexcel_aead_cra_exit,
1971 .cra_module = THIS_MODULE,
1972 },
1973 },
1974 };
1975
1976 static int safexcel_aead_sha224_des3_cra_init(struct crypto_tfm *tfm)
1977 {
1978 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1979
1980 safexcel_aead_sha224_cra_init(tfm);
1981 ctx->alg = SAFEXCEL_3DES; /* override default */
1982 ctx->blocksz = DES3_EDE_BLOCK_SIZE;
1983 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
1984 return 0;
1985 }
1986
1987 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha224_cbc_des3_ede = {
1988 .type = SAFEXCEL_ALG_TYPE_AEAD,
1989 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_256,
1990 .alg.aead = {
1991 .setkey = safexcel_aead_setkey,
1992 .encrypt = safexcel_aead_encrypt,
1993 .decrypt = safexcel_aead_decrypt,
1994 .ivsize = DES3_EDE_BLOCK_SIZE,
1995 .maxauthsize = SHA224_DIGEST_SIZE,
1996 .base = {
1997 .cra_name = "authenc(hmac(sha224),cbc(des3_ede))",
1998 .cra_driver_name = "safexcel-authenc-hmac-sha224-cbc-des3_ede",
1999 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2000 .cra_flags = CRYPTO_ALG_ASYNC |
2001 CRYPTO_ALG_ALLOCATES_MEMORY |
2002 CRYPTO_ALG_KERN_DRIVER_ONLY,
2003 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
2004 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2005 .cra_alignmask = 0,
2006 .cra_init = safexcel_aead_sha224_des3_cra_init,
2007 .cra_exit = safexcel_aead_cra_exit,
2008 .cra_module = THIS_MODULE,
2009 },
2010 },
2011 };
2012
2013 static int safexcel_aead_sha512_des3_cra_init(struct crypto_tfm *tfm)
2014 {
2015 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2016
2017 safexcel_aead_sha512_cra_init(tfm);
2018 ctx->alg = SAFEXCEL_3DES; /* override default */
2019 ctx->blocksz = DES3_EDE_BLOCK_SIZE;
2020 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
2021 return 0;
2022 }
2023
2024 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha512_cbc_des3_ede = {
2025 .type = SAFEXCEL_ALG_TYPE_AEAD,
2026 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_512,
2027 .alg.aead = {
2028 .setkey = safexcel_aead_setkey,
2029 .encrypt = safexcel_aead_encrypt,
2030 .decrypt = safexcel_aead_decrypt,
2031 .ivsize = DES3_EDE_BLOCK_SIZE,
2032 .maxauthsize = SHA512_DIGEST_SIZE,
2033 .base = {
2034 .cra_name = "authenc(hmac(sha512),cbc(des3_ede))",
2035 .cra_driver_name = "safexcel-authenc-hmac-sha512-cbc-des3_ede",
2036 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2037 .cra_flags = CRYPTO_ALG_ASYNC |
2038 CRYPTO_ALG_ALLOCATES_MEMORY |
2039 CRYPTO_ALG_KERN_DRIVER_ONLY,
2040 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
2041 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2042 .cra_alignmask = 0,
2043 .cra_init = safexcel_aead_sha512_des3_cra_init,
2044 .cra_exit = safexcel_aead_cra_exit,
2045 .cra_module = THIS_MODULE,
2046 },
2047 },
2048 };
2049
2050 static int safexcel_aead_sha384_des3_cra_init(struct crypto_tfm *tfm)
2051 {
2052 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2053
2054 safexcel_aead_sha384_cra_init(tfm);
2055 ctx->alg = SAFEXCEL_3DES; /* override default */
2056 ctx->blocksz = DES3_EDE_BLOCK_SIZE;
2057 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
2058 return 0;
2059 }
2060
2061 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha384_cbc_des3_ede = {
2062 .type = SAFEXCEL_ALG_TYPE_AEAD,
2063 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_512,
2064 .alg.aead = {
2065 .setkey = safexcel_aead_setkey,
2066 .encrypt = safexcel_aead_encrypt,
2067 .decrypt = safexcel_aead_decrypt,
2068 .ivsize = DES3_EDE_BLOCK_SIZE,
2069 .maxauthsize = SHA384_DIGEST_SIZE,
2070 .base = {
2071 .cra_name = "authenc(hmac(sha384),cbc(des3_ede))",
2072 .cra_driver_name = "safexcel-authenc-hmac-sha384-cbc-des3_ede",
2073 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2074 .cra_flags = CRYPTO_ALG_ASYNC |
2075 CRYPTO_ALG_ALLOCATES_MEMORY |
2076 CRYPTO_ALG_KERN_DRIVER_ONLY,
2077 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
2078 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2079 .cra_alignmask = 0,
2080 .cra_init = safexcel_aead_sha384_des3_cra_init,
2081 .cra_exit = safexcel_aead_cra_exit,
2082 .cra_module = THIS_MODULE,
2083 },
2084 },
2085 };
2086
2087 static int safexcel_aead_sha1_des_cra_init(struct crypto_tfm *tfm)
2088 {
2089 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2090
2091 safexcel_aead_sha1_cra_init(tfm);
2092 ctx->alg = SAFEXCEL_DES; /* override default */
2093 ctx->blocksz = DES_BLOCK_SIZE;
2094 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
2095 return 0;
2096 }
2097
2098 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_cbc_des = {
2099 .type = SAFEXCEL_ALG_TYPE_AEAD,
2100 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA1,
2101 .alg.aead = {
2102 .setkey = safexcel_aead_setkey,
2103 .encrypt = safexcel_aead_encrypt,
2104 .decrypt = safexcel_aead_decrypt,
2105 .ivsize = DES_BLOCK_SIZE,
2106 .maxauthsize = SHA1_DIGEST_SIZE,
2107 .base = {
2108 .cra_name = "authenc(hmac(sha1),cbc(des))",
2109 .cra_driver_name = "safexcel-authenc-hmac-sha1-cbc-des",
2110 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2111 .cra_flags = CRYPTO_ALG_ASYNC |
2112 CRYPTO_ALG_ALLOCATES_MEMORY |
2113 CRYPTO_ALG_KERN_DRIVER_ONLY,
2114 .cra_blocksize = DES_BLOCK_SIZE,
2115 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2116 .cra_alignmask = 0,
2117 .cra_init = safexcel_aead_sha1_des_cra_init,
2118 .cra_exit = safexcel_aead_cra_exit,
2119 .cra_module = THIS_MODULE,
2120 },
2121 },
2122 };
2123
2124 static int safexcel_aead_sha256_des_cra_init(struct crypto_tfm *tfm)
2125 {
2126 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2127
2128 safexcel_aead_sha256_cra_init(tfm);
2129 ctx->alg = SAFEXCEL_DES; /* override default */
2130 ctx->blocksz = DES_BLOCK_SIZE;
2131 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
2132 return 0;
2133 }
2134
2135 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha256_cbc_des = {
2136 .type = SAFEXCEL_ALG_TYPE_AEAD,
2137 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_256,
2138 .alg.aead = {
2139 .setkey = safexcel_aead_setkey,
2140 .encrypt = safexcel_aead_encrypt,
2141 .decrypt = safexcel_aead_decrypt,
2142 .ivsize = DES_BLOCK_SIZE,
2143 .maxauthsize = SHA256_DIGEST_SIZE,
2144 .base = {
2145 .cra_name = "authenc(hmac(sha256),cbc(des))",
2146 .cra_driver_name = "safexcel-authenc-hmac-sha256-cbc-des",
2147 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2148 .cra_flags = CRYPTO_ALG_ASYNC |
2149 CRYPTO_ALG_ALLOCATES_MEMORY |
2150 CRYPTO_ALG_KERN_DRIVER_ONLY,
2151 .cra_blocksize = DES_BLOCK_SIZE,
2152 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2153 .cra_alignmask = 0,
2154 .cra_init = safexcel_aead_sha256_des_cra_init,
2155 .cra_exit = safexcel_aead_cra_exit,
2156 .cra_module = THIS_MODULE,
2157 },
2158 },
2159 };
2160
2161 static int safexcel_aead_sha224_des_cra_init(struct crypto_tfm *tfm)
2162 {
2163 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2164
2165 safexcel_aead_sha224_cra_init(tfm);
2166 ctx->alg = SAFEXCEL_DES; /* override default */
2167 ctx->blocksz = DES_BLOCK_SIZE;
2168 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
2169 return 0;
2170 }
2171
2172 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha224_cbc_des = {
2173 .type = SAFEXCEL_ALG_TYPE_AEAD,
2174 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_256,
2175 .alg.aead = {
2176 .setkey = safexcel_aead_setkey,
2177 .encrypt = safexcel_aead_encrypt,
2178 .decrypt = safexcel_aead_decrypt,
2179 .ivsize = DES_BLOCK_SIZE,
2180 .maxauthsize = SHA224_DIGEST_SIZE,
2181 .base = {
2182 .cra_name = "authenc(hmac(sha224),cbc(des))",
2183 .cra_driver_name = "safexcel-authenc-hmac-sha224-cbc-des",
2184 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2185 .cra_flags = CRYPTO_ALG_ASYNC |
2186 CRYPTO_ALG_ALLOCATES_MEMORY |
2187 CRYPTO_ALG_KERN_DRIVER_ONLY,
2188 .cra_blocksize = DES_BLOCK_SIZE,
2189 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2190 .cra_alignmask = 0,
2191 .cra_init = safexcel_aead_sha224_des_cra_init,
2192 .cra_exit = safexcel_aead_cra_exit,
2193 .cra_module = THIS_MODULE,
2194 },
2195 },
2196 };
2197
2198 static int safexcel_aead_sha512_des_cra_init(struct crypto_tfm *tfm)
2199 {
2200 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2201
2202 safexcel_aead_sha512_cra_init(tfm);
2203 ctx->alg = SAFEXCEL_DES; /* override default */
2204 ctx->blocksz = DES_BLOCK_SIZE;
2205 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
2206 return 0;
2207 }
2208
2209 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha512_cbc_des = {
2210 .type = SAFEXCEL_ALG_TYPE_AEAD,
2211 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_512,
2212 .alg.aead = {
2213 .setkey = safexcel_aead_setkey,
2214 .encrypt = safexcel_aead_encrypt,
2215 .decrypt = safexcel_aead_decrypt,
2216 .ivsize = DES_BLOCK_SIZE,
2217 .maxauthsize = SHA512_DIGEST_SIZE,
2218 .base = {
2219 .cra_name = "authenc(hmac(sha512),cbc(des))",
2220 .cra_driver_name = "safexcel-authenc-hmac-sha512-cbc-des",
2221 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2222 .cra_flags = CRYPTO_ALG_ASYNC |
2223 CRYPTO_ALG_ALLOCATES_MEMORY |
2224 CRYPTO_ALG_KERN_DRIVER_ONLY,
2225 .cra_blocksize = DES_BLOCK_SIZE,
2226 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2227 .cra_alignmask = 0,
2228 .cra_init = safexcel_aead_sha512_des_cra_init,
2229 .cra_exit = safexcel_aead_cra_exit,
2230 .cra_module = THIS_MODULE,
2231 },
2232 },
2233 };
2234
2235 static int safexcel_aead_sha384_des_cra_init(struct crypto_tfm *tfm)
2236 {
2237 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2238
2239 safexcel_aead_sha384_cra_init(tfm);
2240 ctx->alg = SAFEXCEL_DES; /* override default */
2241 ctx->blocksz = DES_BLOCK_SIZE;
2242 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
2243 return 0;
2244 }
2245
2246 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha384_cbc_des = {
2247 .type = SAFEXCEL_ALG_TYPE_AEAD,
2248 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_512,
2249 .alg.aead = {
2250 .setkey = safexcel_aead_setkey,
2251 .encrypt = safexcel_aead_encrypt,
2252 .decrypt = safexcel_aead_decrypt,
2253 .ivsize = DES_BLOCK_SIZE,
2254 .maxauthsize = SHA384_DIGEST_SIZE,
2255 .base = {
2256 .cra_name = "authenc(hmac(sha384),cbc(des))",
2257 .cra_driver_name = "safexcel-authenc-hmac-sha384-cbc-des",
2258 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2259 .cra_flags = CRYPTO_ALG_ASYNC |
2260 CRYPTO_ALG_ALLOCATES_MEMORY |
2261 CRYPTO_ALG_KERN_DRIVER_ONLY,
2262 .cra_blocksize = DES_BLOCK_SIZE,
2263 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2264 .cra_alignmask = 0,
2265 .cra_init = safexcel_aead_sha384_des_cra_init,
2266 .cra_exit = safexcel_aead_cra_exit,
2267 .cra_module = THIS_MODULE,
2268 },
2269 },
2270 };
2271
2272 static int safexcel_aead_sha1_ctr_cra_init(struct crypto_tfm *tfm)
2273 {
2274 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2275
2276 safexcel_aead_sha1_cra_init(tfm);
2277 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD; /* override default */
2278 return 0;
2279 }
2280
2281 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_ctr_aes = {
2282 .type = SAFEXCEL_ALG_TYPE_AEAD,
2283 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA1,
2284 .alg.aead = {
2285 .setkey = safexcel_aead_setkey,
2286 .encrypt = safexcel_aead_encrypt,
2287 .decrypt = safexcel_aead_decrypt,
2288 .ivsize = CTR_RFC3686_IV_SIZE,
2289 .maxauthsize = SHA1_DIGEST_SIZE,
2290 .base = {
2291 .cra_name = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2292 .cra_driver_name = "safexcel-authenc-hmac-sha1-ctr-aes",
2293 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2294 .cra_flags = CRYPTO_ALG_ASYNC |
2295 CRYPTO_ALG_ALLOCATES_MEMORY |
2296 CRYPTO_ALG_KERN_DRIVER_ONLY,
2297 .cra_blocksize = 1,
2298 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2299 .cra_alignmask = 0,
2300 .cra_init = safexcel_aead_sha1_ctr_cra_init,
2301 .cra_exit = safexcel_aead_cra_exit,
2302 .cra_module = THIS_MODULE,
2303 },
2304 },
2305 };
2306
2307 static int safexcel_aead_sha256_ctr_cra_init(struct crypto_tfm *tfm)
2308 {
2309 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2310
2311 safexcel_aead_sha256_cra_init(tfm);
2312 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD; /* override default */
2313 return 0;
2314 }
2315
2316 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha256_ctr_aes = {
2317 .type = SAFEXCEL_ALG_TYPE_AEAD,
2318 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_256,
2319 .alg.aead = {
2320 .setkey = safexcel_aead_setkey,
2321 .encrypt = safexcel_aead_encrypt,
2322 .decrypt = safexcel_aead_decrypt,
2323 .ivsize = CTR_RFC3686_IV_SIZE,
2324 .maxauthsize = SHA256_DIGEST_SIZE,
2325 .base = {
2326 .cra_name = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2327 .cra_driver_name = "safexcel-authenc-hmac-sha256-ctr-aes",
2328 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2329 .cra_flags = CRYPTO_ALG_ASYNC |
2330 CRYPTO_ALG_ALLOCATES_MEMORY |
2331 CRYPTO_ALG_KERN_DRIVER_ONLY,
2332 .cra_blocksize = 1,
2333 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2334 .cra_alignmask = 0,
2335 .cra_init = safexcel_aead_sha256_ctr_cra_init,
2336 .cra_exit = safexcel_aead_cra_exit,
2337 .cra_module = THIS_MODULE,
2338 },
2339 },
2340 };
2341
2342 static int safexcel_aead_sha224_ctr_cra_init(struct crypto_tfm *tfm)
2343 {
2344 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2345
2346 safexcel_aead_sha224_cra_init(tfm);
2347 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD; /* override default */
2348 return 0;
2349 }
2350
2351 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha224_ctr_aes = {
2352 .type = SAFEXCEL_ALG_TYPE_AEAD,
2353 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_256,
2354 .alg.aead = {
2355 .setkey = safexcel_aead_setkey,
2356 .encrypt = safexcel_aead_encrypt,
2357 .decrypt = safexcel_aead_decrypt,
2358 .ivsize = CTR_RFC3686_IV_SIZE,
2359 .maxauthsize = SHA224_DIGEST_SIZE,
2360 .base = {
2361 .cra_name = "authenc(hmac(sha224),rfc3686(ctr(aes)))",
2362 .cra_driver_name = "safexcel-authenc-hmac-sha224-ctr-aes",
2363 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2364 .cra_flags = CRYPTO_ALG_ASYNC |
2365 CRYPTO_ALG_ALLOCATES_MEMORY |
2366 CRYPTO_ALG_KERN_DRIVER_ONLY,
2367 .cra_blocksize = 1,
2368 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2369 .cra_alignmask = 0,
2370 .cra_init = safexcel_aead_sha224_ctr_cra_init,
2371 .cra_exit = safexcel_aead_cra_exit,
2372 .cra_module = THIS_MODULE,
2373 },
2374 },
2375 };
2376
2377 static int safexcel_aead_sha512_ctr_cra_init(struct crypto_tfm *tfm)
2378 {
2379 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2380
2381 safexcel_aead_sha512_cra_init(tfm);
2382 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD; /* override default */
2383 return 0;
2384 }
2385
2386 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha512_ctr_aes = {
2387 .type = SAFEXCEL_ALG_TYPE_AEAD,
2388 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_512,
2389 .alg.aead = {
2390 .setkey = safexcel_aead_setkey,
2391 .encrypt = safexcel_aead_encrypt,
2392 .decrypt = safexcel_aead_decrypt,
2393 .ivsize = CTR_RFC3686_IV_SIZE,
2394 .maxauthsize = SHA512_DIGEST_SIZE,
2395 .base = {
2396 .cra_name = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2397 .cra_driver_name = "safexcel-authenc-hmac-sha512-ctr-aes",
2398 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2399 .cra_flags = CRYPTO_ALG_ASYNC |
2400 CRYPTO_ALG_ALLOCATES_MEMORY |
2401 CRYPTO_ALG_KERN_DRIVER_ONLY,
2402 .cra_blocksize = 1,
2403 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2404 .cra_alignmask = 0,
2405 .cra_init = safexcel_aead_sha512_ctr_cra_init,
2406 .cra_exit = safexcel_aead_cra_exit,
2407 .cra_module = THIS_MODULE,
2408 },
2409 },
2410 };
2411
2412 static int safexcel_aead_sha384_ctr_cra_init(struct crypto_tfm *tfm)
2413 {
2414 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2415
2416 safexcel_aead_sha384_cra_init(tfm);
2417 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD; /* override default */
2418 return 0;
2419 }
2420
2421 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha384_ctr_aes = {
2422 .type = SAFEXCEL_ALG_TYPE_AEAD,
2423 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_512,
2424 .alg.aead = {
2425 .setkey = safexcel_aead_setkey,
2426 .encrypt = safexcel_aead_encrypt,
2427 .decrypt = safexcel_aead_decrypt,
2428 .ivsize = CTR_RFC3686_IV_SIZE,
2429 .maxauthsize = SHA384_DIGEST_SIZE,
2430 .base = {
2431 .cra_name = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2432 .cra_driver_name = "safexcel-authenc-hmac-sha384-ctr-aes",
2433 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2434 .cra_flags = CRYPTO_ALG_ASYNC |
2435 CRYPTO_ALG_ALLOCATES_MEMORY |
2436 CRYPTO_ALG_KERN_DRIVER_ONLY,
2437 .cra_blocksize = 1,
2438 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2439 .cra_alignmask = 0,
2440 .cra_init = safexcel_aead_sha384_ctr_cra_init,
2441 .cra_exit = safexcel_aead_cra_exit,
2442 .cra_module = THIS_MODULE,
2443 },
2444 },
2445 };
2446
2447 static int safexcel_skcipher_aesxts_setkey(struct crypto_skcipher *ctfm,
2448 const u8 *key, unsigned int len)
2449 {
2450 struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
2451 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2452 struct safexcel_crypto_priv *priv = ctx->base.priv;
2453 struct crypto_aes_ctx aes;
2454 int ret, i;
2455 unsigned int keylen;
2456
2457 /* Check for illegal XTS keys */
2458 ret = xts_verify_key(ctfm, key, len);
2459 if (ret)
2460 return ret;
2461
2462 /* Only half of the key data is cipher key */
2463 keylen = (len >> 1);
2464 ret = aes_expandkey(&aes, key, keylen);
2465 if (ret)
2466 return ret;
2467
2468 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
2469 for (i = 0; i < keylen / sizeof(u32); i++) {
2470 if (le32_to_cpu(ctx->key[i]) != aes.key_enc[i]) {
2471 ctx->base.needs_inv = true;
2472 break;
2473 }
2474 }
2475 }
2476
2477 for (i = 0; i < keylen / sizeof(u32); i++)
2478 ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
2479
2480 /* The other half is the tweak key */
2481 ret = aes_expandkey(&aes, (u8 *)(key + keylen), keylen);
2482 if (ret)
2483 return ret;
2484
2485 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
2486 for (i = 0; i < keylen / sizeof(u32); i++) {
2487 if (le32_to_cpu(ctx->key[i + keylen / sizeof(u32)]) !=
2488 aes.key_enc[i]) {
2489 ctx->base.needs_inv = true;
2490 break;
2491 }
2492 }
2493 }
2494
2495 for (i = 0; i < keylen / sizeof(u32); i++)
2496 ctx->key[i + keylen / sizeof(u32)] =
2497 cpu_to_le32(aes.key_enc[i]);
2498
2499 ctx->key_len = keylen << 1;
2500
2501 memzero_explicit(&aes, sizeof(aes));
2502 return 0;
2503 }
2504
2505 static int safexcel_skcipher_aes_xts_cra_init(struct crypto_tfm *tfm)
2506 {
2507 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2508
2509 safexcel_skcipher_cra_init(tfm);
2510 ctx->alg = SAFEXCEL_AES;
2511 ctx->blocksz = AES_BLOCK_SIZE;
2512 ctx->xts = 1;
2513 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_XTS;
2514 return 0;
2515 }
2516
2517 static int safexcel_encrypt_xts(struct skcipher_request *req)
2518 {
2519 if (req->cryptlen < XTS_BLOCK_SIZE)
2520 return -EINVAL;
2521 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
2522 SAFEXCEL_ENCRYPT);
2523 }
2524
2525 static int safexcel_decrypt_xts(struct skcipher_request *req)
2526 {
2527 if (req->cryptlen < XTS_BLOCK_SIZE)
2528 return -EINVAL;
2529 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
2530 SAFEXCEL_DECRYPT);
2531 }
2532
2533 struct safexcel_alg_template safexcel_alg_xts_aes = {
2534 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
2535 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_AES_XTS,
2536 .alg.skcipher = {
2537 .setkey = safexcel_skcipher_aesxts_setkey,
2538 .encrypt = safexcel_encrypt_xts,
2539 .decrypt = safexcel_decrypt_xts,
2540 /* XTS actually uses 2 AES keys glued together */
2541 .min_keysize = AES_MIN_KEY_SIZE * 2,
2542 .max_keysize = AES_MAX_KEY_SIZE * 2,
2543 .ivsize = XTS_BLOCK_SIZE,
2544 .base = {
2545 .cra_name = "xts(aes)",
2546 .cra_driver_name = "safexcel-xts-aes",
2547 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2548 .cra_flags = CRYPTO_ALG_ASYNC |
2549 CRYPTO_ALG_ALLOCATES_MEMORY |
2550 CRYPTO_ALG_KERN_DRIVER_ONLY,
2551 .cra_blocksize = XTS_BLOCK_SIZE,
2552 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2553 .cra_alignmask = 0,
2554 .cra_init = safexcel_skcipher_aes_xts_cra_init,
2555 .cra_exit = safexcel_skcipher_cra_exit,
2556 .cra_module = THIS_MODULE,
2557 },
2558 },
2559 };
2560
2561 static int safexcel_aead_gcm_setkey(struct crypto_aead *ctfm, const u8 *key,
2562 unsigned int len)
2563 {
2564 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
2565 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2566 struct safexcel_crypto_priv *priv = ctx->base.priv;
2567 struct crypto_aes_ctx aes;
2568 u32 hashkey[AES_BLOCK_SIZE >> 2];
2569 int ret, i;
2570
2571 ret = aes_expandkey(&aes, key, len);
2572 if (ret) {
2573 memzero_explicit(&aes, sizeof(aes));
2574 return ret;
2575 }
2576
2577 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
2578 for (i = 0; i < len / sizeof(u32); i++) {
2579 if (le32_to_cpu(ctx->key[i]) != aes.key_enc[i]) {
2580 ctx->base.needs_inv = true;
2581 break;
2582 }
2583 }
2584 }
2585
2586 for (i = 0; i < len / sizeof(u32); i++)
2587 ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
2588
2589 ctx->key_len = len;
2590
2591 /* Compute hash key by encrypting zeroes with cipher key */
2592 crypto_cipher_clear_flags(ctx->hkaes, CRYPTO_TFM_REQ_MASK);
2593 crypto_cipher_set_flags(ctx->hkaes, crypto_aead_get_flags(ctfm) &
2594 CRYPTO_TFM_REQ_MASK);
2595 ret = crypto_cipher_setkey(ctx->hkaes, key, len);
2596 if (ret)
2597 return ret;
2598
2599 memset(hashkey, 0, AES_BLOCK_SIZE);
2600 crypto_cipher_encrypt_one(ctx->hkaes, (u8 *)hashkey, (u8 *)hashkey);
2601
2602 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
2603 for (i = 0; i < AES_BLOCK_SIZE / sizeof(u32); i++) {
2604 if (be32_to_cpu(ctx->base.ipad.be[i]) != hashkey[i]) {
2605 ctx->base.needs_inv = true;
2606 break;
2607 }
2608 }
2609 }
2610
2611 for (i = 0; i < AES_BLOCK_SIZE / sizeof(u32); i++)
2612 ctx->base.ipad.be[i] = cpu_to_be32(hashkey[i]);
2613
2614 memzero_explicit(hashkey, AES_BLOCK_SIZE);
2615 memzero_explicit(&aes, sizeof(aes));
2616 return 0;
2617 }
2618
2619 static int safexcel_aead_gcm_cra_init(struct crypto_tfm *tfm)
2620 {
2621 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2622
2623 safexcel_aead_cra_init(tfm);
2624 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_GHASH;
2625 ctx->state_sz = GHASH_BLOCK_SIZE;
2626 ctx->xcm = EIP197_XCM_MODE_GCM;
2627 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_XCM; /* override default */
2628
2629 ctx->hkaes = crypto_alloc_cipher("aes", 0, 0);
2630 return PTR_ERR_OR_ZERO(ctx->hkaes);
2631 }
2632
2633 static void safexcel_aead_gcm_cra_exit(struct crypto_tfm *tfm)
2634 {
2635 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2636
2637 crypto_free_cipher(ctx->hkaes);
2638 safexcel_aead_cra_exit(tfm);
2639 }
2640
2641 static int safexcel_aead_gcm_setauthsize(struct crypto_aead *tfm,
2642 unsigned int authsize)
2643 {
2644 return crypto_gcm_check_authsize(authsize);
2645 }
2646
2647 struct safexcel_alg_template safexcel_alg_gcm = {
2648 .type = SAFEXCEL_ALG_TYPE_AEAD,
2649 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_GHASH,
2650 .alg.aead = {
2651 .setkey = safexcel_aead_gcm_setkey,
2652 .setauthsize = safexcel_aead_gcm_setauthsize,
2653 .encrypt = safexcel_aead_encrypt,
2654 .decrypt = safexcel_aead_decrypt,
2655 .ivsize = GCM_AES_IV_SIZE,
2656 .maxauthsize = GHASH_DIGEST_SIZE,
2657 .base = {
2658 .cra_name = "gcm(aes)",
2659 .cra_driver_name = "safexcel-gcm-aes",
2660 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2661 .cra_flags = CRYPTO_ALG_ASYNC |
2662 CRYPTO_ALG_ALLOCATES_MEMORY |
2663 CRYPTO_ALG_KERN_DRIVER_ONLY,
2664 .cra_blocksize = 1,
2665 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2666 .cra_alignmask = 0,
2667 .cra_init = safexcel_aead_gcm_cra_init,
2668 .cra_exit = safexcel_aead_gcm_cra_exit,
2669 .cra_module = THIS_MODULE,
2670 },
2671 },
2672 };
2673
2674 static int safexcel_aead_ccm_setkey(struct crypto_aead *ctfm, const u8 *key,
2675 unsigned int len)
2676 {
2677 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
2678 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2679 struct safexcel_crypto_priv *priv = ctx->base.priv;
2680 struct crypto_aes_ctx aes;
2681 int ret, i;
2682
2683 ret = aes_expandkey(&aes, key, len);
2684 if (ret) {
2685 memzero_explicit(&aes, sizeof(aes));
2686 return ret;
2687 }
2688
2689 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
2690 for (i = 0; i < len / sizeof(u32); i++) {
2691 if (le32_to_cpu(ctx->key[i]) != aes.key_enc[i]) {
2692 ctx->base.needs_inv = true;
2693 break;
2694 }
2695 }
2696 }
2697
2698 for (i = 0; i < len / sizeof(u32); i++) {
2699 ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
2700 ctx->base.ipad.be[i + 2 * AES_BLOCK_SIZE / sizeof(u32)] =
2701 cpu_to_be32(aes.key_enc[i]);
2702 }
2703
2704 ctx->key_len = len;
2705 ctx->state_sz = 2 * AES_BLOCK_SIZE + len;
2706
2707 if (len == AES_KEYSIZE_192)
2708 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_XCBC192;
2709 else if (len == AES_KEYSIZE_256)
2710 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_XCBC256;
2711 else
2712 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_XCBC128;
2713
2714 memzero_explicit(&aes, sizeof(aes));
2715 return 0;
2716 }
2717
2718 static int safexcel_aead_ccm_cra_init(struct crypto_tfm *tfm)
2719 {
2720 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2721
2722 safexcel_aead_cra_init(tfm);
2723 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_XCBC128;
2724 ctx->state_sz = 3 * AES_BLOCK_SIZE;
2725 ctx->xcm = EIP197_XCM_MODE_CCM;
2726 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_XCM; /* override default */
2727 ctx->ctrinit = 0;
2728 return 0;
2729 }
2730
2731 static int safexcel_aead_ccm_setauthsize(struct crypto_aead *tfm,
2732 unsigned int authsize)
2733 {
2734 /* Borrowed from crypto/ccm.c */
2735 switch (authsize) {
2736 case 4:
2737 case 6:
2738 case 8:
2739 case 10:
2740 case 12:
2741 case 14:
2742 case 16:
2743 break;
2744 default:
2745 return -EINVAL;
2746 }
2747
2748 return 0;
2749 }
2750
2751 static int safexcel_ccm_encrypt(struct aead_request *req)
2752 {
2753 struct safexcel_cipher_req *creq = aead_request_ctx(req);
2754
2755 if (req->iv[0] < 1 || req->iv[0] > 7)
2756 return -EINVAL;
2757
2758 return safexcel_queue_req(&req->base, creq, SAFEXCEL_ENCRYPT);
2759 }
2760
2761 static int safexcel_ccm_decrypt(struct aead_request *req)
2762 {
2763 struct safexcel_cipher_req *creq = aead_request_ctx(req);
2764
2765 if (req->iv[0] < 1 || req->iv[0] > 7)
2766 return -EINVAL;
2767
2768 return safexcel_queue_req(&req->base, creq, SAFEXCEL_DECRYPT);
2769 }
2770
2771 struct safexcel_alg_template safexcel_alg_ccm = {
2772 .type = SAFEXCEL_ALG_TYPE_AEAD,
2773 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_CBC_MAC_ALL,
2774 .alg.aead = {
2775 .setkey = safexcel_aead_ccm_setkey,
2776 .setauthsize = safexcel_aead_ccm_setauthsize,
2777 .encrypt = safexcel_ccm_encrypt,
2778 .decrypt = safexcel_ccm_decrypt,
2779 .ivsize = AES_BLOCK_SIZE,
2780 .maxauthsize = AES_BLOCK_SIZE,
2781 .base = {
2782 .cra_name = "ccm(aes)",
2783 .cra_driver_name = "safexcel-ccm-aes",
2784 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2785 .cra_flags = CRYPTO_ALG_ASYNC |
2786 CRYPTO_ALG_ALLOCATES_MEMORY |
2787 CRYPTO_ALG_KERN_DRIVER_ONLY,
2788 .cra_blocksize = 1,
2789 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2790 .cra_alignmask = 0,
2791 .cra_init = safexcel_aead_ccm_cra_init,
2792 .cra_exit = safexcel_aead_cra_exit,
2793 .cra_module = THIS_MODULE,
2794 },
2795 },
2796 };
2797
2798 static void safexcel_chacha20_setkey(struct safexcel_cipher_ctx *ctx,
2799 const u8 *key)
2800 {
2801 struct safexcel_crypto_priv *priv = ctx->base.priv;
2802
2803 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma)
2804 if (memcmp(ctx->key, key, CHACHA_KEY_SIZE))
2805 ctx->base.needs_inv = true;
2806
2807 memcpy(ctx->key, key, CHACHA_KEY_SIZE);
2808 ctx->key_len = CHACHA_KEY_SIZE;
2809 }
2810
2811 static int safexcel_skcipher_chacha20_setkey(struct crypto_skcipher *ctfm,
2812 const u8 *key, unsigned int len)
2813 {
2814 struct safexcel_cipher_ctx *ctx = crypto_skcipher_ctx(ctfm);
2815
2816 if (len != CHACHA_KEY_SIZE)
2817 return -EINVAL;
2818
2819 safexcel_chacha20_setkey(ctx, key);
2820
2821 return 0;
2822 }
2823
2824 static int safexcel_skcipher_chacha20_cra_init(struct crypto_tfm *tfm)
2825 {
2826 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2827
2828 safexcel_skcipher_cra_init(tfm);
2829 ctx->alg = SAFEXCEL_CHACHA20;
2830 ctx->ctrinit = 0;
2831 ctx->mode = CONTEXT_CONTROL_CHACHA20_MODE_256_32;
2832 return 0;
2833 }
2834
2835 struct safexcel_alg_template safexcel_alg_chacha20 = {
2836 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
2837 .algo_mask = SAFEXCEL_ALG_CHACHA20,
2838 .alg.skcipher = {
2839 .setkey = safexcel_skcipher_chacha20_setkey,
2840 .encrypt = safexcel_encrypt,
2841 .decrypt = safexcel_decrypt,
2842 .min_keysize = CHACHA_KEY_SIZE,
2843 .max_keysize = CHACHA_KEY_SIZE,
2844 .ivsize = CHACHA_IV_SIZE,
2845 .base = {
2846 .cra_name = "chacha20",
2847 .cra_driver_name = "safexcel-chacha20",
2848 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2849 .cra_flags = CRYPTO_ALG_ASYNC |
2850 CRYPTO_ALG_ALLOCATES_MEMORY |
2851 CRYPTO_ALG_KERN_DRIVER_ONLY,
2852 .cra_blocksize = 1,
2853 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2854 .cra_alignmask = 0,
2855 .cra_init = safexcel_skcipher_chacha20_cra_init,
2856 .cra_exit = safexcel_skcipher_cra_exit,
2857 .cra_module = THIS_MODULE,
2858 },
2859 },
2860 };
2861
2862 static int safexcel_aead_chachapoly_setkey(struct crypto_aead *ctfm,
2863 const u8 *key, unsigned int len)
2864 {
2865 struct safexcel_cipher_ctx *ctx = crypto_aead_ctx(ctfm);
2866
2867 if (ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP &&
2868 len > EIP197_AEAD_IPSEC_NONCE_SIZE) {
2869 /* ESP variant has nonce appended to key */
2870 len -= EIP197_AEAD_IPSEC_NONCE_SIZE;
2871 ctx->nonce = *(u32 *)(key + len);
2872 }
2873 if (len != CHACHA_KEY_SIZE)
2874 return -EINVAL;
2875
2876 safexcel_chacha20_setkey(ctx, key);
2877
2878 return 0;
2879 }
2880
2881 static int safexcel_aead_chachapoly_setauthsize(struct crypto_aead *tfm,
2882 unsigned int authsize)
2883 {
2884 if (authsize != POLY1305_DIGEST_SIZE)
2885 return -EINVAL;
2886 return 0;
2887 }
2888
2889 static int safexcel_aead_chachapoly_crypt(struct aead_request *req,
2890 enum safexcel_cipher_direction dir)
2891 {
2892 struct safexcel_cipher_req *creq = aead_request_ctx(req);
2893 struct crypto_aead *aead = crypto_aead_reqtfm(req);
2894 struct crypto_tfm *tfm = crypto_aead_tfm(aead);
2895 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2896 struct aead_request *subreq = aead_request_ctx(req);
2897 u32 key[CHACHA_KEY_SIZE / sizeof(u32) + 1];
2898 int ret = 0;
2899
2900 /*
2901 * Instead of wasting time detecting umpteen silly corner cases,
2902 * just dump all "small" requests to the fallback implementation.
2903 * HW would not be faster on such small requests anyway.
2904 */
2905 if (likely((ctx->aead != EIP197_AEAD_TYPE_IPSEC_ESP ||
2906 req->assoclen >= EIP197_AEAD_IPSEC_IV_SIZE) &&
2907 req->cryptlen > POLY1305_DIGEST_SIZE)) {
2908 return safexcel_queue_req(&req->base, creq, dir);
2909 }
2910
2911 /* HW cannot do full (AAD+payload) zero length, use fallback */
2912 memcpy(key, ctx->key, CHACHA_KEY_SIZE);
2913 if (ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP) {
2914 /* ESP variant has nonce appended to the key */
2915 key[CHACHA_KEY_SIZE / sizeof(u32)] = ctx->nonce;
2916 ret = crypto_aead_setkey(ctx->fback, (u8 *)key,
2917 CHACHA_KEY_SIZE +
2918 EIP197_AEAD_IPSEC_NONCE_SIZE);
2919 } else {
2920 ret = crypto_aead_setkey(ctx->fback, (u8 *)key,
2921 CHACHA_KEY_SIZE);
2922 }
2923 if (ret) {
2924 crypto_aead_clear_flags(aead, CRYPTO_TFM_REQ_MASK);
2925 crypto_aead_set_flags(aead, crypto_aead_get_flags(ctx->fback) &
2926 CRYPTO_TFM_REQ_MASK);
2927 return ret;
2928 }
2929
2930 aead_request_set_tfm(subreq, ctx->fback);
2931 aead_request_set_callback(subreq, req->base.flags, req->base.complete,
2932 req->base.data);
2933 aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
2934 req->iv);
2935 aead_request_set_ad(subreq, req->assoclen);
2936
2937 return (dir == SAFEXCEL_ENCRYPT) ?
2938 crypto_aead_encrypt(subreq) :
2939 crypto_aead_decrypt(subreq);
2940 }
2941
2942 static int safexcel_aead_chachapoly_encrypt(struct aead_request *req)
2943 {
2944 return safexcel_aead_chachapoly_crypt(req, SAFEXCEL_ENCRYPT);
2945 }
2946
2947 static int safexcel_aead_chachapoly_decrypt(struct aead_request *req)
2948 {
2949 return safexcel_aead_chachapoly_crypt(req, SAFEXCEL_DECRYPT);
2950 }
2951
2952 static int safexcel_aead_fallback_cra_init(struct crypto_tfm *tfm)
2953 {
2954 struct crypto_aead *aead = __crypto_aead_cast(tfm);
2955 struct aead_alg *alg = crypto_aead_alg(aead);
2956 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2957
2958 safexcel_aead_cra_init(tfm);
2959
2960 /* Allocate fallback implementation */
2961 ctx->fback = crypto_alloc_aead(alg->base.cra_name, 0,
2962 CRYPTO_ALG_ASYNC |
2963 CRYPTO_ALG_NEED_FALLBACK);
2964 if (IS_ERR(ctx->fback))
2965 return PTR_ERR(ctx->fback);
2966
2967 crypto_aead_set_reqsize(aead, max(sizeof(struct safexcel_cipher_req),
2968 sizeof(struct aead_request) +
2969 crypto_aead_reqsize(ctx->fback)));
2970
2971 return 0;
2972 }
2973
2974 static int safexcel_aead_chachapoly_cra_init(struct crypto_tfm *tfm)
2975 {
2976 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2977
2978 safexcel_aead_fallback_cra_init(tfm);
2979 ctx->alg = SAFEXCEL_CHACHA20;
2980 ctx->mode = CONTEXT_CONTROL_CHACHA20_MODE_256_32 |
2981 CONTEXT_CONTROL_CHACHA20_MODE_CALC_OTK;
2982 ctx->ctrinit = 0;
2983 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_POLY1305;
2984 ctx->state_sz = 0; /* Precomputed by HW */
2985 return 0;
2986 }
2987
2988 static void safexcel_aead_fallback_cra_exit(struct crypto_tfm *tfm)
2989 {
2990 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2991
2992 crypto_free_aead(ctx->fback);
2993 safexcel_aead_cra_exit(tfm);
2994 }
2995
2996 struct safexcel_alg_template safexcel_alg_chachapoly = {
2997 .type = SAFEXCEL_ALG_TYPE_AEAD,
2998 .algo_mask = SAFEXCEL_ALG_CHACHA20 | SAFEXCEL_ALG_POLY1305,
2999 .alg.aead = {
3000 .setkey = safexcel_aead_chachapoly_setkey,
3001 .setauthsize = safexcel_aead_chachapoly_setauthsize,
3002 .encrypt = safexcel_aead_chachapoly_encrypt,
3003 .decrypt = safexcel_aead_chachapoly_decrypt,
3004 .ivsize = CHACHAPOLY_IV_SIZE,
3005 .maxauthsize = POLY1305_DIGEST_SIZE,
3006 .base = {
3007 .cra_name = "rfc7539(chacha20,poly1305)",
3008 .cra_driver_name = "safexcel-chacha20-poly1305",
3009 /* +1 to put it above HW chacha + SW poly */
3010 .cra_priority = SAFEXCEL_CRA_PRIORITY + 1,
3011 .cra_flags = CRYPTO_ALG_ASYNC |
3012 CRYPTO_ALG_ALLOCATES_MEMORY |
3013 CRYPTO_ALG_KERN_DRIVER_ONLY |
3014 CRYPTO_ALG_NEED_FALLBACK,
3015 .cra_blocksize = 1,
3016 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3017 .cra_alignmask = 0,
3018 .cra_init = safexcel_aead_chachapoly_cra_init,
3019 .cra_exit = safexcel_aead_fallback_cra_exit,
3020 .cra_module = THIS_MODULE,
3021 },
3022 },
3023 };
3024
3025 static int safexcel_aead_chachapolyesp_cra_init(struct crypto_tfm *tfm)
3026 {
3027 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3028 int ret;
3029
3030 ret = safexcel_aead_chachapoly_cra_init(tfm);
3031 ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP;
3032 ctx->aadskip = EIP197_AEAD_IPSEC_IV_SIZE;
3033 return ret;
3034 }
3035
3036 struct safexcel_alg_template safexcel_alg_chachapoly_esp = {
3037 .type = SAFEXCEL_ALG_TYPE_AEAD,
3038 .algo_mask = SAFEXCEL_ALG_CHACHA20 | SAFEXCEL_ALG_POLY1305,
3039 .alg.aead = {
3040 .setkey = safexcel_aead_chachapoly_setkey,
3041 .setauthsize = safexcel_aead_chachapoly_setauthsize,
3042 .encrypt = safexcel_aead_chachapoly_encrypt,
3043 .decrypt = safexcel_aead_chachapoly_decrypt,
3044 .ivsize = CHACHAPOLY_IV_SIZE - EIP197_AEAD_IPSEC_NONCE_SIZE,
3045 .maxauthsize = POLY1305_DIGEST_SIZE,
3046 .base = {
3047 .cra_name = "rfc7539esp(chacha20,poly1305)",
3048 .cra_driver_name = "safexcel-chacha20-poly1305-esp",
3049 /* +1 to put it above HW chacha + SW poly */
3050 .cra_priority = SAFEXCEL_CRA_PRIORITY + 1,
3051 .cra_flags = CRYPTO_ALG_ASYNC |
3052 CRYPTO_ALG_ALLOCATES_MEMORY |
3053 CRYPTO_ALG_KERN_DRIVER_ONLY |
3054 CRYPTO_ALG_NEED_FALLBACK,
3055 .cra_blocksize = 1,
3056 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3057 .cra_alignmask = 0,
3058 .cra_init = safexcel_aead_chachapolyesp_cra_init,
3059 .cra_exit = safexcel_aead_fallback_cra_exit,
3060 .cra_module = THIS_MODULE,
3061 },
3062 },
3063 };
3064
3065 static int safexcel_skcipher_sm4_setkey(struct crypto_skcipher *ctfm,
3066 const u8 *key, unsigned int len)
3067 {
3068 struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
3069 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3070 struct safexcel_crypto_priv *priv = ctx->base.priv;
3071
3072 if (len != SM4_KEY_SIZE)
3073 return -EINVAL;
3074
3075 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma)
3076 if (memcmp(ctx->key, key, SM4_KEY_SIZE))
3077 ctx->base.needs_inv = true;
3078
3079 memcpy(ctx->key, key, SM4_KEY_SIZE);
3080 ctx->key_len = SM4_KEY_SIZE;
3081
3082 return 0;
3083 }
3084
3085 static int safexcel_sm4_blk_encrypt(struct skcipher_request *req)
3086 {
3087 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3088 if (req->cryptlen & (SM4_BLOCK_SIZE - 1))
3089 return -EINVAL;
3090 else
3091 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
3092 SAFEXCEL_ENCRYPT);
3093 }
3094
3095 static int safexcel_sm4_blk_decrypt(struct skcipher_request *req)
3096 {
3097 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3098 if (req->cryptlen & (SM4_BLOCK_SIZE - 1))
3099 return -EINVAL;
3100 else
3101 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
3102 SAFEXCEL_DECRYPT);
3103 }
3104
3105 static int safexcel_skcipher_sm4_ecb_cra_init(struct crypto_tfm *tfm)
3106 {
3107 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3108
3109 safexcel_skcipher_cra_init(tfm);
3110 ctx->alg = SAFEXCEL_SM4;
3111 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_ECB;
3112 ctx->blocksz = 0;
3113 ctx->ivmask = EIP197_OPTION_2_TOKEN_IV_CMD;
3114 return 0;
3115 }
3116
3117 struct safexcel_alg_template safexcel_alg_ecb_sm4 = {
3118 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
3119 .algo_mask = SAFEXCEL_ALG_SM4,
3120 .alg.skcipher = {
3121 .setkey = safexcel_skcipher_sm4_setkey,
3122 .encrypt = safexcel_sm4_blk_encrypt,
3123 .decrypt = safexcel_sm4_blk_decrypt,
3124 .min_keysize = SM4_KEY_SIZE,
3125 .max_keysize = SM4_KEY_SIZE,
3126 .base = {
3127 .cra_name = "ecb(sm4)",
3128 .cra_driver_name = "safexcel-ecb-sm4",
3129 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3130 .cra_flags = CRYPTO_ALG_ASYNC |
3131 CRYPTO_ALG_ALLOCATES_MEMORY |
3132 CRYPTO_ALG_KERN_DRIVER_ONLY,
3133 .cra_blocksize = SM4_BLOCK_SIZE,
3134 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3135 .cra_alignmask = 0,
3136 .cra_init = safexcel_skcipher_sm4_ecb_cra_init,
3137 .cra_exit = safexcel_skcipher_cra_exit,
3138 .cra_module = THIS_MODULE,
3139 },
3140 },
3141 };
3142
3143 static int safexcel_skcipher_sm4_cbc_cra_init(struct crypto_tfm *tfm)
3144 {
3145 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3146
3147 safexcel_skcipher_cra_init(tfm);
3148 ctx->alg = SAFEXCEL_SM4;
3149 ctx->blocksz = SM4_BLOCK_SIZE;
3150 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CBC;
3151 return 0;
3152 }
3153
3154 struct safexcel_alg_template safexcel_alg_cbc_sm4 = {
3155 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
3156 .algo_mask = SAFEXCEL_ALG_SM4,
3157 .alg.skcipher = {
3158 .setkey = safexcel_skcipher_sm4_setkey,
3159 .encrypt = safexcel_sm4_blk_encrypt,
3160 .decrypt = safexcel_sm4_blk_decrypt,
3161 .min_keysize = SM4_KEY_SIZE,
3162 .max_keysize = SM4_KEY_SIZE,
3163 .ivsize = SM4_BLOCK_SIZE,
3164 .base = {
3165 .cra_name = "cbc(sm4)",
3166 .cra_driver_name = "safexcel-cbc-sm4",
3167 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3168 .cra_flags = CRYPTO_ALG_ASYNC |
3169 CRYPTO_ALG_ALLOCATES_MEMORY |
3170 CRYPTO_ALG_KERN_DRIVER_ONLY,
3171 .cra_blocksize = SM4_BLOCK_SIZE,
3172 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3173 .cra_alignmask = 0,
3174 .cra_init = safexcel_skcipher_sm4_cbc_cra_init,
3175 .cra_exit = safexcel_skcipher_cra_exit,
3176 .cra_module = THIS_MODULE,
3177 },
3178 },
3179 };
3180
3181 static int safexcel_skcipher_sm4_ofb_cra_init(struct crypto_tfm *tfm)
3182 {
3183 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3184
3185 safexcel_skcipher_cra_init(tfm);
3186 ctx->alg = SAFEXCEL_SM4;
3187 ctx->blocksz = SM4_BLOCK_SIZE;
3188 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_OFB;
3189 return 0;
3190 }
3191
3192 struct safexcel_alg_template safexcel_alg_ofb_sm4 = {
3193 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
3194 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_AES_XFB,
3195 .alg.skcipher = {
3196 .setkey = safexcel_skcipher_sm4_setkey,
3197 .encrypt = safexcel_encrypt,
3198 .decrypt = safexcel_decrypt,
3199 .min_keysize = SM4_KEY_SIZE,
3200 .max_keysize = SM4_KEY_SIZE,
3201 .ivsize = SM4_BLOCK_SIZE,
3202 .base = {
3203 .cra_name = "ofb(sm4)",
3204 .cra_driver_name = "safexcel-ofb-sm4",
3205 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3206 .cra_flags = CRYPTO_ALG_ASYNC |
3207 CRYPTO_ALG_ALLOCATES_MEMORY |
3208 CRYPTO_ALG_KERN_DRIVER_ONLY,
3209 .cra_blocksize = 1,
3210 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3211 .cra_alignmask = 0,
3212 .cra_init = safexcel_skcipher_sm4_ofb_cra_init,
3213 .cra_exit = safexcel_skcipher_cra_exit,
3214 .cra_module = THIS_MODULE,
3215 },
3216 },
3217 };
3218
3219 static int safexcel_skcipher_sm4_cfb_cra_init(struct crypto_tfm *tfm)
3220 {
3221 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3222
3223 safexcel_skcipher_cra_init(tfm);
3224 ctx->alg = SAFEXCEL_SM4;
3225 ctx->blocksz = SM4_BLOCK_SIZE;
3226 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CFB;
3227 return 0;
3228 }
3229
3230 struct safexcel_alg_template safexcel_alg_cfb_sm4 = {
3231 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
3232 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_AES_XFB,
3233 .alg.skcipher = {
3234 .setkey = safexcel_skcipher_sm4_setkey,
3235 .encrypt = safexcel_encrypt,
3236 .decrypt = safexcel_decrypt,
3237 .min_keysize = SM4_KEY_SIZE,
3238 .max_keysize = SM4_KEY_SIZE,
3239 .ivsize = SM4_BLOCK_SIZE,
3240 .base = {
3241 .cra_name = "cfb(sm4)",
3242 .cra_driver_name = "safexcel-cfb-sm4",
3243 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3244 .cra_flags = CRYPTO_ALG_ASYNC |
3245 CRYPTO_ALG_ALLOCATES_MEMORY |
3246 CRYPTO_ALG_KERN_DRIVER_ONLY,
3247 .cra_blocksize = 1,
3248 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3249 .cra_alignmask = 0,
3250 .cra_init = safexcel_skcipher_sm4_cfb_cra_init,
3251 .cra_exit = safexcel_skcipher_cra_exit,
3252 .cra_module = THIS_MODULE,
3253 },
3254 },
3255 };
3256
3257 static int safexcel_skcipher_sm4ctr_setkey(struct crypto_skcipher *ctfm,
3258 const u8 *key, unsigned int len)
3259 {
3260 struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
3261 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3262
3263 /* last 4 bytes of key are the nonce! */
3264 ctx->nonce = *(u32 *)(key + len - CTR_RFC3686_NONCE_SIZE);
3265 /* exclude the nonce here */
3266 len -= CTR_RFC3686_NONCE_SIZE;
3267
3268 return safexcel_skcipher_sm4_setkey(ctfm, key, len);
3269 }
3270
3271 static int safexcel_skcipher_sm4_ctr_cra_init(struct crypto_tfm *tfm)
3272 {
3273 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3274
3275 safexcel_skcipher_cra_init(tfm);
3276 ctx->alg = SAFEXCEL_SM4;
3277 ctx->blocksz = SM4_BLOCK_SIZE;
3278 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD;
3279 return 0;
3280 }
3281
3282 struct safexcel_alg_template safexcel_alg_ctr_sm4 = {
3283 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
3284 .algo_mask = SAFEXCEL_ALG_SM4,
3285 .alg.skcipher = {
3286 .setkey = safexcel_skcipher_sm4ctr_setkey,
3287 .encrypt = safexcel_encrypt,
3288 .decrypt = safexcel_decrypt,
3289 /* Add nonce size */
3290 .min_keysize = SM4_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
3291 .max_keysize = SM4_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
3292 .ivsize = CTR_RFC3686_IV_SIZE,
3293 .base = {
3294 .cra_name = "rfc3686(ctr(sm4))",
3295 .cra_driver_name = "safexcel-ctr-sm4",
3296 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3297 .cra_flags = CRYPTO_ALG_ASYNC |
3298 CRYPTO_ALG_ALLOCATES_MEMORY |
3299 CRYPTO_ALG_KERN_DRIVER_ONLY,
3300 .cra_blocksize = 1,
3301 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3302 .cra_alignmask = 0,
3303 .cra_init = safexcel_skcipher_sm4_ctr_cra_init,
3304 .cra_exit = safexcel_skcipher_cra_exit,
3305 .cra_module = THIS_MODULE,
3306 },
3307 },
3308 };
3309
3310 static int safexcel_aead_sm4_blk_encrypt(struct aead_request *req)
3311 {
3312 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3313 if (req->cryptlen & (SM4_BLOCK_SIZE - 1))
3314 return -EINVAL;
3315
3316 return safexcel_queue_req(&req->base, aead_request_ctx(req),
3317 SAFEXCEL_ENCRYPT);
3318 }
3319
3320 static int safexcel_aead_sm4_blk_decrypt(struct aead_request *req)
3321 {
3322 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
3323
3324 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3325 if ((req->cryptlen - crypto_aead_authsize(tfm)) & (SM4_BLOCK_SIZE - 1))
3326 return -EINVAL;
3327
3328 return safexcel_queue_req(&req->base, aead_request_ctx(req),
3329 SAFEXCEL_DECRYPT);
3330 }
3331
3332 static int safexcel_aead_sm4cbc_sha1_cra_init(struct crypto_tfm *tfm)
3333 {
3334 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3335
3336 safexcel_aead_cra_init(tfm);
3337 ctx->alg = SAFEXCEL_SM4;
3338 ctx->blocksz = SM4_BLOCK_SIZE;
3339 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA1;
3340 ctx->state_sz = SHA1_DIGEST_SIZE;
3341 return 0;
3342 }
3343
3344 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_cbc_sm4 = {
3345 .type = SAFEXCEL_ALG_TYPE_AEAD,
3346 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_SHA1,
3347 .alg.aead = {
3348 .setkey = safexcel_aead_setkey,
3349 .encrypt = safexcel_aead_sm4_blk_encrypt,
3350 .decrypt = safexcel_aead_sm4_blk_decrypt,
3351 .ivsize = SM4_BLOCK_SIZE,
3352 .maxauthsize = SHA1_DIGEST_SIZE,
3353 .base = {
3354 .cra_name = "authenc(hmac(sha1),cbc(sm4))",
3355 .cra_driver_name = "safexcel-authenc-hmac-sha1-cbc-sm4",
3356 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3357 .cra_flags = CRYPTO_ALG_ASYNC |
3358 CRYPTO_ALG_ALLOCATES_MEMORY |
3359 CRYPTO_ALG_KERN_DRIVER_ONLY,
3360 .cra_blocksize = SM4_BLOCK_SIZE,
3361 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3362 .cra_alignmask = 0,
3363 .cra_init = safexcel_aead_sm4cbc_sha1_cra_init,
3364 .cra_exit = safexcel_aead_cra_exit,
3365 .cra_module = THIS_MODULE,
3366 },
3367 },
3368 };
3369
3370 static int safexcel_aead_fallback_setkey(struct crypto_aead *ctfm,
3371 const u8 *key, unsigned int len)
3372 {
3373 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
3374 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3375
3376 /* Keep fallback cipher synchronized */
3377 return crypto_aead_setkey(ctx->fback, (u8 *)key, len) ?:
3378 safexcel_aead_setkey(ctfm, key, len);
3379 }
3380
3381 static int safexcel_aead_fallback_setauthsize(struct crypto_aead *ctfm,
3382 unsigned int authsize)
3383 {
3384 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
3385 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3386
3387 /* Keep fallback cipher synchronized */
3388 return crypto_aead_setauthsize(ctx->fback, authsize);
3389 }
3390
3391 static int safexcel_aead_fallback_crypt(struct aead_request *req,
3392 enum safexcel_cipher_direction dir)
3393 {
3394 struct crypto_aead *aead = crypto_aead_reqtfm(req);
3395 struct crypto_tfm *tfm = crypto_aead_tfm(aead);
3396 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3397 struct aead_request *subreq = aead_request_ctx(req);
3398
3399 aead_request_set_tfm(subreq, ctx->fback);
3400 aead_request_set_callback(subreq, req->base.flags, req->base.complete,
3401 req->base.data);
3402 aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
3403 req->iv);
3404 aead_request_set_ad(subreq, req->assoclen);
3405
3406 return (dir == SAFEXCEL_ENCRYPT) ?
3407 crypto_aead_encrypt(subreq) :
3408 crypto_aead_decrypt(subreq);
3409 }
3410
3411 static int safexcel_aead_sm4cbc_sm3_encrypt(struct aead_request *req)
3412 {
3413 struct safexcel_cipher_req *creq = aead_request_ctx(req);
3414
3415 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3416 if (req->cryptlen & (SM4_BLOCK_SIZE - 1))
3417 return -EINVAL;
3418 else if (req->cryptlen || req->assoclen) /* If input length > 0 only */
3419 return safexcel_queue_req(&req->base, creq, SAFEXCEL_ENCRYPT);
3420
3421 /* HW cannot do full (AAD+payload) zero length, use fallback */
3422 return safexcel_aead_fallback_crypt(req, SAFEXCEL_ENCRYPT);
3423 }
3424
3425 static int safexcel_aead_sm4cbc_sm3_decrypt(struct aead_request *req)
3426 {
3427 struct safexcel_cipher_req *creq = aead_request_ctx(req);
3428 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
3429
3430 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3431 if ((req->cryptlen - crypto_aead_authsize(tfm)) & (SM4_BLOCK_SIZE - 1))
3432 return -EINVAL;
3433 else if (req->cryptlen > crypto_aead_authsize(tfm) || req->assoclen)
3434 /* If input length > 0 only */
3435 return safexcel_queue_req(&req->base, creq, SAFEXCEL_DECRYPT);
3436
3437 /* HW cannot do full (AAD+payload) zero length, use fallback */
3438 return safexcel_aead_fallback_crypt(req, SAFEXCEL_DECRYPT);
3439 }
3440
3441 static int safexcel_aead_sm4cbc_sm3_cra_init(struct crypto_tfm *tfm)
3442 {
3443 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3444
3445 safexcel_aead_fallback_cra_init(tfm);
3446 ctx->alg = SAFEXCEL_SM4;
3447 ctx->blocksz = SM4_BLOCK_SIZE;
3448 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SM3;
3449 ctx->state_sz = SM3_DIGEST_SIZE;
3450 return 0;
3451 }
3452
3453 struct safexcel_alg_template safexcel_alg_authenc_hmac_sm3_cbc_sm4 = {
3454 .type = SAFEXCEL_ALG_TYPE_AEAD,
3455 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_SM3,
3456 .alg.aead = {
3457 .setkey = safexcel_aead_fallback_setkey,
3458 .setauthsize = safexcel_aead_fallback_setauthsize,
3459 .encrypt = safexcel_aead_sm4cbc_sm3_encrypt,
3460 .decrypt = safexcel_aead_sm4cbc_sm3_decrypt,
3461 .ivsize = SM4_BLOCK_SIZE,
3462 .maxauthsize = SM3_DIGEST_SIZE,
3463 .base = {
3464 .cra_name = "authenc(hmac(sm3),cbc(sm4))",
3465 .cra_driver_name = "safexcel-authenc-hmac-sm3-cbc-sm4",
3466 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3467 .cra_flags = CRYPTO_ALG_ASYNC |
3468 CRYPTO_ALG_ALLOCATES_MEMORY |
3469 CRYPTO_ALG_KERN_DRIVER_ONLY |
3470 CRYPTO_ALG_NEED_FALLBACK,
3471 .cra_blocksize = SM4_BLOCK_SIZE,
3472 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3473 .cra_alignmask = 0,
3474 .cra_init = safexcel_aead_sm4cbc_sm3_cra_init,
3475 .cra_exit = safexcel_aead_fallback_cra_exit,
3476 .cra_module = THIS_MODULE,
3477 },
3478 },
3479 };
3480
3481 static int safexcel_aead_sm4ctr_sha1_cra_init(struct crypto_tfm *tfm)
3482 {
3483 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3484
3485 safexcel_aead_sm4cbc_sha1_cra_init(tfm);
3486 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD;
3487 return 0;
3488 }
3489
3490 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_ctr_sm4 = {
3491 .type = SAFEXCEL_ALG_TYPE_AEAD,
3492 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_SHA1,
3493 .alg.aead = {
3494 .setkey = safexcel_aead_setkey,
3495 .encrypt = safexcel_aead_encrypt,
3496 .decrypt = safexcel_aead_decrypt,
3497 .ivsize = CTR_RFC3686_IV_SIZE,
3498 .maxauthsize = SHA1_DIGEST_SIZE,
3499 .base = {
3500 .cra_name = "authenc(hmac(sha1),rfc3686(ctr(sm4)))",
3501 .cra_driver_name = "safexcel-authenc-hmac-sha1-ctr-sm4",
3502 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3503 .cra_flags = CRYPTO_ALG_ASYNC |
3504 CRYPTO_ALG_ALLOCATES_MEMORY |
3505 CRYPTO_ALG_KERN_DRIVER_ONLY,
3506 .cra_blocksize = 1,
3507 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3508 .cra_alignmask = 0,
3509 .cra_init = safexcel_aead_sm4ctr_sha1_cra_init,
3510 .cra_exit = safexcel_aead_cra_exit,
3511 .cra_module = THIS_MODULE,
3512 },
3513 },
3514 };
3515
3516 static int safexcel_aead_sm4ctr_sm3_cra_init(struct crypto_tfm *tfm)
3517 {
3518 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3519
3520 safexcel_aead_sm4cbc_sm3_cra_init(tfm);
3521 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD;
3522 return 0;
3523 }
3524
3525 struct safexcel_alg_template safexcel_alg_authenc_hmac_sm3_ctr_sm4 = {
3526 .type = SAFEXCEL_ALG_TYPE_AEAD,
3527 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_SM3,
3528 .alg.aead = {
3529 .setkey = safexcel_aead_setkey,
3530 .encrypt = safexcel_aead_encrypt,
3531 .decrypt = safexcel_aead_decrypt,
3532 .ivsize = CTR_RFC3686_IV_SIZE,
3533 .maxauthsize = SM3_DIGEST_SIZE,
3534 .base = {
3535 .cra_name = "authenc(hmac(sm3),rfc3686(ctr(sm4)))",
3536 .cra_driver_name = "safexcel-authenc-hmac-sm3-ctr-sm4",
3537 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3538 .cra_flags = CRYPTO_ALG_ASYNC |
3539 CRYPTO_ALG_ALLOCATES_MEMORY |
3540 CRYPTO_ALG_KERN_DRIVER_ONLY,
3541 .cra_blocksize = 1,
3542 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3543 .cra_alignmask = 0,
3544 .cra_init = safexcel_aead_sm4ctr_sm3_cra_init,
3545 .cra_exit = safexcel_aead_cra_exit,
3546 .cra_module = THIS_MODULE,
3547 },
3548 },
3549 };
3550
3551 static int safexcel_rfc4106_gcm_setkey(struct crypto_aead *ctfm, const u8 *key,
3552 unsigned int len)
3553 {
3554 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
3555 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3556
3557 /* last 4 bytes of key are the nonce! */
3558 ctx->nonce = *(u32 *)(key + len - CTR_RFC3686_NONCE_SIZE);
3559
3560 len -= CTR_RFC3686_NONCE_SIZE;
3561 return safexcel_aead_gcm_setkey(ctfm, key, len);
3562 }
3563
3564 static int safexcel_rfc4106_gcm_setauthsize(struct crypto_aead *tfm,
3565 unsigned int authsize)
3566 {
3567 return crypto_rfc4106_check_authsize(authsize);
3568 }
3569
3570 static int safexcel_rfc4106_encrypt(struct aead_request *req)
3571 {
3572 return crypto_ipsec_check_assoclen(req->assoclen) ?:
3573 safexcel_aead_encrypt(req);
3574 }
3575
3576 static int safexcel_rfc4106_decrypt(struct aead_request *req)
3577 {
3578 return crypto_ipsec_check_assoclen(req->assoclen) ?:
3579 safexcel_aead_decrypt(req);
3580 }
3581
3582 static int safexcel_rfc4106_gcm_cra_init(struct crypto_tfm *tfm)
3583 {
3584 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3585 int ret;
3586
3587 ret = safexcel_aead_gcm_cra_init(tfm);
3588 ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP;
3589 ctx->aadskip = EIP197_AEAD_IPSEC_IV_SIZE;
3590 return ret;
3591 }
3592
3593 struct safexcel_alg_template safexcel_alg_rfc4106_gcm = {
3594 .type = SAFEXCEL_ALG_TYPE_AEAD,
3595 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_GHASH,
3596 .alg.aead = {
3597 .setkey = safexcel_rfc4106_gcm_setkey,
3598 .setauthsize = safexcel_rfc4106_gcm_setauthsize,
3599 .encrypt = safexcel_rfc4106_encrypt,
3600 .decrypt = safexcel_rfc4106_decrypt,
3601 .ivsize = GCM_RFC4106_IV_SIZE,
3602 .maxauthsize = GHASH_DIGEST_SIZE,
3603 .base = {
3604 .cra_name = "rfc4106(gcm(aes))",
3605 .cra_driver_name = "safexcel-rfc4106-gcm-aes",
3606 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3607 .cra_flags = CRYPTO_ALG_ASYNC |
3608 CRYPTO_ALG_ALLOCATES_MEMORY |
3609 CRYPTO_ALG_KERN_DRIVER_ONLY,
3610 .cra_blocksize = 1,
3611 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3612 .cra_alignmask = 0,
3613 .cra_init = safexcel_rfc4106_gcm_cra_init,
3614 .cra_exit = safexcel_aead_gcm_cra_exit,
3615 },
3616 },
3617 };
3618
3619 static int safexcel_rfc4543_gcm_setauthsize(struct crypto_aead *tfm,
3620 unsigned int authsize)
3621 {
3622 if (authsize != GHASH_DIGEST_SIZE)
3623 return -EINVAL;
3624
3625 return 0;
3626 }
3627
3628 static int safexcel_rfc4543_gcm_cra_init(struct crypto_tfm *tfm)
3629 {
3630 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3631 int ret;
3632
3633 ret = safexcel_aead_gcm_cra_init(tfm);
3634 ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP_GMAC;
3635 return ret;
3636 }
3637
3638 struct safexcel_alg_template safexcel_alg_rfc4543_gcm = {
3639 .type = SAFEXCEL_ALG_TYPE_AEAD,
3640 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_GHASH,
3641 .alg.aead = {
3642 .setkey = safexcel_rfc4106_gcm_setkey,
3643 .setauthsize = safexcel_rfc4543_gcm_setauthsize,
3644 .encrypt = safexcel_rfc4106_encrypt,
3645 .decrypt = safexcel_rfc4106_decrypt,
3646 .ivsize = GCM_RFC4543_IV_SIZE,
3647 .maxauthsize = GHASH_DIGEST_SIZE,
3648 .base = {
3649 .cra_name = "rfc4543(gcm(aes))",
3650 .cra_driver_name = "safexcel-rfc4543-gcm-aes",
3651 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3652 .cra_flags = CRYPTO_ALG_ASYNC |
3653 CRYPTO_ALG_ALLOCATES_MEMORY |
3654 CRYPTO_ALG_KERN_DRIVER_ONLY,
3655 .cra_blocksize = 1,
3656 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3657 .cra_alignmask = 0,
3658 .cra_init = safexcel_rfc4543_gcm_cra_init,
3659 .cra_exit = safexcel_aead_gcm_cra_exit,
3660 },
3661 },
3662 };
3663
3664 static int safexcel_rfc4309_ccm_setkey(struct crypto_aead *ctfm, const u8 *key,
3665 unsigned int len)
3666 {
3667 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
3668 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3669
3670 /* First byte of the nonce = L = always 3 for RFC4309 (4 byte ctr) */
3671 *(u8 *)&ctx->nonce = EIP197_AEAD_IPSEC_COUNTER_SIZE - 1;
3672 /* last 3 bytes of key are the nonce! */
3673 memcpy((u8 *)&ctx->nonce + 1, key + len -
3674 EIP197_AEAD_IPSEC_CCM_NONCE_SIZE,
3675 EIP197_AEAD_IPSEC_CCM_NONCE_SIZE);
3676
3677 len -= EIP197_AEAD_IPSEC_CCM_NONCE_SIZE;
3678 return safexcel_aead_ccm_setkey(ctfm, key, len);
3679 }
3680
3681 static int safexcel_rfc4309_ccm_setauthsize(struct crypto_aead *tfm,
3682 unsigned int authsize)
3683 {
3684 /* Borrowed from crypto/ccm.c */
3685 switch (authsize) {
3686 case 8:
3687 case 12:
3688 case 16:
3689 break;
3690 default:
3691 return -EINVAL;
3692 }
3693
3694 return 0;
3695 }
3696
3697 static int safexcel_rfc4309_ccm_encrypt(struct aead_request *req)
3698 {
3699 struct safexcel_cipher_req *creq = aead_request_ctx(req);
3700
3701 /* Borrowed from crypto/ccm.c */
3702 if (req->assoclen != 16 && req->assoclen != 20)
3703 return -EINVAL;
3704
3705 return safexcel_queue_req(&req->base, creq, SAFEXCEL_ENCRYPT);
3706 }
3707
3708 static int safexcel_rfc4309_ccm_decrypt(struct aead_request *req)
3709 {
3710 struct safexcel_cipher_req *creq = aead_request_ctx(req);
3711
3712 /* Borrowed from crypto/ccm.c */
3713 if (req->assoclen != 16 && req->assoclen != 20)
3714 return -EINVAL;
3715
3716 return safexcel_queue_req(&req->base, creq, SAFEXCEL_DECRYPT);
3717 }
3718
3719 static int safexcel_rfc4309_ccm_cra_init(struct crypto_tfm *tfm)
3720 {
3721 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3722 int ret;
3723
3724 ret = safexcel_aead_ccm_cra_init(tfm);
3725 ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP;
3726 ctx->aadskip = EIP197_AEAD_IPSEC_IV_SIZE;
3727 return ret;
3728 }
3729
3730 struct safexcel_alg_template safexcel_alg_rfc4309_ccm = {
3731 .type = SAFEXCEL_ALG_TYPE_AEAD,
3732 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_CBC_MAC_ALL,
3733 .alg.aead = {
3734 .setkey = safexcel_rfc4309_ccm_setkey,
3735 .setauthsize = safexcel_rfc4309_ccm_setauthsize,
3736 .encrypt = safexcel_rfc4309_ccm_encrypt,
3737 .decrypt = safexcel_rfc4309_ccm_decrypt,
3738 .ivsize = EIP197_AEAD_IPSEC_IV_SIZE,
3739 .maxauthsize = AES_BLOCK_SIZE,
3740 .base = {
3741 .cra_name = "rfc4309(ccm(aes))",
3742 .cra_driver_name = "safexcel-rfc4309-ccm-aes",
3743 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3744 .cra_flags = CRYPTO_ALG_ASYNC |
3745 CRYPTO_ALG_ALLOCATES_MEMORY |
3746 CRYPTO_ALG_KERN_DRIVER_ONLY,
3747 .cra_blocksize = 1,
3748 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3749 .cra_alignmask = 0,
3750 .cra_init = safexcel_rfc4309_ccm_cra_init,
3751 .cra_exit = safexcel_aead_cra_exit,
3752 .cra_module = THIS_MODULE,
3753 },
3754 },
3755 };
Linux with added FPC-III support