1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2017 Marvell
5 * Antoine Tenart <antoine.tenart@free-electrons.com>
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/sha.h>
22 #include <crypto/sm3.h>
23 #include <crypto/sm4.h>
24 #include <crypto/xts.h>
25 #include <crypto/skcipher.h>
26 #include <crypto/internal/aead.h>
27 #include <crypto/internal/skcipher.h>
31 enum safexcel_cipher_direction {
36 enum safexcel_cipher_alg {
44 struct safexcel_cipher_ctx {
45 struct safexcel_context base;
46 struct safexcel_crypto_priv *priv;
49 enum safexcel_cipher_alg alg;
50 char aead; /* !=0=AEAD, 2=IPSec ESP AEAD, 3=IPsec ESP GMAC */
51 char xcm; /* 0=authenc, 1=GCM, 2 reserved for CCM */
55 unsigned int key_len, xts;
57 /* All the below is AEAD specific */
60 __be32 ipad[SHA512_DIGEST_SIZE / sizeof(u32)];
61 __be32 opad[SHA512_DIGEST_SIZE / sizeof(u32)];
63 struct crypto_cipher *hkaes;
64 struct crypto_aead *fback;
67 struct safexcel_cipher_req {
68 enum safexcel_cipher_direction direction;
69 /* Number of result descriptors associated to the request */
75 static void safexcel_cipher_token(struct safexcel_cipher_ctx *ctx, u8 *iv,
76 struct safexcel_command_desc *cdesc)
80 if (ctx->mode == CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD ||
81 ctx->aead & EIP197_AEAD_TYPE_IPSEC_ESP) { /* _ESP and _ESP_GMAC */
82 cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
85 cdesc->control_data.token[0] = ctx->nonce;
87 memcpy(&cdesc->control_data.token[1], iv, 8);
89 if (ctx->alg == SAFEXCEL_CHACHA20 ||
90 ctx->xcm == EIP197_XCM_MODE_CCM) {
91 /* 32 bit counter, starting at 0 */
92 cdesc->control_data.token[3] = 0;
94 /* 32 bit counter, start at 1 (big endian!) */
95 cdesc->control_data.token[3] =
96 (__force u32)cpu_to_be32(1);
100 } else if (ctx->xcm == EIP197_XCM_MODE_GCM ||
101 (ctx->aead && ctx->alg == SAFEXCEL_CHACHA20)) {
102 cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
105 memcpy(&cdesc->control_data.token[0], iv, 12);
107 if (ctx->alg == SAFEXCEL_CHACHA20) {
108 /* 32 bit counter, starting at 0 */
109 cdesc->control_data.token[3] = 0;
111 /* 32 bit counter, start at 1 (big endian!) */
112 *(__be32 *)&cdesc->control_data.token[3] =
117 } else if (ctx->alg == SAFEXCEL_CHACHA20) {
118 cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
120 /* 96 bit nonce part */
121 memcpy(&cdesc->control_data.token[0], &iv[4], 12);
123 cdesc->control_data.token[3] = *(u32 *)iv;
126 } else if (ctx->xcm == EIP197_XCM_MODE_CCM) {
127 cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
129 /* Variable length IV part */
130 memcpy(&cdesc->control_data.token[0], iv, 15 - iv[0]);
131 /* Start variable length counter at 0 */
132 memset((u8 *)&cdesc->control_data.token[0] + 15 - iv[0],
138 if (ctx->mode != CONTEXT_CONTROL_CRYPTO_MODE_ECB) {
141 block_sz = DES_BLOCK_SIZE;
142 cdesc->control_data.options |= EIP197_OPTION_2_TOKEN_IV_CMD;
145 block_sz = DES3_EDE_BLOCK_SIZE;
146 cdesc->control_data.options |= EIP197_OPTION_2_TOKEN_IV_CMD;
149 block_sz = SM4_BLOCK_SIZE;
150 cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
153 block_sz = AES_BLOCK_SIZE;
154 cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
159 memcpy(cdesc->control_data.token, iv, block_sz);
163 static void safexcel_skcipher_token(struct safexcel_cipher_ctx *ctx, u8 *iv,
164 struct safexcel_command_desc *cdesc,
167 struct safexcel_token *token;
169 safexcel_cipher_token(ctx, iv, cdesc);
171 /* skip over worst case IV of 4 dwords, no need to be exact */
172 token = (struct safexcel_token *)(cdesc->control_data.token + 4);
174 token[0].opcode = EIP197_TOKEN_OPCODE_DIRECTION;
175 token[0].packet_length = length;
176 token[0].stat = EIP197_TOKEN_STAT_LAST_PACKET |
177 EIP197_TOKEN_STAT_LAST_HASH;
178 token[0].instructions = EIP197_TOKEN_INS_LAST |
179 EIP197_TOKEN_INS_TYPE_CRYPTO |
180 EIP197_TOKEN_INS_TYPE_OUTPUT;
183 static void safexcel_aead_token(struct safexcel_cipher_ctx *ctx, u8 *iv,
184 struct safexcel_command_desc *cdesc,
185 enum safexcel_cipher_direction direction,
186 u32 cryptlen, u32 assoclen, u32 digestsize)
188 struct safexcel_token *token;
190 safexcel_cipher_token(ctx, iv, cdesc);
192 if (direction == SAFEXCEL_ENCRYPT) {
193 /* align end of instruction sequence to end of token */
194 token = (struct safexcel_token *)(cdesc->control_data.token +
195 EIP197_MAX_TOKENS - 14);
197 token[13].opcode = EIP197_TOKEN_OPCODE_INSERT;
198 token[13].packet_length = digestsize;
199 token[13].stat = EIP197_TOKEN_STAT_LAST_HASH |
200 EIP197_TOKEN_STAT_LAST_PACKET;
201 token[13].instructions = EIP197_TOKEN_INS_TYPE_OUTPUT |
202 EIP197_TOKEN_INS_INSERT_HASH_DIGEST;
204 cryptlen -= digestsize;
206 /* align end of instruction sequence to end of token */
207 token = (struct safexcel_token *)(cdesc->control_data.token +
208 EIP197_MAX_TOKENS - 15);
210 token[13].opcode = EIP197_TOKEN_OPCODE_RETRIEVE;
211 token[13].packet_length = digestsize;
212 token[13].stat = EIP197_TOKEN_STAT_LAST_HASH |
213 EIP197_TOKEN_STAT_LAST_PACKET;
214 token[13].instructions = EIP197_TOKEN_INS_INSERT_HASH_DIGEST;
216 token[14].opcode = EIP197_TOKEN_OPCODE_VERIFY;
217 token[14].packet_length = digestsize |
218 EIP197_TOKEN_HASH_RESULT_VERIFY;
219 token[14].stat = EIP197_TOKEN_STAT_LAST_HASH |
220 EIP197_TOKEN_STAT_LAST_PACKET;
221 token[14].instructions = EIP197_TOKEN_INS_TYPE_OUTPUT;
224 if (ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP) {
225 /* For ESP mode (and not GMAC), skip over the IV */
226 token[8].opcode = EIP197_TOKEN_OPCODE_DIRECTION;
227 token[8].packet_length = EIP197_AEAD_IPSEC_IV_SIZE;
229 assoclen -= EIP197_AEAD_IPSEC_IV_SIZE;
232 token[6].opcode = EIP197_TOKEN_OPCODE_DIRECTION;
233 token[6].packet_length = assoclen;
234 token[6].instructions = EIP197_TOKEN_INS_LAST |
235 EIP197_TOKEN_INS_TYPE_HASH;
237 if (likely(cryptlen || ctx->alg == SAFEXCEL_CHACHA20)) {
238 token[11].opcode = EIP197_TOKEN_OPCODE_DIRECTION;
239 token[11].packet_length = cryptlen;
240 token[11].stat = EIP197_TOKEN_STAT_LAST_HASH;
241 if (unlikely(ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP_GMAC)) {
242 token[6].instructions = EIP197_TOKEN_INS_TYPE_HASH;
243 /* Do not send to crypt engine in case of GMAC */
244 token[11].instructions = EIP197_TOKEN_INS_LAST |
245 EIP197_TOKEN_INS_TYPE_HASH |
246 EIP197_TOKEN_INS_TYPE_OUTPUT;
248 token[11].instructions = EIP197_TOKEN_INS_LAST |
249 EIP197_TOKEN_INS_TYPE_CRYPTO |
250 EIP197_TOKEN_INS_TYPE_HASH |
251 EIP197_TOKEN_INS_TYPE_OUTPUT;
253 } else if (ctx->xcm != EIP197_XCM_MODE_CCM) {
254 token[6].stat = EIP197_TOKEN_STAT_LAST_HASH;
260 token[9].opcode = EIP197_TOKEN_OPCODE_INSERT_REMRES;
261 token[9].packet_length = 0;
262 token[9].instructions = AES_BLOCK_SIZE;
264 token[10].opcode = EIP197_TOKEN_OPCODE_INSERT;
265 token[10].packet_length = AES_BLOCK_SIZE;
266 token[10].instructions = EIP197_TOKEN_INS_TYPE_OUTPUT |
267 EIP197_TOKEN_INS_TYPE_CRYPTO;
269 if (ctx->xcm != EIP197_XCM_MODE_GCM) {
270 u8 *final_iv = (u8 *)cdesc->control_data.token;
271 u8 *cbcmaciv = (u8 *)&token[1];
272 __le32 *aadlen = (__le32 *)&token[5];
274 /* Construct IV block B0 for the CBC-MAC */
275 token[0].opcode = EIP197_TOKEN_OPCODE_INSERT;
276 token[0].packet_length = AES_BLOCK_SIZE +
277 ((assoclen > 0) << 1);
278 token[0].instructions = EIP197_TOKEN_INS_ORIGIN_TOKEN |
279 EIP197_TOKEN_INS_TYPE_HASH;
280 /* Variable length IV part */
281 memcpy(cbcmaciv, final_iv, 15 - final_iv[0]);
282 /* fixup flags byte */
283 cbcmaciv[0] |= ((assoclen > 0) << 6) | ((digestsize - 2) << 2);
284 /* Clear upper bytes of variable message length to 0 */
285 memset(cbcmaciv + 15 - final_iv[0], 0, final_iv[0] - 1);
286 /* insert lower 2 bytes of message length */
287 cbcmaciv[14] = cryptlen >> 8;
288 cbcmaciv[15] = cryptlen & 255;
291 *aadlen = cpu_to_le32((assoclen >> 8) |
292 ((assoclen & 0xff) << 8));
296 token[6].instructions = EIP197_TOKEN_INS_TYPE_HASH;
298 /* Align AAD data towards hash engine */
299 token[7].opcode = EIP197_TOKEN_OPCODE_INSERT;
301 token[7].packet_length = assoclen ? 16 - assoclen : 0;
303 if (likely(cryptlen)) {
304 token[7].instructions = EIP197_TOKEN_INS_TYPE_HASH;
306 /* Align crypto data towards hash engine */
309 token[12].opcode = EIP197_TOKEN_OPCODE_INSERT;
311 token[12].packet_length = cryptlen ? 16 - cryptlen : 0;
312 token[12].stat = EIP197_TOKEN_STAT_LAST_HASH;
313 token[12].instructions = EIP197_TOKEN_INS_TYPE_HASH;
315 token[7].stat = EIP197_TOKEN_STAT_LAST_HASH;
316 token[7].instructions = EIP197_TOKEN_INS_LAST |
317 EIP197_TOKEN_INS_TYPE_HASH;
322 static int safexcel_skcipher_aes_setkey(struct crypto_skcipher *ctfm,
323 const u8 *key, unsigned int len)
325 struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
326 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
327 struct safexcel_crypto_priv *priv = ctx->priv;
328 struct crypto_aes_ctx aes;
331 ret = aes_expandkey(&aes, key, len);
333 crypto_skcipher_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
337 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
338 for (i = 0; i < len / sizeof(u32); i++) {
339 if (le32_to_cpu(ctx->key[i]) != aes.key_enc[i]) {
340 ctx->base.needs_inv = true;
346 for (i = 0; i < len / sizeof(u32); i++)
347 ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
351 memzero_explicit(&aes, sizeof(aes));
355 static int safexcel_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
358 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
359 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
360 struct safexcel_ahash_export_state istate, ostate;
361 struct safexcel_crypto_priv *priv = ctx->priv;
362 struct crypto_authenc_keys keys;
363 struct crypto_aes_ctx aes;
364 int err = -EINVAL, i;
366 if (unlikely(crypto_authenc_extractkeys(&keys, key, len)))
369 if (ctx->mode == CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD) {
370 /* Must have at least space for the nonce here */
371 if (unlikely(keys.enckeylen < CTR_RFC3686_NONCE_SIZE))
373 /* last 4 bytes of key are the nonce! */
374 ctx->nonce = *(u32 *)(keys.enckey + keys.enckeylen -
375 CTR_RFC3686_NONCE_SIZE);
376 /* exclude the nonce here */
377 keys.enckeylen -= CTR_RFC3686_NONCE_SIZE;
383 err = verify_aead_des_key(ctfm, keys.enckey, keys.enckeylen);
385 goto badkey_expflags;
388 err = verify_aead_des3_key(ctfm, keys.enckey, keys.enckeylen);
390 goto badkey_expflags;
393 err = aes_expandkey(&aes, keys.enckey, keys.enckeylen);
398 if (unlikely(keys.enckeylen != SM4_KEY_SIZE))
402 dev_err(priv->dev, "aead: unsupported cipher algorithm\n");
406 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
407 for (i = 0; i < keys.enckeylen / sizeof(u32); i++) {
408 if (le32_to_cpu(ctx->key[i]) !=
409 ((u32 *)keys.enckey)[i]) {
410 ctx->base.needs_inv = true;
417 switch (ctx->hash_alg) {
418 case CONTEXT_CONTROL_CRYPTO_ALG_SHA1:
419 if (safexcel_hmac_setkey("safexcel-sha1", keys.authkey,
420 keys.authkeylen, &istate, &ostate))
423 case CONTEXT_CONTROL_CRYPTO_ALG_SHA224:
424 if (safexcel_hmac_setkey("safexcel-sha224", keys.authkey,
425 keys.authkeylen, &istate, &ostate))
428 case CONTEXT_CONTROL_CRYPTO_ALG_SHA256:
429 if (safexcel_hmac_setkey("safexcel-sha256", keys.authkey,
430 keys.authkeylen, &istate, &ostate))
433 case CONTEXT_CONTROL_CRYPTO_ALG_SHA384:
434 if (safexcel_hmac_setkey("safexcel-sha384", keys.authkey,
435 keys.authkeylen, &istate, &ostate))
438 case CONTEXT_CONTROL_CRYPTO_ALG_SHA512:
439 if (safexcel_hmac_setkey("safexcel-sha512", keys.authkey,
440 keys.authkeylen, &istate, &ostate))
443 case CONTEXT_CONTROL_CRYPTO_ALG_SM3:
444 if (safexcel_hmac_setkey("safexcel-sm3", keys.authkey,
445 keys.authkeylen, &istate, &ostate))
449 dev_err(priv->dev, "aead: unsupported hash algorithm\n");
453 crypto_aead_set_flags(ctfm, crypto_aead_get_flags(ctfm) &
454 CRYPTO_TFM_RES_MASK);
456 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma &&
457 (memcmp(ctx->ipad, istate.state, ctx->state_sz) ||
458 memcmp(ctx->opad, ostate.state, ctx->state_sz)))
459 ctx->base.needs_inv = true;
461 /* Now copy the keys into the context */
462 for (i = 0; i < keys.enckeylen / sizeof(u32); i++)
463 ctx->key[i] = cpu_to_le32(((u32 *)keys.enckey)[i]);
464 ctx->key_len = keys.enckeylen;
466 memcpy(ctx->ipad, &istate.state, ctx->state_sz);
467 memcpy(ctx->opad, &ostate.state, ctx->state_sz);
469 memzero_explicit(&keys, sizeof(keys));
473 crypto_aead_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
475 memzero_explicit(&keys, sizeof(keys));
479 static int safexcel_context_control(struct safexcel_cipher_ctx *ctx,
480 struct crypto_async_request *async,
481 struct safexcel_cipher_req *sreq,
482 struct safexcel_command_desc *cdesc)
484 struct safexcel_crypto_priv *priv = ctx->priv;
485 int ctrl_size = ctx->key_len / sizeof(u32);
487 cdesc->control_data.control1 = ctx->mode;
490 /* Take in account the ipad+opad digests */
492 ctrl_size += ctx->state_sz / sizeof(u32);
493 cdesc->control_data.control0 =
494 CONTEXT_CONTROL_KEY_EN |
495 CONTEXT_CONTROL_DIGEST_XCM |
497 CONTEXT_CONTROL_SIZE(ctrl_size);
498 } else if (ctx->alg == SAFEXCEL_CHACHA20) {
499 /* Chacha20-Poly1305 */
500 cdesc->control_data.control0 =
501 CONTEXT_CONTROL_KEY_EN |
502 CONTEXT_CONTROL_CRYPTO_ALG_CHACHA20 |
503 (sreq->direction == SAFEXCEL_ENCRYPT ?
504 CONTEXT_CONTROL_TYPE_ENCRYPT_HASH_OUT :
505 CONTEXT_CONTROL_TYPE_HASH_DECRYPT_IN) |
507 CONTEXT_CONTROL_SIZE(ctrl_size);
510 ctrl_size += ctx->state_sz / sizeof(u32) * 2;
511 cdesc->control_data.control0 =
512 CONTEXT_CONTROL_KEY_EN |
513 CONTEXT_CONTROL_DIGEST_HMAC |
515 CONTEXT_CONTROL_SIZE(ctrl_size);
518 if (sreq->direction == SAFEXCEL_ENCRYPT &&
519 (ctx->xcm == EIP197_XCM_MODE_CCM ||
520 ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP_GMAC))
521 cdesc->control_data.control0 |=
522 CONTEXT_CONTROL_TYPE_HASH_ENCRYPT_OUT;
523 else if (sreq->direction == SAFEXCEL_ENCRYPT)
524 cdesc->control_data.control0 |=
525 CONTEXT_CONTROL_TYPE_ENCRYPT_HASH_OUT;
526 else if (ctx->xcm == EIP197_XCM_MODE_CCM)
527 cdesc->control_data.control0 |=
528 CONTEXT_CONTROL_TYPE_DECRYPT_HASH_IN;
530 cdesc->control_data.control0 |=
531 CONTEXT_CONTROL_TYPE_HASH_DECRYPT_IN;
533 if (sreq->direction == SAFEXCEL_ENCRYPT)
534 cdesc->control_data.control0 =
535 CONTEXT_CONTROL_TYPE_CRYPTO_OUT |
536 CONTEXT_CONTROL_KEY_EN |
537 CONTEXT_CONTROL_SIZE(ctrl_size);
539 cdesc->control_data.control0 =
540 CONTEXT_CONTROL_TYPE_CRYPTO_IN |
541 CONTEXT_CONTROL_KEY_EN |
542 CONTEXT_CONTROL_SIZE(ctrl_size);
545 if (ctx->alg == SAFEXCEL_DES) {
546 cdesc->control_data.control0 |=
547 CONTEXT_CONTROL_CRYPTO_ALG_DES;
548 } else if (ctx->alg == SAFEXCEL_3DES) {
549 cdesc->control_data.control0 |=
550 CONTEXT_CONTROL_CRYPTO_ALG_3DES;
551 } else if (ctx->alg == SAFEXCEL_AES) {
552 switch (ctx->key_len >> ctx->xts) {
553 case AES_KEYSIZE_128:
554 cdesc->control_data.control0 |=
555 CONTEXT_CONTROL_CRYPTO_ALG_AES128;
557 case AES_KEYSIZE_192:
558 cdesc->control_data.control0 |=
559 CONTEXT_CONTROL_CRYPTO_ALG_AES192;
561 case AES_KEYSIZE_256:
562 cdesc->control_data.control0 |=
563 CONTEXT_CONTROL_CRYPTO_ALG_AES256;
566 dev_err(priv->dev, "aes keysize not supported: %u\n",
567 ctx->key_len >> ctx->xts);
570 } else if (ctx->alg == SAFEXCEL_CHACHA20) {
571 cdesc->control_data.control0 |=
572 CONTEXT_CONTROL_CRYPTO_ALG_CHACHA20;
573 } else if (ctx->alg == SAFEXCEL_SM4) {
574 cdesc->control_data.control0 |=
575 CONTEXT_CONTROL_CRYPTO_ALG_SM4;
581 static int safexcel_handle_req_result(struct safexcel_crypto_priv *priv, int ring,
582 struct crypto_async_request *async,
583 struct scatterlist *src,
584 struct scatterlist *dst,
585 unsigned int cryptlen,
586 struct safexcel_cipher_req *sreq,
587 bool *should_complete, int *ret)
589 struct skcipher_request *areq = skcipher_request_cast(async);
590 struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(areq);
591 struct safexcel_cipher_ctx *ctx = crypto_skcipher_ctx(skcipher);
592 struct safexcel_result_desc *rdesc;
597 if (unlikely(!sreq->rdescs))
600 while (sreq->rdescs--) {
601 rdesc = safexcel_ring_next_rptr(priv, &priv->ring[ring].rdr);
604 "cipher: result: could not retrieve the result descriptor\n");
605 *ret = PTR_ERR(rdesc);
610 *ret = safexcel_rdesc_check_errors(priv, rdesc);
615 safexcel_complete(priv, ring);
618 dma_unmap_sg(priv->dev, src, sreq->nr_src, DMA_BIDIRECTIONAL);
620 dma_unmap_sg(priv->dev, src, sreq->nr_src, DMA_TO_DEVICE);
621 dma_unmap_sg(priv->dev, dst, sreq->nr_dst, DMA_FROM_DEVICE);
625 * Update IV in req from last crypto output word for CBC modes
627 if ((!ctx->aead) && (ctx->mode == CONTEXT_CONTROL_CRYPTO_MODE_CBC) &&
628 (sreq->direction == SAFEXCEL_ENCRYPT)) {
629 /* For encrypt take the last output word */
630 sg_pcopy_to_buffer(dst, sreq->nr_dst, areq->iv,
631 crypto_skcipher_ivsize(skcipher),
633 crypto_skcipher_ivsize(skcipher)));
636 *should_complete = true;
641 static int safexcel_send_req(struct crypto_async_request *base, int ring,
642 struct safexcel_cipher_req *sreq,
643 struct scatterlist *src, struct scatterlist *dst,
644 unsigned int cryptlen, unsigned int assoclen,
645 unsigned int digestsize, u8 *iv, int *commands,
648 struct skcipher_request *areq = skcipher_request_cast(base);
649 struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(areq);
650 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(base->tfm);
651 struct safexcel_crypto_priv *priv = ctx->priv;
652 struct safexcel_command_desc *cdesc;
653 struct safexcel_command_desc *first_cdesc = NULL;
654 struct safexcel_result_desc *rdesc, *first_rdesc = NULL;
655 struct scatterlist *sg;
657 unsigned int totlen_src = cryptlen + assoclen;
658 unsigned int totlen_dst = totlen_src;
659 int n_cdesc = 0, n_rdesc = 0;
660 int queued, i, ret = 0;
663 sreq->nr_src = sg_nents_for_len(src, totlen_src);
667 * AEAD has auth tag appended to output for encrypt and
668 * removed from the output for decrypt!
670 if (sreq->direction == SAFEXCEL_DECRYPT)
671 totlen_dst -= digestsize;
673 totlen_dst += digestsize;
675 memcpy(ctx->base.ctxr->data + ctx->key_len / sizeof(u32),
676 ctx->ipad, ctx->state_sz);
678 memcpy(ctx->base.ctxr->data + (ctx->key_len +
679 ctx->state_sz) / sizeof(u32), ctx->opad,
681 } else if ((ctx->mode == CONTEXT_CONTROL_CRYPTO_MODE_CBC) &&
682 (sreq->direction == SAFEXCEL_DECRYPT)) {
684 * Save IV from last crypto input word for CBC modes in decrypt
685 * direction. Need to do this first in case of inplace operation
686 * as it will be overwritten.
688 sg_pcopy_to_buffer(src, sreq->nr_src, areq->iv,
689 crypto_skcipher_ivsize(skcipher),
691 crypto_skcipher_ivsize(skcipher)));
694 sreq->nr_dst = sg_nents_for_len(dst, totlen_dst);
697 * Remember actual input length, source buffer length may be
698 * updated in case of inline operation below.
704 sreq->nr_src = max(sreq->nr_src, sreq->nr_dst);
705 sreq->nr_dst = sreq->nr_src;
706 if (unlikely((totlen_src || totlen_dst) &&
707 (sreq->nr_src <= 0))) {
708 dev_err(priv->dev, "In-place buffer not large enough (need %d bytes)!",
709 max(totlen_src, totlen_dst));
712 dma_map_sg(priv->dev, src, sreq->nr_src, DMA_BIDIRECTIONAL);
714 if (unlikely(totlen_src && (sreq->nr_src <= 0))) {
715 dev_err(priv->dev, "Source buffer not large enough (need %d bytes)!",
719 dma_map_sg(priv->dev, src, sreq->nr_src, DMA_TO_DEVICE);
721 if (unlikely(totlen_dst && (sreq->nr_dst <= 0))) {
722 dev_err(priv->dev, "Dest buffer not large enough (need %d bytes)!",
724 dma_unmap_sg(priv->dev, src, sreq->nr_src,
728 dma_map_sg(priv->dev, dst, sreq->nr_dst, DMA_FROM_DEVICE);
731 memcpy(ctx->base.ctxr->data, ctx->key, ctx->key_len);
733 /* The EIP cannot deal with zero length input packets! */
737 /* command descriptors */
738 for_each_sg(src, sg, sreq->nr_src, i) {
739 int len = sg_dma_len(sg);
741 /* Do not overflow the request */
742 if (queued - len < 0)
745 cdesc = safexcel_add_cdesc(priv, ring, !n_cdesc,
747 sg_dma_address(sg), len, totlen,
750 /* No space left in the command descriptor ring */
751 ret = PTR_ERR(cdesc);
765 if (unlikely(!n_cdesc)) {
767 * Special case: zero length input buffer.
768 * The engine always needs the 1st command descriptor, however!
770 first_cdesc = safexcel_add_cdesc(priv, ring, 1, 1, 0, 0, totlen,
775 /* Add context control words and token to first command descriptor */
776 safexcel_context_control(ctx, base, sreq, first_cdesc);
778 safexcel_aead_token(ctx, iv, first_cdesc,
779 sreq->direction, cryptlen,
780 assoclen, digestsize);
782 safexcel_skcipher_token(ctx, iv, first_cdesc,
785 /* result descriptors */
786 for_each_sg(dst, sg, sreq->nr_dst, i) {
787 bool last = (i == sreq->nr_dst - 1);
788 u32 len = sg_dma_len(sg);
790 /* only allow the part of the buffer we know we need */
791 if (len > totlen_dst)
797 /* skip over AAD space in buffer - not written */
799 if (assoclen >= len) {
803 rdesc = safexcel_add_rdesc(priv, ring, first, last,
809 rdesc = safexcel_add_rdesc(priv, ring, first, last,
814 /* No space left in the result descriptor ring */
815 ret = PTR_ERR(rdesc);
825 if (unlikely(first)) {
827 * Special case: AEAD decrypt with only AAD data.
828 * In this case there is NO output data from the engine,
829 * but the engine still needs a result descriptor!
830 * Create a dummy one just for catching the result token.
832 rdesc = safexcel_add_rdesc(priv, ring, true, true, 0, 0);
834 /* No space left in the result descriptor ring */
835 ret = PTR_ERR(rdesc);
842 safexcel_rdr_req_set(priv, ring, first_rdesc, base);
849 for (i = 0; i < n_rdesc; i++)
850 safexcel_ring_rollback_wptr(priv, &priv->ring[ring].rdr);
852 for (i = 0; i < n_cdesc; i++)
853 safexcel_ring_rollback_wptr(priv, &priv->ring[ring].cdr);
856 dma_unmap_sg(priv->dev, src, sreq->nr_src, DMA_BIDIRECTIONAL);
858 dma_unmap_sg(priv->dev, src, sreq->nr_src, DMA_TO_DEVICE);
859 dma_unmap_sg(priv->dev, dst, sreq->nr_dst, DMA_FROM_DEVICE);
865 static int safexcel_handle_inv_result(struct safexcel_crypto_priv *priv,
867 struct crypto_async_request *base,
868 struct safexcel_cipher_req *sreq,
869 bool *should_complete, int *ret)
871 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(base->tfm);
872 struct safexcel_result_desc *rdesc;
873 int ndesc = 0, enq_ret;
877 if (unlikely(!sreq->rdescs))
880 while (sreq->rdescs--) {
881 rdesc = safexcel_ring_next_rptr(priv, &priv->ring[ring].rdr);
884 "cipher: invalidate: could not retrieve the result descriptor\n");
885 *ret = PTR_ERR(rdesc);
890 *ret = safexcel_rdesc_check_errors(priv, rdesc);
895 safexcel_complete(priv, ring);
897 if (ctx->base.exit_inv) {
898 dma_pool_free(priv->context_pool, ctx->base.ctxr,
901 *should_complete = true;
906 ring = safexcel_select_ring(priv);
907 ctx->base.ring = ring;
909 spin_lock_bh(&priv->ring[ring].queue_lock);
910 enq_ret = crypto_enqueue_request(&priv->ring[ring].queue, base);
911 spin_unlock_bh(&priv->ring[ring].queue_lock);
913 if (enq_ret != -EINPROGRESS)
916 queue_work(priv->ring[ring].workqueue,
917 &priv->ring[ring].work_data.work);
919 *should_complete = false;
924 static int safexcel_skcipher_handle_result(struct safexcel_crypto_priv *priv,
926 struct crypto_async_request *async,
927 bool *should_complete, int *ret)
929 struct skcipher_request *req = skcipher_request_cast(async);
930 struct safexcel_cipher_req *sreq = skcipher_request_ctx(req);
933 if (sreq->needs_inv) {
934 sreq->needs_inv = false;
935 err = safexcel_handle_inv_result(priv, ring, async, sreq,
936 should_complete, ret);
938 err = safexcel_handle_req_result(priv, ring, async, req->src,
939 req->dst, req->cryptlen, sreq,
940 should_complete, ret);
946 static int safexcel_aead_handle_result(struct safexcel_crypto_priv *priv,
948 struct crypto_async_request *async,
949 bool *should_complete, int *ret)
951 struct aead_request *req = aead_request_cast(async);
952 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
953 struct safexcel_cipher_req *sreq = aead_request_ctx(req);
956 if (sreq->needs_inv) {
957 sreq->needs_inv = false;
958 err = safexcel_handle_inv_result(priv, ring, async, sreq,
959 should_complete, ret);
961 err = safexcel_handle_req_result(priv, ring, async, req->src,
963 req->cryptlen + crypto_aead_authsize(tfm),
964 sreq, should_complete, ret);
970 static int safexcel_cipher_send_inv(struct crypto_async_request *base,
971 int ring, int *commands, int *results)
973 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(base->tfm);
974 struct safexcel_crypto_priv *priv = ctx->priv;
977 ret = safexcel_invalidate_cache(base, priv, ctx->base.ctxr_dma, ring);
987 static int safexcel_skcipher_send(struct crypto_async_request *async, int ring,
988 int *commands, int *results)
990 struct skcipher_request *req = skcipher_request_cast(async);
991 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
992 struct safexcel_cipher_req *sreq = skcipher_request_ctx(req);
993 struct safexcel_crypto_priv *priv = ctx->priv;
996 BUG_ON(!(priv->flags & EIP197_TRC_CACHE) && sreq->needs_inv);
998 if (sreq->needs_inv) {
999 ret = safexcel_cipher_send_inv(async, ring, commands, results);
1001 struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
1002 u8 input_iv[AES_BLOCK_SIZE];
1005 * Save input IV in case of CBC decrypt mode
1006 * Will be overwritten with output IV prior to use!
1008 memcpy(input_iv, req->iv, crypto_skcipher_ivsize(skcipher));
1010 ret = safexcel_send_req(async, ring, sreq, req->src,
1011 req->dst, req->cryptlen, 0, 0, input_iv,
1015 sreq->rdescs = *results;
1019 static int safexcel_aead_send(struct crypto_async_request *async, int ring,
1020 int *commands, int *results)
1022 struct aead_request *req = aead_request_cast(async);
1023 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
1024 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
1025 struct safexcel_cipher_req *sreq = aead_request_ctx(req);
1026 struct safexcel_crypto_priv *priv = ctx->priv;
1029 BUG_ON(!(priv->flags & EIP197_TRC_CACHE) && sreq->needs_inv);
1031 if (sreq->needs_inv)
1032 ret = safexcel_cipher_send_inv(async, ring, commands, results);
1034 ret = safexcel_send_req(async, ring, sreq, req->src, req->dst,
1035 req->cryptlen, req->assoclen,
1036 crypto_aead_authsize(tfm), req->iv,
1038 sreq->rdescs = *results;
1042 static int safexcel_cipher_exit_inv(struct crypto_tfm *tfm,
1043 struct crypto_async_request *base,
1044 struct safexcel_cipher_req *sreq,
1045 struct safexcel_inv_result *result)
1047 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1048 struct safexcel_crypto_priv *priv = ctx->priv;
1049 int ring = ctx->base.ring;
1051 init_completion(&result->completion);
1053 ctx = crypto_tfm_ctx(base->tfm);
1054 ctx->base.exit_inv = true;
1055 sreq->needs_inv = true;
1057 spin_lock_bh(&priv->ring[ring].queue_lock);
1058 crypto_enqueue_request(&priv->ring[ring].queue, base);
1059 spin_unlock_bh(&priv->ring[ring].queue_lock);
1061 queue_work(priv->ring[ring].workqueue,
1062 &priv->ring[ring].work_data.work);
1064 wait_for_completion(&result->completion);
1066 if (result->error) {
1068 "cipher: sync: invalidate: completion error %d\n",
1070 return result->error;
1076 static int safexcel_skcipher_exit_inv(struct crypto_tfm *tfm)
1078 EIP197_REQUEST_ON_STACK(req, skcipher, EIP197_SKCIPHER_REQ_SIZE);
1079 struct safexcel_cipher_req *sreq = skcipher_request_ctx(req);
1080 struct safexcel_inv_result result = {};
1082 memset(req, 0, sizeof(struct skcipher_request));
1084 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1085 safexcel_inv_complete, &result);
1086 skcipher_request_set_tfm(req, __crypto_skcipher_cast(tfm));
1088 return safexcel_cipher_exit_inv(tfm, &req->base, sreq, &result);
1091 static int safexcel_aead_exit_inv(struct crypto_tfm *tfm)
1093 EIP197_REQUEST_ON_STACK(req, aead, EIP197_AEAD_REQ_SIZE);
1094 struct safexcel_cipher_req *sreq = aead_request_ctx(req);
1095 struct safexcel_inv_result result = {};
1097 memset(req, 0, sizeof(struct aead_request));
1099 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1100 safexcel_inv_complete, &result);
1101 aead_request_set_tfm(req, __crypto_aead_cast(tfm));
1103 return safexcel_cipher_exit_inv(tfm, &req->base, sreq, &result);
1106 static int safexcel_queue_req(struct crypto_async_request *base,
1107 struct safexcel_cipher_req *sreq,
1108 enum safexcel_cipher_direction dir)
1110 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(base->tfm);
1111 struct safexcel_crypto_priv *priv = ctx->priv;
1114 sreq->needs_inv = false;
1115 sreq->direction = dir;
1117 if (ctx->base.ctxr) {
1118 if (priv->flags & EIP197_TRC_CACHE && ctx->base.needs_inv) {
1119 sreq->needs_inv = true;
1120 ctx->base.needs_inv = false;
1123 ctx->base.ring = safexcel_select_ring(priv);
1124 ctx->base.ctxr = dma_pool_zalloc(priv->context_pool,
1125 EIP197_GFP_FLAGS(*base),
1126 &ctx->base.ctxr_dma);
1127 if (!ctx->base.ctxr)
1131 ring = ctx->base.ring;
1133 spin_lock_bh(&priv->ring[ring].queue_lock);
1134 ret = crypto_enqueue_request(&priv->ring[ring].queue, base);
1135 spin_unlock_bh(&priv->ring[ring].queue_lock);
1137 queue_work(priv->ring[ring].workqueue,
1138 &priv->ring[ring].work_data.work);
1143 static int safexcel_encrypt(struct skcipher_request *req)
1145 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
1149 static int safexcel_decrypt(struct skcipher_request *req)
1151 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
1155 static int safexcel_skcipher_cra_init(struct crypto_tfm *tfm)
1157 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1158 struct safexcel_alg_template *tmpl =
1159 container_of(tfm->__crt_alg, struct safexcel_alg_template,
1162 crypto_skcipher_set_reqsize(__crypto_skcipher_cast(tfm),
1163 sizeof(struct safexcel_cipher_req));
1165 ctx->priv = tmpl->priv;
1167 ctx->base.send = safexcel_skcipher_send;
1168 ctx->base.handle_result = safexcel_skcipher_handle_result;
1172 static int safexcel_cipher_cra_exit(struct crypto_tfm *tfm)
1174 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1176 memzero_explicit(ctx->key, sizeof(ctx->key));
1178 /* context not allocated, skip invalidation */
1179 if (!ctx->base.ctxr)
1182 memzero_explicit(ctx->base.ctxr->data, sizeof(ctx->base.ctxr->data));
1186 static void safexcel_skcipher_cra_exit(struct crypto_tfm *tfm)
1188 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1189 struct safexcel_crypto_priv *priv = ctx->priv;
1192 if (safexcel_cipher_cra_exit(tfm))
1195 if (priv->flags & EIP197_TRC_CACHE) {
1196 ret = safexcel_skcipher_exit_inv(tfm);
1198 dev_warn(priv->dev, "skcipher: invalidation error %d\n",
1201 dma_pool_free(priv->context_pool, ctx->base.ctxr,
1202 ctx->base.ctxr_dma);
1206 static void safexcel_aead_cra_exit(struct crypto_tfm *tfm)
1208 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1209 struct safexcel_crypto_priv *priv = ctx->priv;
1212 if (safexcel_cipher_cra_exit(tfm))
1215 if (priv->flags & EIP197_TRC_CACHE) {
1216 ret = safexcel_aead_exit_inv(tfm);
1218 dev_warn(priv->dev, "aead: invalidation error %d\n",
1221 dma_pool_free(priv->context_pool, ctx->base.ctxr,
1222 ctx->base.ctxr_dma);
1226 static int safexcel_skcipher_aes_ecb_cra_init(struct crypto_tfm *tfm)
1228 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1230 safexcel_skcipher_cra_init(tfm);
1231 ctx->alg = SAFEXCEL_AES;
1232 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_ECB;
1236 struct safexcel_alg_template safexcel_alg_ecb_aes = {
1237 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1238 .algo_mask = SAFEXCEL_ALG_AES,
1240 .setkey = safexcel_skcipher_aes_setkey,
1241 .encrypt = safexcel_encrypt,
1242 .decrypt = safexcel_decrypt,
1243 .min_keysize = AES_MIN_KEY_SIZE,
1244 .max_keysize = AES_MAX_KEY_SIZE,
1246 .cra_name = "ecb(aes)",
1247 .cra_driver_name = "safexcel-ecb-aes",
1248 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1249 .cra_flags = CRYPTO_ALG_ASYNC |
1250 CRYPTO_ALG_KERN_DRIVER_ONLY,
1251 .cra_blocksize = AES_BLOCK_SIZE,
1252 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1254 .cra_init = safexcel_skcipher_aes_ecb_cra_init,
1255 .cra_exit = safexcel_skcipher_cra_exit,
1256 .cra_module = THIS_MODULE,
1261 static int safexcel_skcipher_aes_cbc_cra_init(struct crypto_tfm *tfm)
1263 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1265 safexcel_skcipher_cra_init(tfm);
1266 ctx->alg = SAFEXCEL_AES;
1267 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CBC;
1271 struct safexcel_alg_template safexcel_alg_cbc_aes = {
1272 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1273 .algo_mask = SAFEXCEL_ALG_AES,
1275 .setkey = safexcel_skcipher_aes_setkey,
1276 .encrypt = safexcel_encrypt,
1277 .decrypt = safexcel_decrypt,
1278 .min_keysize = AES_MIN_KEY_SIZE,
1279 .max_keysize = AES_MAX_KEY_SIZE,
1280 .ivsize = AES_BLOCK_SIZE,
1282 .cra_name = "cbc(aes)",
1283 .cra_driver_name = "safexcel-cbc-aes",
1284 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1285 .cra_flags = CRYPTO_ALG_ASYNC |
1286 CRYPTO_ALG_KERN_DRIVER_ONLY,
1287 .cra_blocksize = AES_BLOCK_SIZE,
1288 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1290 .cra_init = safexcel_skcipher_aes_cbc_cra_init,
1291 .cra_exit = safexcel_skcipher_cra_exit,
1292 .cra_module = THIS_MODULE,
1297 static int safexcel_skcipher_aes_cfb_cra_init(struct crypto_tfm *tfm)
1299 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1301 safexcel_skcipher_cra_init(tfm);
1302 ctx->alg = SAFEXCEL_AES;
1303 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CFB;
1307 struct safexcel_alg_template safexcel_alg_cfb_aes = {
1308 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1309 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_AES_XFB,
1311 .setkey = safexcel_skcipher_aes_setkey,
1312 .encrypt = safexcel_encrypt,
1313 .decrypt = safexcel_decrypt,
1314 .min_keysize = AES_MIN_KEY_SIZE,
1315 .max_keysize = AES_MAX_KEY_SIZE,
1316 .ivsize = AES_BLOCK_SIZE,
1318 .cra_name = "cfb(aes)",
1319 .cra_driver_name = "safexcel-cfb-aes",
1320 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1321 .cra_flags = CRYPTO_ALG_ASYNC |
1322 CRYPTO_ALG_KERN_DRIVER_ONLY,
1324 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1326 .cra_init = safexcel_skcipher_aes_cfb_cra_init,
1327 .cra_exit = safexcel_skcipher_cra_exit,
1328 .cra_module = THIS_MODULE,
1333 static int safexcel_skcipher_aes_ofb_cra_init(struct crypto_tfm *tfm)
1335 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1337 safexcel_skcipher_cra_init(tfm);
1338 ctx->alg = SAFEXCEL_AES;
1339 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_OFB;
1343 struct safexcel_alg_template safexcel_alg_ofb_aes = {
1344 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1345 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_AES_XFB,
1347 .setkey = safexcel_skcipher_aes_setkey,
1348 .encrypt = safexcel_encrypt,
1349 .decrypt = safexcel_decrypt,
1350 .min_keysize = AES_MIN_KEY_SIZE,
1351 .max_keysize = AES_MAX_KEY_SIZE,
1352 .ivsize = AES_BLOCK_SIZE,
1354 .cra_name = "ofb(aes)",
1355 .cra_driver_name = "safexcel-ofb-aes",
1356 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1357 .cra_flags = CRYPTO_ALG_ASYNC |
1358 CRYPTO_ALG_KERN_DRIVER_ONLY,
1360 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1362 .cra_init = safexcel_skcipher_aes_ofb_cra_init,
1363 .cra_exit = safexcel_skcipher_cra_exit,
1364 .cra_module = THIS_MODULE,
1369 static int safexcel_skcipher_aesctr_setkey(struct crypto_skcipher *ctfm,
1370 const u8 *key, unsigned int len)
1372 struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
1373 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1374 struct safexcel_crypto_priv *priv = ctx->priv;
1375 struct crypto_aes_ctx aes;
1377 unsigned int keylen;
1379 /* last 4 bytes of key are the nonce! */
1380 ctx->nonce = *(u32 *)(key + len - CTR_RFC3686_NONCE_SIZE);
1381 /* exclude the nonce here */
1382 keylen = len - CTR_RFC3686_NONCE_SIZE;
1383 ret = aes_expandkey(&aes, key, keylen);
1385 crypto_skcipher_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
1389 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
1390 for (i = 0; i < keylen / sizeof(u32); i++) {
1391 if (le32_to_cpu(ctx->key[i]) != aes.key_enc[i]) {
1392 ctx->base.needs_inv = true;
1398 for (i = 0; i < keylen / sizeof(u32); i++)
1399 ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
1401 ctx->key_len = keylen;
1403 memzero_explicit(&aes, sizeof(aes));
1407 static int safexcel_skcipher_aes_ctr_cra_init(struct crypto_tfm *tfm)
1409 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1411 safexcel_skcipher_cra_init(tfm);
1412 ctx->alg = SAFEXCEL_AES;
1413 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD;
1417 struct safexcel_alg_template safexcel_alg_ctr_aes = {
1418 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1419 .algo_mask = SAFEXCEL_ALG_AES,
1421 .setkey = safexcel_skcipher_aesctr_setkey,
1422 .encrypt = safexcel_encrypt,
1423 .decrypt = safexcel_decrypt,
1424 /* Add nonce size */
1425 .min_keysize = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
1426 .max_keysize = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
1427 .ivsize = CTR_RFC3686_IV_SIZE,
1429 .cra_name = "rfc3686(ctr(aes))",
1430 .cra_driver_name = "safexcel-ctr-aes",
1431 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1432 .cra_flags = CRYPTO_ALG_ASYNC |
1433 CRYPTO_ALG_KERN_DRIVER_ONLY,
1435 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1437 .cra_init = safexcel_skcipher_aes_ctr_cra_init,
1438 .cra_exit = safexcel_skcipher_cra_exit,
1439 .cra_module = THIS_MODULE,
1444 static int safexcel_des_setkey(struct crypto_skcipher *ctfm, const u8 *key,
1447 struct safexcel_cipher_ctx *ctx = crypto_skcipher_ctx(ctfm);
1450 ret = verify_skcipher_des_key(ctfm, key);
1454 /* if context exits and key changed, need to invalidate it */
1455 if (ctx->base.ctxr_dma)
1456 if (memcmp(ctx->key, key, len))
1457 ctx->base.needs_inv = true;
1459 memcpy(ctx->key, key, len);
1465 static int safexcel_skcipher_des_cbc_cra_init(struct crypto_tfm *tfm)
1467 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1469 safexcel_skcipher_cra_init(tfm);
1470 ctx->alg = SAFEXCEL_DES;
1471 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CBC;
1475 struct safexcel_alg_template safexcel_alg_cbc_des = {
1476 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1477 .algo_mask = SAFEXCEL_ALG_DES,
1479 .setkey = safexcel_des_setkey,
1480 .encrypt = safexcel_encrypt,
1481 .decrypt = safexcel_decrypt,
1482 .min_keysize = DES_KEY_SIZE,
1483 .max_keysize = DES_KEY_SIZE,
1484 .ivsize = DES_BLOCK_SIZE,
1486 .cra_name = "cbc(des)",
1487 .cra_driver_name = "safexcel-cbc-des",
1488 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1489 .cra_flags = CRYPTO_ALG_ASYNC |
1490 CRYPTO_ALG_KERN_DRIVER_ONLY,
1491 .cra_blocksize = DES_BLOCK_SIZE,
1492 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1494 .cra_init = safexcel_skcipher_des_cbc_cra_init,
1495 .cra_exit = safexcel_skcipher_cra_exit,
1496 .cra_module = THIS_MODULE,
1501 static int safexcel_skcipher_des_ecb_cra_init(struct crypto_tfm *tfm)
1503 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1505 safexcel_skcipher_cra_init(tfm);
1506 ctx->alg = SAFEXCEL_DES;
1507 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_ECB;
1511 struct safexcel_alg_template safexcel_alg_ecb_des = {
1512 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1513 .algo_mask = SAFEXCEL_ALG_DES,
1515 .setkey = safexcel_des_setkey,
1516 .encrypt = safexcel_encrypt,
1517 .decrypt = safexcel_decrypt,
1518 .min_keysize = DES_KEY_SIZE,
1519 .max_keysize = DES_KEY_SIZE,
1521 .cra_name = "ecb(des)",
1522 .cra_driver_name = "safexcel-ecb-des",
1523 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1524 .cra_flags = CRYPTO_ALG_ASYNC |
1525 CRYPTO_ALG_KERN_DRIVER_ONLY,
1526 .cra_blocksize = DES_BLOCK_SIZE,
1527 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1529 .cra_init = safexcel_skcipher_des_ecb_cra_init,
1530 .cra_exit = safexcel_skcipher_cra_exit,
1531 .cra_module = THIS_MODULE,
1536 static int safexcel_des3_ede_setkey(struct crypto_skcipher *ctfm,
1537 const u8 *key, unsigned int len)
1539 struct safexcel_cipher_ctx *ctx = crypto_skcipher_ctx(ctfm);
1542 err = verify_skcipher_des3_key(ctfm, key);
1546 /* if context exits and key changed, need to invalidate it */
1547 if (ctx->base.ctxr_dma)
1548 if (memcmp(ctx->key, key, len))
1549 ctx->base.needs_inv = true;
1551 memcpy(ctx->key, key, len);
1557 static int safexcel_skcipher_des3_cbc_cra_init(struct crypto_tfm *tfm)
1559 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1561 safexcel_skcipher_cra_init(tfm);
1562 ctx->alg = SAFEXCEL_3DES;
1563 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CBC;
1567 struct safexcel_alg_template safexcel_alg_cbc_des3_ede = {
1568 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1569 .algo_mask = SAFEXCEL_ALG_DES,
1571 .setkey = safexcel_des3_ede_setkey,
1572 .encrypt = safexcel_encrypt,
1573 .decrypt = safexcel_decrypt,
1574 .min_keysize = DES3_EDE_KEY_SIZE,
1575 .max_keysize = DES3_EDE_KEY_SIZE,
1576 .ivsize = DES3_EDE_BLOCK_SIZE,
1578 .cra_name = "cbc(des3_ede)",
1579 .cra_driver_name = "safexcel-cbc-des3_ede",
1580 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1581 .cra_flags = CRYPTO_ALG_ASYNC |
1582 CRYPTO_ALG_KERN_DRIVER_ONLY,
1583 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1584 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1586 .cra_init = safexcel_skcipher_des3_cbc_cra_init,
1587 .cra_exit = safexcel_skcipher_cra_exit,
1588 .cra_module = THIS_MODULE,
1593 static int safexcel_skcipher_des3_ecb_cra_init(struct crypto_tfm *tfm)
1595 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1597 safexcel_skcipher_cra_init(tfm);
1598 ctx->alg = SAFEXCEL_3DES;
1599 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_ECB;
1603 struct safexcel_alg_template safexcel_alg_ecb_des3_ede = {
1604 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
1605 .algo_mask = SAFEXCEL_ALG_DES,
1607 .setkey = safexcel_des3_ede_setkey,
1608 .encrypt = safexcel_encrypt,
1609 .decrypt = safexcel_decrypt,
1610 .min_keysize = DES3_EDE_KEY_SIZE,
1611 .max_keysize = DES3_EDE_KEY_SIZE,
1613 .cra_name = "ecb(des3_ede)",
1614 .cra_driver_name = "safexcel-ecb-des3_ede",
1615 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1616 .cra_flags = CRYPTO_ALG_ASYNC |
1617 CRYPTO_ALG_KERN_DRIVER_ONLY,
1618 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1619 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1621 .cra_init = safexcel_skcipher_des3_ecb_cra_init,
1622 .cra_exit = safexcel_skcipher_cra_exit,
1623 .cra_module = THIS_MODULE,
1628 static int safexcel_aead_encrypt(struct aead_request *req)
1630 struct safexcel_cipher_req *creq = aead_request_ctx(req);
1632 return safexcel_queue_req(&req->base, creq, SAFEXCEL_ENCRYPT);
1635 static int safexcel_aead_decrypt(struct aead_request *req)
1637 struct safexcel_cipher_req *creq = aead_request_ctx(req);
1639 return safexcel_queue_req(&req->base, creq, SAFEXCEL_DECRYPT);
1642 static int safexcel_aead_cra_init(struct crypto_tfm *tfm)
1644 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1645 struct safexcel_alg_template *tmpl =
1646 container_of(tfm->__crt_alg, struct safexcel_alg_template,
1649 crypto_aead_set_reqsize(__crypto_aead_cast(tfm),
1650 sizeof(struct safexcel_cipher_req));
1652 ctx->priv = tmpl->priv;
1654 ctx->alg = SAFEXCEL_AES; /* default */
1655 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CBC; /* default */
1657 ctx->base.send = safexcel_aead_send;
1658 ctx->base.handle_result = safexcel_aead_handle_result;
1662 static int safexcel_aead_sha1_cra_init(struct crypto_tfm *tfm)
1664 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1666 safexcel_aead_cra_init(tfm);
1667 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA1;
1668 ctx->state_sz = SHA1_DIGEST_SIZE;
1672 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_cbc_aes = {
1673 .type = SAFEXCEL_ALG_TYPE_AEAD,
1674 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA1,
1676 .setkey = safexcel_aead_setkey,
1677 .encrypt = safexcel_aead_encrypt,
1678 .decrypt = safexcel_aead_decrypt,
1679 .ivsize = AES_BLOCK_SIZE,
1680 .maxauthsize = SHA1_DIGEST_SIZE,
1682 .cra_name = "authenc(hmac(sha1),cbc(aes))",
1683 .cra_driver_name = "safexcel-authenc-hmac-sha1-cbc-aes",
1684 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1685 .cra_flags = CRYPTO_ALG_ASYNC |
1686 CRYPTO_ALG_KERN_DRIVER_ONLY,
1687 .cra_blocksize = AES_BLOCK_SIZE,
1688 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1690 .cra_init = safexcel_aead_sha1_cra_init,
1691 .cra_exit = safexcel_aead_cra_exit,
1692 .cra_module = THIS_MODULE,
1697 static int safexcel_aead_sha256_cra_init(struct crypto_tfm *tfm)
1699 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1701 safexcel_aead_cra_init(tfm);
1702 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA256;
1703 ctx->state_sz = SHA256_DIGEST_SIZE;
1707 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha256_cbc_aes = {
1708 .type = SAFEXCEL_ALG_TYPE_AEAD,
1709 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_256,
1711 .setkey = safexcel_aead_setkey,
1712 .encrypt = safexcel_aead_encrypt,
1713 .decrypt = safexcel_aead_decrypt,
1714 .ivsize = AES_BLOCK_SIZE,
1715 .maxauthsize = SHA256_DIGEST_SIZE,
1717 .cra_name = "authenc(hmac(sha256),cbc(aes))",
1718 .cra_driver_name = "safexcel-authenc-hmac-sha256-cbc-aes",
1719 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1720 .cra_flags = CRYPTO_ALG_ASYNC |
1721 CRYPTO_ALG_KERN_DRIVER_ONLY,
1722 .cra_blocksize = AES_BLOCK_SIZE,
1723 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1725 .cra_init = safexcel_aead_sha256_cra_init,
1726 .cra_exit = safexcel_aead_cra_exit,
1727 .cra_module = THIS_MODULE,
1732 static int safexcel_aead_sha224_cra_init(struct crypto_tfm *tfm)
1734 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1736 safexcel_aead_cra_init(tfm);
1737 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA224;
1738 ctx->state_sz = SHA256_DIGEST_SIZE;
1742 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha224_cbc_aes = {
1743 .type = SAFEXCEL_ALG_TYPE_AEAD,
1744 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_256,
1746 .setkey = safexcel_aead_setkey,
1747 .encrypt = safexcel_aead_encrypt,
1748 .decrypt = safexcel_aead_decrypt,
1749 .ivsize = AES_BLOCK_SIZE,
1750 .maxauthsize = SHA224_DIGEST_SIZE,
1752 .cra_name = "authenc(hmac(sha224),cbc(aes))",
1753 .cra_driver_name = "safexcel-authenc-hmac-sha224-cbc-aes",
1754 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1755 .cra_flags = CRYPTO_ALG_ASYNC |
1756 CRYPTO_ALG_KERN_DRIVER_ONLY,
1757 .cra_blocksize = AES_BLOCK_SIZE,
1758 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1760 .cra_init = safexcel_aead_sha224_cra_init,
1761 .cra_exit = safexcel_aead_cra_exit,
1762 .cra_module = THIS_MODULE,
1767 static int safexcel_aead_sha512_cra_init(struct crypto_tfm *tfm)
1769 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1771 safexcel_aead_cra_init(tfm);
1772 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA512;
1773 ctx->state_sz = SHA512_DIGEST_SIZE;
1777 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha512_cbc_aes = {
1778 .type = SAFEXCEL_ALG_TYPE_AEAD,
1779 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_512,
1781 .setkey = safexcel_aead_setkey,
1782 .encrypt = safexcel_aead_encrypt,
1783 .decrypt = safexcel_aead_decrypt,
1784 .ivsize = AES_BLOCK_SIZE,
1785 .maxauthsize = SHA512_DIGEST_SIZE,
1787 .cra_name = "authenc(hmac(sha512),cbc(aes))",
1788 .cra_driver_name = "safexcel-authenc-hmac-sha512-cbc-aes",
1789 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1790 .cra_flags = CRYPTO_ALG_ASYNC |
1791 CRYPTO_ALG_KERN_DRIVER_ONLY,
1792 .cra_blocksize = AES_BLOCK_SIZE,
1793 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1795 .cra_init = safexcel_aead_sha512_cra_init,
1796 .cra_exit = safexcel_aead_cra_exit,
1797 .cra_module = THIS_MODULE,
1802 static int safexcel_aead_sha384_cra_init(struct crypto_tfm *tfm)
1804 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1806 safexcel_aead_cra_init(tfm);
1807 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA384;
1808 ctx->state_sz = SHA512_DIGEST_SIZE;
1812 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha384_cbc_aes = {
1813 .type = SAFEXCEL_ALG_TYPE_AEAD,
1814 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_512,
1816 .setkey = safexcel_aead_setkey,
1817 .encrypt = safexcel_aead_encrypt,
1818 .decrypt = safexcel_aead_decrypt,
1819 .ivsize = AES_BLOCK_SIZE,
1820 .maxauthsize = SHA384_DIGEST_SIZE,
1822 .cra_name = "authenc(hmac(sha384),cbc(aes))",
1823 .cra_driver_name = "safexcel-authenc-hmac-sha384-cbc-aes",
1824 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1825 .cra_flags = CRYPTO_ALG_ASYNC |
1826 CRYPTO_ALG_KERN_DRIVER_ONLY,
1827 .cra_blocksize = AES_BLOCK_SIZE,
1828 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1830 .cra_init = safexcel_aead_sha384_cra_init,
1831 .cra_exit = safexcel_aead_cra_exit,
1832 .cra_module = THIS_MODULE,
1837 static int safexcel_aead_sha1_des3_cra_init(struct crypto_tfm *tfm)
1839 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1841 safexcel_aead_sha1_cra_init(tfm);
1842 ctx->alg = SAFEXCEL_3DES; /* override default */
1846 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_cbc_des3_ede = {
1847 .type = SAFEXCEL_ALG_TYPE_AEAD,
1848 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA1,
1850 .setkey = safexcel_aead_setkey,
1851 .encrypt = safexcel_aead_encrypt,
1852 .decrypt = safexcel_aead_decrypt,
1853 .ivsize = DES3_EDE_BLOCK_SIZE,
1854 .maxauthsize = SHA1_DIGEST_SIZE,
1856 .cra_name = "authenc(hmac(sha1),cbc(des3_ede))",
1857 .cra_driver_name = "safexcel-authenc-hmac-sha1-cbc-des3_ede",
1858 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1859 .cra_flags = CRYPTO_ALG_ASYNC |
1860 CRYPTO_ALG_KERN_DRIVER_ONLY,
1861 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1862 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1864 .cra_init = safexcel_aead_sha1_des3_cra_init,
1865 .cra_exit = safexcel_aead_cra_exit,
1866 .cra_module = THIS_MODULE,
1871 static int safexcel_aead_sha256_des3_cra_init(struct crypto_tfm *tfm)
1873 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1875 safexcel_aead_sha256_cra_init(tfm);
1876 ctx->alg = SAFEXCEL_3DES; /* override default */
1880 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha256_cbc_des3_ede = {
1881 .type = SAFEXCEL_ALG_TYPE_AEAD,
1882 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_256,
1884 .setkey = safexcel_aead_setkey,
1885 .encrypt = safexcel_aead_encrypt,
1886 .decrypt = safexcel_aead_decrypt,
1887 .ivsize = DES3_EDE_BLOCK_SIZE,
1888 .maxauthsize = SHA256_DIGEST_SIZE,
1890 .cra_name = "authenc(hmac(sha256),cbc(des3_ede))",
1891 .cra_driver_name = "safexcel-authenc-hmac-sha256-cbc-des3_ede",
1892 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1893 .cra_flags = CRYPTO_ALG_ASYNC |
1894 CRYPTO_ALG_KERN_DRIVER_ONLY,
1895 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1896 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1898 .cra_init = safexcel_aead_sha256_des3_cra_init,
1899 .cra_exit = safexcel_aead_cra_exit,
1900 .cra_module = THIS_MODULE,
1905 static int safexcel_aead_sha224_des3_cra_init(struct crypto_tfm *tfm)
1907 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1909 safexcel_aead_sha224_cra_init(tfm);
1910 ctx->alg = SAFEXCEL_3DES; /* override default */
1914 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha224_cbc_des3_ede = {
1915 .type = SAFEXCEL_ALG_TYPE_AEAD,
1916 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_256,
1918 .setkey = safexcel_aead_setkey,
1919 .encrypt = safexcel_aead_encrypt,
1920 .decrypt = safexcel_aead_decrypt,
1921 .ivsize = DES3_EDE_BLOCK_SIZE,
1922 .maxauthsize = SHA224_DIGEST_SIZE,
1924 .cra_name = "authenc(hmac(sha224),cbc(des3_ede))",
1925 .cra_driver_name = "safexcel-authenc-hmac-sha224-cbc-des3_ede",
1926 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1927 .cra_flags = CRYPTO_ALG_ASYNC |
1928 CRYPTO_ALG_KERN_DRIVER_ONLY,
1929 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1930 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1932 .cra_init = safexcel_aead_sha224_des3_cra_init,
1933 .cra_exit = safexcel_aead_cra_exit,
1934 .cra_module = THIS_MODULE,
1939 static int safexcel_aead_sha512_des3_cra_init(struct crypto_tfm *tfm)
1941 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1943 safexcel_aead_sha512_cra_init(tfm);
1944 ctx->alg = SAFEXCEL_3DES; /* override default */
1948 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha512_cbc_des3_ede = {
1949 .type = SAFEXCEL_ALG_TYPE_AEAD,
1950 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_512,
1952 .setkey = safexcel_aead_setkey,
1953 .encrypt = safexcel_aead_encrypt,
1954 .decrypt = safexcel_aead_decrypt,
1955 .ivsize = DES3_EDE_BLOCK_SIZE,
1956 .maxauthsize = SHA512_DIGEST_SIZE,
1958 .cra_name = "authenc(hmac(sha512),cbc(des3_ede))",
1959 .cra_driver_name = "safexcel-authenc-hmac-sha512-cbc-des3_ede",
1960 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1961 .cra_flags = CRYPTO_ALG_ASYNC |
1962 CRYPTO_ALG_KERN_DRIVER_ONLY,
1963 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1964 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
1966 .cra_init = safexcel_aead_sha512_des3_cra_init,
1967 .cra_exit = safexcel_aead_cra_exit,
1968 .cra_module = THIS_MODULE,
1973 static int safexcel_aead_sha384_des3_cra_init(struct crypto_tfm *tfm)
1975 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
1977 safexcel_aead_sha384_cra_init(tfm);
1978 ctx->alg = SAFEXCEL_3DES; /* override default */
1982 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha384_cbc_des3_ede = {
1983 .type = SAFEXCEL_ALG_TYPE_AEAD,
1984 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_512,
1986 .setkey = safexcel_aead_setkey,
1987 .encrypt = safexcel_aead_encrypt,
1988 .decrypt = safexcel_aead_decrypt,
1989 .ivsize = DES3_EDE_BLOCK_SIZE,
1990 .maxauthsize = SHA384_DIGEST_SIZE,
1992 .cra_name = "authenc(hmac(sha384),cbc(des3_ede))",
1993 .cra_driver_name = "safexcel-authenc-hmac-sha384-cbc-des3_ede",
1994 .cra_priority = SAFEXCEL_CRA_PRIORITY,
1995 .cra_flags = CRYPTO_ALG_ASYNC |
1996 CRYPTO_ALG_KERN_DRIVER_ONLY,
1997 .cra_blocksize = DES3_EDE_BLOCK_SIZE,
1998 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2000 .cra_init = safexcel_aead_sha384_des3_cra_init,
2001 .cra_exit = safexcel_aead_cra_exit,
2002 .cra_module = THIS_MODULE,
2007 static int safexcel_aead_sha1_des_cra_init(struct crypto_tfm *tfm)
2009 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2011 safexcel_aead_sha1_cra_init(tfm);
2012 ctx->alg = SAFEXCEL_DES; /* override default */
2016 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_cbc_des = {
2017 .type = SAFEXCEL_ALG_TYPE_AEAD,
2018 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA1,
2020 .setkey = safexcel_aead_setkey,
2021 .encrypt = safexcel_aead_encrypt,
2022 .decrypt = safexcel_aead_decrypt,
2023 .ivsize = DES_BLOCK_SIZE,
2024 .maxauthsize = SHA1_DIGEST_SIZE,
2026 .cra_name = "authenc(hmac(sha1),cbc(des))",
2027 .cra_driver_name = "safexcel-authenc-hmac-sha1-cbc-des",
2028 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2029 .cra_flags = CRYPTO_ALG_ASYNC |
2030 CRYPTO_ALG_KERN_DRIVER_ONLY,
2031 .cra_blocksize = DES_BLOCK_SIZE,
2032 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2034 .cra_init = safexcel_aead_sha1_des_cra_init,
2035 .cra_exit = safexcel_aead_cra_exit,
2036 .cra_module = THIS_MODULE,
2041 static int safexcel_aead_sha256_des_cra_init(struct crypto_tfm *tfm)
2043 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2045 safexcel_aead_sha256_cra_init(tfm);
2046 ctx->alg = SAFEXCEL_DES; /* override default */
2050 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha256_cbc_des = {
2051 .type = SAFEXCEL_ALG_TYPE_AEAD,
2052 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_256,
2054 .setkey = safexcel_aead_setkey,
2055 .encrypt = safexcel_aead_encrypt,
2056 .decrypt = safexcel_aead_decrypt,
2057 .ivsize = DES_BLOCK_SIZE,
2058 .maxauthsize = SHA256_DIGEST_SIZE,
2060 .cra_name = "authenc(hmac(sha256),cbc(des))",
2061 .cra_driver_name = "safexcel-authenc-hmac-sha256-cbc-des",
2062 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2063 .cra_flags = CRYPTO_ALG_ASYNC |
2064 CRYPTO_ALG_KERN_DRIVER_ONLY,
2065 .cra_blocksize = DES_BLOCK_SIZE,
2066 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2068 .cra_init = safexcel_aead_sha256_des_cra_init,
2069 .cra_exit = safexcel_aead_cra_exit,
2070 .cra_module = THIS_MODULE,
2075 static int safexcel_aead_sha224_des_cra_init(struct crypto_tfm *tfm)
2077 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2079 safexcel_aead_sha224_cra_init(tfm);
2080 ctx->alg = SAFEXCEL_DES; /* override default */
2084 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha224_cbc_des = {
2085 .type = SAFEXCEL_ALG_TYPE_AEAD,
2086 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_256,
2088 .setkey = safexcel_aead_setkey,
2089 .encrypt = safexcel_aead_encrypt,
2090 .decrypt = safexcel_aead_decrypt,
2091 .ivsize = DES_BLOCK_SIZE,
2092 .maxauthsize = SHA224_DIGEST_SIZE,
2094 .cra_name = "authenc(hmac(sha224),cbc(des))",
2095 .cra_driver_name = "safexcel-authenc-hmac-sha224-cbc-des",
2096 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2097 .cra_flags = CRYPTO_ALG_ASYNC |
2098 CRYPTO_ALG_KERN_DRIVER_ONLY,
2099 .cra_blocksize = DES_BLOCK_SIZE,
2100 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2102 .cra_init = safexcel_aead_sha224_des_cra_init,
2103 .cra_exit = safexcel_aead_cra_exit,
2104 .cra_module = THIS_MODULE,
2109 static int safexcel_aead_sha512_des_cra_init(struct crypto_tfm *tfm)
2111 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2113 safexcel_aead_sha512_cra_init(tfm);
2114 ctx->alg = SAFEXCEL_DES; /* override default */
2118 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha512_cbc_des = {
2119 .type = SAFEXCEL_ALG_TYPE_AEAD,
2120 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_512,
2122 .setkey = safexcel_aead_setkey,
2123 .encrypt = safexcel_aead_encrypt,
2124 .decrypt = safexcel_aead_decrypt,
2125 .ivsize = DES_BLOCK_SIZE,
2126 .maxauthsize = SHA512_DIGEST_SIZE,
2128 .cra_name = "authenc(hmac(sha512),cbc(des))",
2129 .cra_driver_name = "safexcel-authenc-hmac-sha512-cbc-des",
2130 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2131 .cra_flags = CRYPTO_ALG_ASYNC |
2132 CRYPTO_ALG_KERN_DRIVER_ONLY,
2133 .cra_blocksize = DES_BLOCK_SIZE,
2134 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2136 .cra_init = safexcel_aead_sha512_des_cra_init,
2137 .cra_exit = safexcel_aead_cra_exit,
2138 .cra_module = THIS_MODULE,
2143 static int safexcel_aead_sha384_des_cra_init(struct crypto_tfm *tfm)
2145 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2147 safexcel_aead_sha384_cra_init(tfm);
2148 ctx->alg = SAFEXCEL_DES; /* override default */
2152 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha384_cbc_des = {
2153 .type = SAFEXCEL_ALG_TYPE_AEAD,
2154 .algo_mask = SAFEXCEL_ALG_DES | SAFEXCEL_ALG_SHA2_512,
2156 .setkey = safexcel_aead_setkey,
2157 .encrypt = safexcel_aead_encrypt,
2158 .decrypt = safexcel_aead_decrypt,
2159 .ivsize = DES_BLOCK_SIZE,
2160 .maxauthsize = SHA384_DIGEST_SIZE,
2162 .cra_name = "authenc(hmac(sha384),cbc(des))",
2163 .cra_driver_name = "safexcel-authenc-hmac-sha384-cbc-des",
2164 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2165 .cra_flags = CRYPTO_ALG_ASYNC |
2166 CRYPTO_ALG_KERN_DRIVER_ONLY,
2167 .cra_blocksize = DES_BLOCK_SIZE,
2168 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2170 .cra_init = safexcel_aead_sha384_des_cra_init,
2171 .cra_exit = safexcel_aead_cra_exit,
2172 .cra_module = THIS_MODULE,
2177 static int safexcel_aead_sha1_ctr_cra_init(struct crypto_tfm *tfm)
2179 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2181 safexcel_aead_sha1_cra_init(tfm);
2182 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD; /* override default */
2186 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_ctr_aes = {
2187 .type = SAFEXCEL_ALG_TYPE_AEAD,
2188 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA1,
2190 .setkey = safexcel_aead_setkey,
2191 .encrypt = safexcel_aead_encrypt,
2192 .decrypt = safexcel_aead_decrypt,
2193 .ivsize = CTR_RFC3686_IV_SIZE,
2194 .maxauthsize = SHA1_DIGEST_SIZE,
2196 .cra_name = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2197 .cra_driver_name = "safexcel-authenc-hmac-sha1-ctr-aes",
2198 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2199 .cra_flags = CRYPTO_ALG_ASYNC |
2200 CRYPTO_ALG_KERN_DRIVER_ONLY,
2202 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2204 .cra_init = safexcel_aead_sha1_ctr_cra_init,
2205 .cra_exit = safexcel_aead_cra_exit,
2206 .cra_module = THIS_MODULE,
2211 static int safexcel_aead_sha256_ctr_cra_init(struct crypto_tfm *tfm)
2213 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2215 safexcel_aead_sha256_cra_init(tfm);
2216 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD; /* override default */
2220 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha256_ctr_aes = {
2221 .type = SAFEXCEL_ALG_TYPE_AEAD,
2222 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_256,
2224 .setkey = safexcel_aead_setkey,
2225 .encrypt = safexcel_aead_encrypt,
2226 .decrypt = safexcel_aead_decrypt,
2227 .ivsize = CTR_RFC3686_IV_SIZE,
2228 .maxauthsize = SHA256_DIGEST_SIZE,
2230 .cra_name = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2231 .cra_driver_name = "safexcel-authenc-hmac-sha256-ctr-aes",
2232 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2233 .cra_flags = CRYPTO_ALG_ASYNC |
2234 CRYPTO_ALG_KERN_DRIVER_ONLY,
2236 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2238 .cra_init = safexcel_aead_sha256_ctr_cra_init,
2239 .cra_exit = safexcel_aead_cra_exit,
2240 .cra_module = THIS_MODULE,
2245 static int safexcel_aead_sha224_ctr_cra_init(struct crypto_tfm *tfm)
2247 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2249 safexcel_aead_sha224_cra_init(tfm);
2250 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD; /* override default */
2254 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha224_ctr_aes = {
2255 .type = SAFEXCEL_ALG_TYPE_AEAD,
2256 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_256,
2258 .setkey = safexcel_aead_setkey,
2259 .encrypt = safexcel_aead_encrypt,
2260 .decrypt = safexcel_aead_decrypt,
2261 .ivsize = CTR_RFC3686_IV_SIZE,
2262 .maxauthsize = SHA224_DIGEST_SIZE,
2264 .cra_name = "authenc(hmac(sha224),rfc3686(ctr(aes)))",
2265 .cra_driver_name = "safexcel-authenc-hmac-sha224-ctr-aes",
2266 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2267 .cra_flags = CRYPTO_ALG_ASYNC |
2268 CRYPTO_ALG_KERN_DRIVER_ONLY,
2270 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2272 .cra_init = safexcel_aead_sha224_ctr_cra_init,
2273 .cra_exit = safexcel_aead_cra_exit,
2274 .cra_module = THIS_MODULE,
2279 static int safexcel_aead_sha512_ctr_cra_init(struct crypto_tfm *tfm)
2281 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2283 safexcel_aead_sha512_cra_init(tfm);
2284 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD; /* override default */
2288 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha512_ctr_aes = {
2289 .type = SAFEXCEL_ALG_TYPE_AEAD,
2290 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_512,
2292 .setkey = safexcel_aead_setkey,
2293 .encrypt = safexcel_aead_encrypt,
2294 .decrypt = safexcel_aead_decrypt,
2295 .ivsize = CTR_RFC3686_IV_SIZE,
2296 .maxauthsize = SHA512_DIGEST_SIZE,
2298 .cra_name = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2299 .cra_driver_name = "safexcel-authenc-hmac-sha512-ctr-aes",
2300 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2301 .cra_flags = CRYPTO_ALG_ASYNC |
2302 CRYPTO_ALG_KERN_DRIVER_ONLY,
2304 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2306 .cra_init = safexcel_aead_sha512_ctr_cra_init,
2307 .cra_exit = safexcel_aead_cra_exit,
2308 .cra_module = THIS_MODULE,
2313 static int safexcel_aead_sha384_ctr_cra_init(struct crypto_tfm *tfm)
2315 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2317 safexcel_aead_sha384_cra_init(tfm);
2318 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD; /* override default */
2322 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha384_ctr_aes = {
2323 .type = SAFEXCEL_ALG_TYPE_AEAD,
2324 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_SHA2_512,
2326 .setkey = safexcel_aead_setkey,
2327 .encrypt = safexcel_aead_encrypt,
2328 .decrypt = safexcel_aead_decrypt,
2329 .ivsize = CTR_RFC3686_IV_SIZE,
2330 .maxauthsize = SHA384_DIGEST_SIZE,
2332 .cra_name = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2333 .cra_driver_name = "safexcel-authenc-hmac-sha384-ctr-aes",
2334 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2335 .cra_flags = CRYPTO_ALG_ASYNC |
2336 CRYPTO_ALG_KERN_DRIVER_ONLY,
2338 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2340 .cra_init = safexcel_aead_sha384_ctr_cra_init,
2341 .cra_exit = safexcel_aead_cra_exit,
2342 .cra_module = THIS_MODULE,
2347 static int safexcel_skcipher_aesxts_setkey(struct crypto_skcipher *ctfm,
2348 const u8 *key, unsigned int len)
2350 struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
2351 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2352 struct safexcel_crypto_priv *priv = ctx->priv;
2353 struct crypto_aes_ctx aes;
2355 unsigned int keylen;
2357 /* Check for illegal XTS keys */
2358 ret = xts_verify_key(ctfm, key, len);
2362 /* Only half of the key data is cipher key */
2363 keylen = (len >> 1);
2364 ret = aes_expandkey(&aes, key, keylen);
2366 crypto_skcipher_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
2370 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
2371 for (i = 0; i < keylen / sizeof(u32); i++) {
2372 if (le32_to_cpu(ctx->key[i]) != aes.key_enc[i]) {
2373 ctx->base.needs_inv = true;
2379 for (i = 0; i < keylen / sizeof(u32); i++)
2380 ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
2382 /* The other half is the tweak key */
2383 ret = aes_expandkey(&aes, (u8 *)(key + keylen), keylen);
2385 crypto_skcipher_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
2389 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
2390 for (i = 0; i < keylen / sizeof(u32); i++) {
2391 if (le32_to_cpu(ctx->key[i + keylen / sizeof(u32)]) !=
2393 ctx->base.needs_inv = true;
2399 for (i = 0; i < keylen / sizeof(u32); i++)
2400 ctx->key[i + keylen / sizeof(u32)] =
2401 cpu_to_le32(aes.key_enc[i]);
2403 ctx->key_len = keylen << 1;
2405 memzero_explicit(&aes, sizeof(aes));
2409 static int safexcel_skcipher_aes_xts_cra_init(struct crypto_tfm *tfm)
2411 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2413 safexcel_skcipher_cra_init(tfm);
2414 ctx->alg = SAFEXCEL_AES;
2416 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_XTS;
2420 static int safexcel_encrypt_xts(struct skcipher_request *req)
2422 if (req->cryptlen < XTS_BLOCK_SIZE)
2424 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
2428 static int safexcel_decrypt_xts(struct skcipher_request *req)
2430 if (req->cryptlen < XTS_BLOCK_SIZE)
2432 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
2436 struct safexcel_alg_template safexcel_alg_xts_aes = {
2437 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
2438 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_AES_XTS,
2440 .setkey = safexcel_skcipher_aesxts_setkey,
2441 .encrypt = safexcel_encrypt_xts,
2442 .decrypt = safexcel_decrypt_xts,
2443 /* XTS actually uses 2 AES keys glued together */
2444 .min_keysize = AES_MIN_KEY_SIZE * 2,
2445 .max_keysize = AES_MAX_KEY_SIZE * 2,
2446 .ivsize = XTS_BLOCK_SIZE,
2448 .cra_name = "xts(aes)",
2449 .cra_driver_name = "safexcel-xts-aes",
2450 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2451 .cra_flags = CRYPTO_ALG_ASYNC |
2452 CRYPTO_ALG_KERN_DRIVER_ONLY,
2453 .cra_blocksize = XTS_BLOCK_SIZE,
2454 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2456 .cra_init = safexcel_skcipher_aes_xts_cra_init,
2457 .cra_exit = safexcel_skcipher_cra_exit,
2458 .cra_module = THIS_MODULE,
2463 static int safexcel_aead_gcm_setkey(struct crypto_aead *ctfm, const u8 *key,
2466 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
2467 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2468 struct safexcel_crypto_priv *priv = ctx->priv;
2469 struct crypto_aes_ctx aes;
2470 u32 hashkey[AES_BLOCK_SIZE >> 2];
2473 ret = aes_expandkey(&aes, key, len);
2475 crypto_aead_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
2476 memzero_explicit(&aes, sizeof(aes));
2480 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
2481 for (i = 0; i < len / sizeof(u32); i++) {
2482 if (le32_to_cpu(ctx->key[i]) != aes.key_enc[i]) {
2483 ctx->base.needs_inv = true;
2489 for (i = 0; i < len / sizeof(u32); i++)
2490 ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
2494 /* Compute hash key by encrypting zeroes with cipher key */
2495 crypto_cipher_clear_flags(ctx->hkaes, CRYPTO_TFM_REQ_MASK);
2496 crypto_cipher_set_flags(ctx->hkaes, crypto_aead_get_flags(ctfm) &
2497 CRYPTO_TFM_REQ_MASK);
2498 ret = crypto_cipher_setkey(ctx->hkaes, key, len);
2499 crypto_aead_set_flags(ctfm, crypto_cipher_get_flags(ctx->hkaes) &
2500 CRYPTO_TFM_RES_MASK);
2504 memset(hashkey, 0, AES_BLOCK_SIZE);
2505 crypto_cipher_encrypt_one(ctx->hkaes, (u8 *)hashkey, (u8 *)hashkey);
2507 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
2508 for (i = 0; i < AES_BLOCK_SIZE / sizeof(u32); i++) {
2509 if (be32_to_cpu(ctx->ipad[i]) != hashkey[i]) {
2510 ctx->base.needs_inv = true;
2516 for (i = 0; i < AES_BLOCK_SIZE / sizeof(u32); i++)
2517 ctx->ipad[i] = cpu_to_be32(hashkey[i]);
2519 memzero_explicit(hashkey, AES_BLOCK_SIZE);
2520 memzero_explicit(&aes, sizeof(aes));
2524 static int safexcel_aead_gcm_cra_init(struct crypto_tfm *tfm)
2526 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2528 safexcel_aead_cra_init(tfm);
2529 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_GHASH;
2530 ctx->state_sz = GHASH_BLOCK_SIZE;
2531 ctx->xcm = EIP197_XCM_MODE_GCM;
2532 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_XCM; /* override default */
2534 ctx->hkaes = crypto_alloc_cipher("aes", 0, 0);
2535 if (IS_ERR(ctx->hkaes))
2536 return PTR_ERR(ctx->hkaes);
2541 static void safexcel_aead_gcm_cra_exit(struct crypto_tfm *tfm)
2543 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2545 crypto_free_cipher(ctx->hkaes);
2546 safexcel_aead_cra_exit(tfm);
2549 static int safexcel_aead_gcm_setauthsize(struct crypto_aead *tfm,
2550 unsigned int authsize)
2552 return crypto_gcm_check_authsize(authsize);
2555 struct safexcel_alg_template safexcel_alg_gcm = {
2556 .type = SAFEXCEL_ALG_TYPE_AEAD,
2557 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_GHASH,
2559 .setkey = safexcel_aead_gcm_setkey,
2560 .setauthsize = safexcel_aead_gcm_setauthsize,
2561 .encrypt = safexcel_aead_encrypt,
2562 .decrypt = safexcel_aead_decrypt,
2563 .ivsize = GCM_AES_IV_SIZE,
2564 .maxauthsize = GHASH_DIGEST_SIZE,
2566 .cra_name = "gcm(aes)",
2567 .cra_driver_name = "safexcel-gcm-aes",
2568 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2569 .cra_flags = CRYPTO_ALG_ASYNC |
2570 CRYPTO_ALG_KERN_DRIVER_ONLY,
2572 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2574 .cra_init = safexcel_aead_gcm_cra_init,
2575 .cra_exit = safexcel_aead_gcm_cra_exit,
2576 .cra_module = THIS_MODULE,
2581 static int safexcel_aead_ccm_setkey(struct crypto_aead *ctfm, const u8 *key,
2584 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
2585 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2586 struct safexcel_crypto_priv *priv = ctx->priv;
2587 struct crypto_aes_ctx aes;
2590 ret = aes_expandkey(&aes, key, len);
2592 crypto_aead_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
2593 memzero_explicit(&aes, sizeof(aes));
2597 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
2598 for (i = 0; i < len / sizeof(u32); i++) {
2599 if (le32_to_cpu(ctx->key[i]) != aes.key_enc[i]) {
2600 ctx->base.needs_inv = true;
2606 for (i = 0; i < len / sizeof(u32); i++) {
2607 ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
2608 ctx->ipad[i + 2 * AES_BLOCK_SIZE / sizeof(u32)] =
2609 cpu_to_be32(aes.key_enc[i]);
2613 ctx->state_sz = 2 * AES_BLOCK_SIZE + len;
2615 if (len == AES_KEYSIZE_192)
2616 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_XCBC192;
2617 else if (len == AES_KEYSIZE_256)
2618 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_XCBC256;
2620 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_XCBC128;
2622 memzero_explicit(&aes, sizeof(aes));
2626 static int safexcel_aead_ccm_cra_init(struct crypto_tfm *tfm)
2628 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2630 safexcel_aead_cra_init(tfm);
2631 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_XCBC128;
2632 ctx->state_sz = 3 * AES_BLOCK_SIZE;
2633 ctx->xcm = EIP197_XCM_MODE_CCM;
2634 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_XCM; /* override default */
2638 static int safexcel_aead_ccm_setauthsize(struct crypto_aead *tfm,
2639 unsigned int authsize)
2641 /* Borrowed from crypto/ccm.c */
2658 static int safexcel_ccm_encrypt(struct aead_request *req)
2660 struct safexcel_cipher_req *creq = aead_request_ctx(req);
2662 if (req->iv[0] < 1 || req->iv[0] > 7)
2665 return safexcel_queue_req(&req->base, creq, SAFEXCEL_ENCRYPT);
2668 static int safexcel_ccm_decrypt(struct aead_request *req)
2670 struct safexcel_cipher_req *creq = aead_request_ctx(req);
2672 if (req->iv[0] < 1 || req->iv[0] > 7)
2675 return safexcel_queue_req(&req->base, creq, SAFEXCEL_DECRYPT);
2678 struct safexcel_alg_template safexcel_alg_ccm = {
2679 .type = SAFEXCEL_ALG_TYPE_AEAD,
2680 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_CBC_MAC_ALL,
2682 .setkey = safexcel_aead_ccm_setkey,
2683 .setauthsize = safexcel_aead_ccm_setauthsize,
2684 .encrypt = safexcel_ccm_encrypt,
2685 .decrypt = safexcel_ccm_decrypt,
2686 .ivsize = AES_BLOCK_SIZE,
2687 .maxauthsize = AES_BLOCK_SIZE,
2689 .cra_name = "ccm(aes)",
2690 .cra_driver_name = "safexcel-ccm-aes",
2691 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2692 .cra_flags = CRYPTO_ALG_ASYNC |
2693 CRYPTO_ALG_KERN_DRIVER_ONLY,
2695 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2697 .cra_init = safexcel_aead_ccm_cra_init,
2698 .cra_exit = safexcel_aead_cra_exit,
2699 .cra_module = THIS_MODULE,
2704 static void safexcel_chacha20_setkey(struct safexcel_cipher_ctx *ctx,
2707 struct safexcel_crypto_priv *priv = ctx->priv;
2709 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma)
2710 if (memcmp(ctx->key, key, CHACHA_KEY_SIZE))
2711 ctx->base.needs_inv = true;
2713 memcpy(ctx->key, key, CHACHA_KEY_SIZE);
2714 ctx->key_len = CHACHA_KEY_SIZE;
2717 static int safexcel_skcipher_chacha20_setkey(struct crypto_skcipher *ctfm,
2718 const u8 *key, unsigned int len)
2720 struct safexcel_cipher_ctx *ctx = crypto_skcipher_ctx(ctfm);
2722 if (len != CHACHA_KEY_SIZE) {
2723 crypto_skcipher_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
2726 safexcel_chacha20_setkey(ctx, key);
2731 static int safexcel_skcipher_chacha20_cra_init(struct crypto_tfm *tfm)
2733 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2735 safexcel_skcipher_cra_init(tfm);
2736 ctx->alg = SAFEXCEL_CHACHA20;
2737 ctx->mode = CONTEXT_CONTROL_CHACHA20_MODE_256_32;
2741 struct safexcel_alg_template safexcel_alg_chacha20 = {
2742 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
2743 .algo_mask = SAFEXCEL_ALG_CHACHA20,
2745 .setkey = safexcel_skcipher_chacha20_setkey,
2746 .encrypt = safexcel_encrypt,
2747 .decrypt = safexcel_decrypt,
2748 .min_keysize = CHACHA_KEY_SIZE,
2749 .max_keysize = CHACHA_KEY_SIZE,
2750 .ivsize = CHACHA_IV_SIZE,
2752 .cra_name = "chacha20",
2753 .cra_driver_name = "safexcel-chacha20",
2754 .cra_priority = SAFEXCEL_CRA_PRIORITY,
2755 .cra_flags = CRYPTO_ALG_ASYNC |
2756 CRYPTO_ALG_KERN_DRIVER_ONLY,
2758 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2760 .cra_init = safexcel_skcipher_chacha20_cra_init,
2761 .cra_exit = safexcel_skcipher_cra_exit,
2762 .cra_module = THIS_MODULE,
2767 static int safexcel_aead_chachapoly_setkey(struct crypto_aead *ctfm,
2768 const u8 *key, unsigned int len)
2770 struct safexcel_cipher_ctx *ctx = crypto_aead_ctx(ctfm);
2772 if (ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP &&
2773 len > EIP197_AEAD_IPSEC_NONCE_SIZE) {
2774 /* ESP variant has nonce appended to key */
2775 len -= EIP197_AEAD_IPSEC_NONCE_SIZE;
2776 ctx->nonce = *(u32 *)(key + len);
2778 if (len != CHACHA_KEY_SIZE) {
2779 crypto_aead_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
2782 safexcel_chacha20_setkey(ctx, key);
2787 static int safexcel_aead_chachapoly_setauthsize(struct crypto_aead *tfm,
2788 unsigned int authsize)
2790 if (authsize != POLY1305_DIGEST_SIZE)
2795 static int safexcel_aead_chachapoly_crypt(struct aead_request *req,
2796 enum safexcel_cipher_direction dir)
2798 struct safexcel_cipher_req *creq = aead_request_ctx(req);
2799 struct crypto_aead *aead = crypto_aead_reqtfm(req);
2800 struct crypto_tfm *tfm = crypto_aead_tfm(aead);
2801 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2802 struct aead_request *subreq = aead_request_ctx(req);
2803 u32 key[CHACHA_KEY_SIZE / sizeof(u32) + 1];
2807 * Instead of wasting time detecting umpteen silly corner cases,
2808 * just dump all "small" requests to the fallback implementation.
2809 * HW would not be faster on such small requests anyway.
2811 if (likely((ctx->aead != EIP197_AEAD_TYPE_IPSEC_ESP ||
2812 req->assoclen >= EIP197_AEAD_IPSEC_IV_SIZE) &&
2813 req->cryptlen > POLY1305_DIGEST_SIZE)) {
2814 return safexcel_queue_req(&req->base, creq, dir);
2817 /* HW cannot do full (AAD+payload) zero length, use fallback */
2818 memcpy(key, ctx->key, CHACHA_KEY_SIZE);
2819 if (ctx->aead == EIP197_AEAD_TYPE_IPSEC_ESP) {
2820 /* ESP variant has nonce appended to the key */
2821 key[CHACHA_KEY_SIZE / sizeof(u32)] = ctx->nonce;
2822 ret = crypto_aead_setkey(ctx->fback, (u8 *)key,
2824 EIP197_AEAD_IPSEC_NONCE_SIZE);
2826 ret = crypto_aead_setkey(ctx->fback, (u8 *)key,
2830 crypto_aead_clear_flags(aead, CRYPTO_TFM_REQ_MASK);
2831 crypto_aead_set_flags(aead, crypto_aead_get_flags(ctx->fback) &
2832 CRYPTO_TFM_REQ_MASK);
2836 aead_request_set_tfm(subreq, ctx->fback);
2837 aead_request_set_callback(subreq, req->base.flags, req->base.complete,
2839 aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
2841 aead_request_set_ad(subreq, req->assoclen);
2843 return (dir == SAFEXCEL_ENCRYPT) ?
2844 crypto_aead_encrypt(subreq) :
2845 crypto_aead_decrypt(subreq);
2848 static int safexcel_aead_chachapoly_encrypt(struct aead_request *req)
2850 return safexcel_aead_chachapoly_crypt(req, SAFEXCEL_ENCRYPT);
2853 static int safexcel_aead_chachapoly_decrypt(struct aead_request *req)
2855 return safexcel_aead_chachapoly_crypt(req, SAFEXCEL_DECRYPT);
2858 static int safexcel_aead_fallback_cra_init(struct crypto_tfm *tfm)
2860 struct crypto_aead *aead = __crypto_aead_cast(tfm);
2861 struct aead_alg *alg = crypto_aead_alg(aead);
2862 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2864 safexcel_aead_cra_init(tfm);
2866 /* Allocate fallback implementation */
2867 ctx->fback = crypto_alloc_aead(alg->base.cra_name, 0,
2869 CRYPTO_ALG_NEED_FALLBACK);
2870 if (IS_ERR(ctx->fback))
2871 return PTR_ERR(ctx->fback);
2873 crypto_aead_set_reqsize(aead, max(sizeof(struct safexcel_cipher_req),
2874 sizeof(struct aead_request) +
2875 crypto_aead_reqsize(ctx->fback)));
2880 static int safexcel_aead_chachapoly_cra_init(struct crypto_tfm *tfm)
2882 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2884 safexcel_aead_fallback_cra_init(tfm);
2885 ctx->alg = SAFEXCEL_CHACHA20;
2886 ctx->mode = CONTEXT_CONTROL_CHACHA20_MODE_256_32 |
2887 CONTEXT_CONTROL_CHACHA20_MODE_CALC_OTK;
2888 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_POLY1305;
2889 ctx->state_sz = 0; /* Precomputed by HW */
2893 static void safexcel_aead_fallback_cra_exit(struct crypto_tfm *tfm)
2895 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2897 crypto_free_aead(ctx->fback);
2898 safexcel_aead_cra_exit(tfm);
2901 struct safexcel_alg_template safexcel_alg_chachapoly = {
2902 .type = SAFEXCEL_ALG_TYPE_AEAD,
2903 .algo_mask = SAFEXCEL_ALG_CHACHA20 | SAFEXCEL_ALG_POLY1305,
2905 .setkey = safexcel_aead_chachapoly_setkey,
2906 .setauthsize = safexcel_aead_chachapoly_setauthsize,
2907 .encrypt = safexcel_aead_chachapoly_encrypt,
2908 .decrypt = safexcel_aead_chachapoly_decrypt,
2909 .ivsize = CHACHAPOLY_IV_SIZE,
2910 .maxauthsize = POLY1305_DIGEST_SIZE,
2912 .cra_name = "rfc7539(chacha20,poly1305)",
2913 .cra_driver_name = "safexcel-chacha20-poly1305",
2914 /* +1 to put it above HW chacha + SW poly */
2915 .cra_priority = SAFEXCEL_CRA_PRIORITY + 1,
2916 .cra_flags = CRYPTO_ALG_ASYNC |
2917 CRYPTO_ALG_KERN_DRIVER_ONLY |
2918 CRYPTO_ALG_NEED_FALLBACK,
2920 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2922 .cra_init = safexcel_aead_chachapoly_cra_init,
2923 .cra_exit = safexcel_aead_fallback_cra_exit,
2924 .cra_module = THIS_MODULE,
2929 static int safexcel_aead_chachapolyesp_cra_init(struct crypto_tfm *tfm)
2931 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2934 ret = safexcel_aead_chachapoly_cra_init(tfm);
2935 ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP;
2939 struct safexcel_alg_template safexcel_alg_chachapoly_esp = {
2940 .type = SAFEXCEL_ALG_TYPE_AEAD,
2941 .algo_mask = SAFEXCEL_ALG_CHACHA20 | SAFEXCEL_ALG_POLY1305,
2943 .setkey = safexcel_aead_chachapoly_setkey,
2944 .setauthsize = safexcel_aead_chachapoly_setauthsize,
2945 .encrypt = safexcel_aead_chachapoly_encrypt,
2946 .decrypt = safexcel_aead_chachapoly_decrypt,
2947 .ivsize = CHACHAPOLY_IV_SIZE - EIP197_AEAD_IPSEC_NONCE_SIZE,
2948 .maxauthsize = POLY1305_DIGEST_SIZE,
2950 .cra_name = "rfc7539esp(chacha20,poly1305)",
2951 .cra_driver_name = "safexcel-chacha20-poly1305-esp",
2952 /* +1 to put it above HW chacha + SW poly */
2953 .cra_priority = SAFEXCEL_CRA_PRIORITY + 1,
2954 .cra_flags = CRYPTO_ALG_ASYNC |
2955 CRYPTO_ALG_KERN_DRIVER_ONLY |
2956 CRYPTO_ALG_NEED_FALLBACK,
2958 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
2960 .cra_init = safexcel_aead_chachapolyesp_cra_init,
2961 .cra_exit = safexcel_aead_fallback_cra_exit,
2962 .cra_module = THIS_MODULE,
2967 static int safexcel_skcipher_sm4_setkey(struct crypto_skcipher *ctfm,
2968 const u8 *key, unsigned int len)
2970 struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
2971 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
2972 struct safexcel_crypto_priv *priv = ctx->priv;
2974 if (len != SM4_KEY_SIZE) {
2975 crypto_skcipher_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
2979 if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma)
2980 if (memcmp(ctx->key, key, SM4_KEY_SIZE))
2981 ctx->base.needs_inv = true;
2983 memcpy(ctx->key, key, SM4_KEY_SIZE);
2984 ctx->key_len = SM4_KEY_SIZE;
2989 static int safexcel_sm4_blk_encrypt(struct skcipher_request *req)
2991 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
2992 if (req->cryptlen & (SM4_BLOCK_SIZE - 1))
2995 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
2999 static int safexcel_sm4_blk_decrypt(struct skcipher_request *req)
3001 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3002 if (req->cryptlen & (SM4_BLOCK_SIZE - 1))
3005 return safexcel_queue_req(&req->base, skcipher_request_ctx(req),
3009 static int safexcel_skcipher_sm4_ecb_cra_init(struct crypto_tfm *tfm)
3011 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3013 safexcel_skcipher_cra_init(tfm);
3014 ctx->alg = SAFEXCEL_SM4;
3015 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_ECB;
3019 struct safexcel_alg_template safexcel_alg_ecb_sm4 = {
3020 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
3021 .algo_mask = SAFEXCEL_ALG_SM4,
3023 .setkey = safexcel_skcipher_sm4_setkey,
3024 .encrypt = safexcel_sm4_blk_encrypt,
3025 .decrypt = safexcel_sm4_blk_decrypt,
3026 .min_keysize = SM4_KEY_SIZE,
3027 .max_keysize = SM4_KEY_SIZE,
3029 .cra_name = "ecb(sm4)",
3030 .cra_driver_name = "safexcel-ecb-sm4",
3031 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3032 .cra_flags = CRYPTO_ALG_ASYNC |
3033 CRYPTO_ALG_KERN_DRIVER_ONLY,
3034 .cra_blocksize = SM4_BLOCK_SIZE,
3035 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3037 .cra_init = safexcel_skcipher_sm4_ecb_cra_init,
3038 .cra_exit = safexcel_skcipher_cra_exit,
3039 .cra_module = THIS_MODULE,
3044 static int safexcel_skcipher_sm4_cbc_cra_init(struct crypto_tfm *tfm)
3046 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3048 safexcel_skcipher_cra_init(tfm);
3049 ctx->alg = SAFEXCEL_SM4;
3050 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CBC;
3054 struct safexcel_alg_template safexcel_alg_cbc_sm4 = {
3055 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
3056 .algo_mask = SAFEXCEL_ALG_SM4,
3058 .setkey = safexcel_skcipher_sm4_setkey,
3059 .encrypt = safexcel_sm4_blk_encrypt,
3060 .decrypt = safexcel_sm4_blk_decrypt,
3061 .min_keysize = SM4_KEY_SIZE,
3062 .max_keysize = SM4_KEY_SIZE,
3063 .ivsize = SM4_BLOCK_SIZE,
3065 .cra_name = "cbc(sm4)",
3066 .cra_driver_name = "safexcel-cbc-sm4",
3067 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3068 .cra_flags = CRYPTO_ALG_ASYNC |
3069 CRYPTO_ALG_KERN_DRIVER_ONLY,
3070 .cra_blocksize = SM4_BLOCK_SIZE,
3071 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3073 .cra_init = safexcel_skcipher_sm4_cbc_cra_init,
3074 .cra_exit = safexcel_skcipher_cra_exit,
3075 .cra_module = THIS_MODULE,
3080 static int safexcel_skcipher_sm4_ofb_cra_init(struct crypto_tfm *tfm)
3082 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3084 safexcel_skcipher_cra_init(tfm);
3085 ctx->alg = SAFEXCEL_SM4;
3086 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_OFB;
3090 struct safexcel_alg_template safexcel_alg_ofb_sm4 = {
3091 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
3092 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_AES_XFB,
3094 .setkey = safexcel_skcipher_sm4_setkey,
3095 .encrypt = safexcel_encrypt,
3096 .decrypt = safexcel_decrypt,
3097 .min_keysize = SM4_KEY_SIZE,
3098 .max_keysize = SM4_KEY_SIZE,
3099 .ivsize = SM4_BLOCK_SIZE,
3101 .cra_name = "ofb(sm4)",
3102 .cra_driver_name = "safexcel-ofb-sm4",
3103 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3104 .cra_flags = CRYPTO_ALG_ASYNC |
3105 CRYPTO_ALG_KERN_DRIVER_ONLY,
3107 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3109 .cra_init = safexcel_skcipher_sm4_ofb_cra_init,
3110 .cra_exit = safexcel_skcipher_cra_exit,
3111 .cra_module = THIS_MODULE,
3116 static int safexcel_skcipher_sm4_cfb_cra_init(struct crypto_tfm *tfm)
3118 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3120 safexcel_skcipher_cra_init(tfm);
3121 ctx->alg = SAFEXCEL_SM4;
3122 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CFB;
3126 struct safexcel_alg_template safexcel_alg_cfb_sm4 = {
3127 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
3128 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_AES_XFB,
3130 .setkey = safexcel_skcipher_sm4_setkey,
3131 .encrypt = safexcel_encrypt,
3132 .decrypt = safexcel_decrypt,
3133 .min_keysize = SM4_KEY_SIZE,
3134 .max_keysize = SM4_KEY_SIZE,
3135 .ivsize = SM4_BLOCK_SIZE,
3137 .cra_name = "cfb(sm4)",
3138 .cra_driver_name = "safexcel-cfb-sm4",
3139 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3140 .cra_flags = CRYPTO_ALG_ASYNC |
3141 CRYPTO_ALG_KERN_DRIVER_ONLY,
3143 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3145 .cra_init = safexcel_skcipher_sm4_cfb_cra_init,
3146 .cra_exit = safexcel_skcipher_cra_exit,
3147 .cra_module = THIS_MODULE,
3152 static int safexcel_skcipher_sm4ctr_setkey(struct crypto_skcipher *ctfm,
3153 const u8 *key, unsigned int len)
3155 struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
3156 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3158 /* last 4 bytes of key are the nonce! */
3159 ctx->nonce = *(u32 *)(key + len - CTR_RFC3686_NONCE_SIZE);
3160 /* exclude the nonce here */
3161 len -= CTR_RFC3686_NONCE_SIZE;
3163 return safexcel_skcipher_sm4_setkey(ctfm, key, len);
3166 static int safexcel_skcipher_sm4_ctr_cra_init(struct crypto_tfm *tfm)
3168 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3170 safexcel_skcipher_cra_init(tfm);
3171 ctx->alg = SAFEXCEL_SM4;
3172 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD;
3176 struct safexcel_alg_template safexcel_alg_ctr_sm4 = {
3177 .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
3178 .algo_mask = SAFEXCEL_ALG_SM4,
3180 .setkey = safexcel_skcipher_sm4ctr_setkey,
3181 .encrypt = safexcel_encrypt,
3182 .decrypt = safexcel_decrypt,
3183 /* Add nonce size */
3184 .min_keysize = SM4_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
3185 .max_keysize = SM4_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
3186 .ivsize = CTR_RFC3686_IV_SIZE,
3188 .cra_name = "rfc3686(ctr(sm4))",
3189 .cra_driver_name = "safexcel-ctr-sm4",
3190 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3191 .cra_flags = CRYPTO_ALG_ASYNC |
3192 CRYPTO_ALG_KERN_DRIVER_ONLY,
3194 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3196 .cra_init = safexcel_skcipher_sm4_ctr_cra_init,
3197 .cra_exit = safexcel_skcipher_cra_exit,
3198 .cra_module = THIS_MODULE,
3203 static int safexcel_aead_sm4_blk_encrypt(struct aead_request *req)
3205 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3206 if (req->cryptlen & (SM4_BLOCK_SIZE - 1))
3209 return safexcel_queue_req(&req->base, aead_request_ctx(req),
3213 static int safexcel_aead_sm4_blk_decrypt(struct aead_request *req)
3215 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
3217 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3218 if ((req->cryptlen - crypto_aead_authsize(tfm)) & (SM4_BLOCK_SIZE - 1))
3221 return safexcel_queue_req(&req->base, aead_request_ctx(req),
3225 static int safexcel_aead_sm4cbc_sha1_cra_init(struct crypto_tfm *tfm)
3227 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3229 safexcel_aead_cra_init(tfm);
3230 ctx->alg = SAFEXCEL_SM4;
3231 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA1;
3232 ctx->state_sz = SHA1_DIGEST_SIZE;
3236 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_cbc_sm4 = {
3237 .type = SAFEXCEL_ALG_TYPE_AEAD,
3238 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_SHA1,
3240 .setkey = safexcel_aead_setkey,
3241 .encrypt = safexcel_aead_sm4_blk_encrypt,
3242 .decrypt = safexcel_aead_sm4_blk_decrypt,
3243 .ivsize = SM4_BLOCK_SIZE,
3244 .maxauthsize = SHA1_DIGEST_SIZE,
3246 .cra_name = "authenc(hmac(sha1),cbc(sm4))",
3247 .cra_driver_name = "safexcel-authenc-hmac-sha1-cbc-sm4",
3248 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3249 .cra_flags = CRYPTO_ALG_ASYNC |
3250 CRYPTO_ALG_KERN_DRIVER_ONLY,
3251 .cra_blocksize = SM4_BLOCK_SIZE,
3252 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3254 .cra_init = safexcel_aead_sm4cbc_sha1_cra_init,
3255 .cra_exit = safexcel_aead_cra_exit,
3256 .cra_module = THIS_MODULE,
3261 static int safexcel_aead_fallback_setkey(struct crypto_aead *ctfm,
3262 const u8 *key, unsigned int len)
3264 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
3265 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3267 /* Keep fallback cipher synchronized */
3268 return crypto_aead_setkey(ctx->fback, (u8 *)key, len) ?:
3269 safexcel_aead_setkey(ctfm, key, len);
3272 static int safexcel_aead_fallback_setauthsize(struct crypto_aead *ctfm,
3273 unsigned int authsize)
3275 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
3276 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3278 /* Keep fallback cipher synchronized */
3279 return crypto_aead_setauthsize(ctx->fback, authsize);
3282 static int safexcel_aead_fallback_crypt(struct aead_request *req,
3283 enum safexcel_cipher_direction dir)
3285 struct crypto_aead *aead = crypto_aead_reqtfm(req);
3286 struct crypto_tfm *tfm = crypto_aead_tfm(aead);
3287 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3288 struct aead_request *subreq = aead_request_ctx(req);
3290 aead_request_set_tfm(subreq, ctx->fback);
3291 aead_request_set_callback(subreq, req->base.flags, req->base.complete,
3293 aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
3295 aead_request_set_ad(subreq, req->assoclen);
3297 return (dir == SAFEXCEL_ENCRYPT) ?
3298 crypto_aead_encrypt(subreq) :
3299 crypto_aead_decrypt(subreq);
3302 static int safexcel_aead_sm4cbc_sm3_encrypt(struct aead_request *req)
3304 struct safexcel_cipher_req *creq = aead_request_ctx(req);
3306 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3307 if (req->cryptlen & (SM4_BLOCK_SIZE - 1))
3309 else if (req->cryptlen || req->assoclen) /* If input length > 0 only */
3310 return safexcel_queue_req(&req->base, creq, SAFEXCEL_ENCRYPT);
3312 /* HW cannot do full (AAD+payload) zero length, use fallback */
3313 return safexcel_aead_fallback_crypt(req, SAFEXCEL_ENCRYPT);
3316 static int safexcel_aead_sm4cbc_sm3_decrypt(struct aead_request *req)
3318 struct safexcel_cipher_req *creq = aead_request_ctx(req);
3319 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
3321 /* Workaround for HW bug: EIP96 4.3 does not report blocksize error */
3322 if ((req->cryptlen - crypto_aead_authsize(tfm)) & (SM4_BLOCK_SIZE - 1))
3324 else if (req->cryptlen > crypto_aead_authsize(tfm) || req->assoclen)
3325 /* If input length > 0 only */
3326 return safexcel_queue_req(&req->base, creq, SAFEXCEL_DECRYPT);
3328 /* HW cannot do full (AAD+payload) zero length, use fallback */
3329 return safexcel_aead_fallback_crypt(req, SAFEXCEL_DECRYPT);
3332 static int safexcel_aead_sm4cbc_sm3_cra_init(struct crypto_tfm *tfm)
3334 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3336 safexcel_aead_fallback_cra_init(tfm);
3337 ctx->alg = SAFEXCEL_SM4;
3338 ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_SM3;
3339 ctx->state_sz = SM3_DIGEST_SIZE;
3343 struct safexcel_alg_template safexcel_alg_authenc_hmac_sm3_cbc_sm4 = {
3344 .type = SAFEXCEL_ALG_TYPE_AEAD,
3345 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_SM3,
3347 .setkey = safexcel_aead_fallback_setkey,
3348 .setauthsize = safexcel_aead_fallback_setauthsize,
3349 .encrypt = safexcel_aead_sm4cbc_sm3_encrypt,
3350 .decrypt = safexcel_aead_sm4cbc_sm3_decrypt,
3351 .ivsize = SM4_BLOCK_SIZE,
3352 .maxauthsize = SM3_DIGEST_SIZE,
3354 .cra_name = "authenc(hmac(sm3),cbc(sm4))",
3355 .cra_driver_name = "safexcel-authenc-hmac-sm3-cbc-sm4",
3356 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3357 .cra_flags = CRYPTO_ALG_ASYNC |
3358 CRYPTO_ALG_KERN_DRIVER_ONLY |
3359 CRYPTO_ALG_NEED_FALLBACK,
3360 .cra_blocksize = SM4_BLOCK_SIZE,
3361 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3363 .cra_init = safexcel_aead_sm4cbc_sm3_cra_init,
3364 .cra_exit = safexcel_aead_fallback_cra_exit,
3365 .cra_module = THIS_MODULE,
3370 static int safexcel_aead_sm4ctr_sha1_cra_init(struct crypto_tfm *tfm)
3372 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3374 safexcel_aead_sm4cbc_sha1_cra_init(tfm);
3375 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD;
3379 struct safexcel_alg_template safexcel_alg_authenc_hmac_sha1_ctr_sm4 = {
3380 .type = SAFEXCEL_ALG_TYPE_AEAD,
3381 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_SHA1,
3383 .setkey = safexcel_aead_setkey,
3384 .encrypt = safexcel_aead_encrypt,
3385 .decrypt = safexcel_aead_decrypt,
3386 .ivsize = CTR_RFC3686_IV_SIZE,
3387 .maxauthsize = SHA1_DIGEST_SIZE,
3389 .cra_name = "authenc(hmac(sha1),rfc3686(ctr(sm4)))",
3390 .cra_driver_name = "safexcel-authenc-hmac-sha1-ctr-sm4",
3391 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3392 .cra_flags = CRYPTO_ALG_ASYNC |
3393 CRYPTO_ALG_KERN_DRIVER_ONLY,
3395 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3397 .cra_init = safexcel_aead_sm4ctr_sha1_cra_init,
3398 .cra_exit = safexcel_aead_cra_exit,
3399 .cra_module = THIS_MODULE,
3404 static int safexcel_aead_sm4ctr_sm3_cra_init(struct crypto_tfm *tfm)
3406 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3408 safexcel_aead_sm4cbc_sm3_cra_init(tfm);
3409 ctx->mode = CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD;
3413 struct safexcel_alg_template safexcel_alg_authenc_hmac_sm3_ctr_sm4 = {
3414 .type = SAFEXCEL_ALG_TYPE_AEAD,
3415 .algo_mask = SAFEXCEL_ALG_SM4 | SAFEXCEL_ALG_SM3,
3417 .setkey = safexcel_aead_setkey,
3418 .encrypt = safexcel_aead_encrypt,
3419 .decrypt = safexcel_aead_decrypt,
3420 .ivsize = CTR_RFC3686_IV_SIZE,
3421 .maxauthsize = SM3_DIGEST_SIZE,
3423 .cra_name = "authenc(hmac(sm3),rfc3686(ctr(sm4)))",
3424 .cra_driver_name = "safexcel-authenc-hmac-sm3-ctr-sm4",
3425 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3426 .cra_flags = CRYPTO_ALG_ASYNC |
3427 CRYPTO_ALG_KERN_DRIVER_ONLY,
3429 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3431 .cra_init = safexcel_aead_sm4ctr_sm3_cra_init,
3432 .cra_exit = safexcel_aead_cra_exit,
3433 .cra_module = THIS_MODULE,
3438 static int safexcel_rfc4106_gcm_setkey(struct crypto_aead *ctfm, const u8 *key,
3441 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
3442 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3444 /* last 4 bytes of key are the nonce! */
3445 ctx->nonce = *(u32 *)(key + len - CTR_RFC3686_NONCE_SIZE);
3447 len -= CTR_RFC3686_NONCE_SIZE;
3448 return safexcel_aead_gcm_setkey(ctfm, key, len);
3451 static int safexcel_rfc4106_gcm_setauthsize(struct crypto_aead *tfm,
3452 unsigned int authsize)
3454 return crypto_rfc4106_check_authsize(authsize);
3457 static int safexcel_rfc4106_encrypt(struct aead_request *req)
3459 return crypto_ipsec_check_assoclen(req->assoclen) ?:
3460 safexcel_aead_encrypt(req);
3463 static int safexcel_rfc4106_decrypt(struct aead_request *req)
3465 return crypto_ipsec_check_assoclen(req->assoclen) ?:
3466 safexcel_aead_decrypt(req);
3469 static int safexcel_rfc4106_gcm_cra_init(struct crypto_tfm *tfm)
3471 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3474 ret = safexcel_aead_gcm_cra_init(tfm);
3475 ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP;
3479 struct safexcel_alg_template safexcel_alg_rfc4106_gcm = {
3480 .type = SAFEXCEL_ALG_TYPE_AEAD,
3481 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_GHASH,
3483 .setkey = safexcel_rfc4106_gcm_setkey,
3484 .setauthsize = safexcel_rfc4106_gcm_setauthsize,
3485 .encrypt = safexcel_rfc4106_encrypt,
3486 .decrypt = safexcel_rfc4106_decrypt,
3487 .ivsize = GCM_RFC4106_IV_SIZE,
3488 .maxauthsize = GHASH_DIGEST_SIZE,
3490 .cra_name = "rfc4106(gcm(aes))",
3491 .cra_driver_name = "safexcel-rfc4106-gcm-aes",
3492 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3493 .cra_flags = CRYPTO_ALG_ASYNC |
3494 CRYPTO_ALG_KERN_DRIVER_ONLY,
3496 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3498 .cra_init = safexcel_rfc4106_gcm_cra_init,
3499 .cra_exit = safexcel_aead_gcm_cra_exit,
3504 static int safexcel_rfc4543_gcm_setauthsize(struct crypto_aead *tfm,
3505 unsigned int authsize)
3507 if (authsize != GHASH_DIGEST_SIZE)
3513 static int safexcel_rfc4543_gcm_cra_init(struct crypto_tfm *tfm)
3515 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3518 ret = safexcel_aead_gcm_cra_init(tfm);
3519 ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP_GMAC;
3523 struct safexcel_alg_template safexcel_alg_rfc4543_gcm = {
3524 .type = SAFEXCEL_ALG_TYPE_AEAD,
3525 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_GHASH,
3527 .setkey = safexcel_rfc4106_gcm_setkey,
3528 .setauthsize = safexcel_rfc4543_gcm_setauthsize,
3529 .encrypt = safexcel_rfc4106_encrypt,
3530 .decrypt = safexcel_rfc4106_decrypt,
3531 .ivsize = GCM_RFC4543_IV_SIZE,
3532 .maxauthsize = GHASH_DIGEST_SIZE,
3534 .cra_name = "rfc4543(gcm(aes))",
3535 .cra_driver_name = "safexcel-rfc4543-gcm-aes",
3536 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3537 .cra_flags = CRYPTO_ALG_ASYNC |
3538 CRYPTO_ALG_KERN_DRIVER_ONLY,
3540 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3542 .cra_init = safexcel_rfc4543_gcm_cra_init,
3543 .cra_exit = safexcel_aead_gcm_cra_exit,
3548 static int safexcel_rfc4309_ccm_setkey(struct crypto_aead *ctfm, const u8 *key,
3551 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
3552 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3554 /* First byte of the nonce = L = always 3 for RFC4309 (4 byte ctr) */
3555 *(u8 *)&ctx->nonce = EIP197_AEAD_IPSEC_COUNTER_SIZE - 1;
3556 /* last 3 bytes of key are the nonce! */
3557 memcpy((u8 *)&ctx->nonce + 1, key + len -
3558 EIP197_AEAD_IPSEC_CCM_NONCE_SIZE,
3559 EIP197_AEAD_IPSEC_CCM_NONCE_SIZE);
3561 len -= EIP197_AEAD_IPSEC_CCM_NONCE_SIZE;
3562 return safexcel_aead_ccm_setkey(ctfm, key, len);
3565 static int safexcel_rfc4309_ccm_setauthsize(struct crypto_aead *tfm,
3566 unsigned int authsize)
3568 /* Borrowed from crypto/ccm.c */
3581 static int safexcel_rfc4309_ccm_encrypt(struct aead_request *req)
3583 struct safexcel_cipher_req *creq = aead_request_ctx(req);
3585 /* Borrowed from crypto/ccm.c */
3586 if (req->assoclen != 16 && req->assoclen != 20)
3589 return safexcel_queue_req(&req->base, creq, SAFEXCEL_ENCRYPT);
3592 static int safexcel_rfc4309_ccm_decrypt(struct aead_request *req)
3594 struct safexcel_cipher_req *creq = aead_request_ctx(req);
3596 /* Borrowed from crypto/ccm.c */
3597 if (req->assoclen != 16 && req->assoclen != 20)
3600 return safexcel_queue_req(&req->base, creq, SAFEXCEL_DECRYPT);
3603 static int safexcel_rfc4309_ccm_cra_init(struct crypto_tfm *tfm)
3605 struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
3608 ret = safexcel_aead_ccm_cra_init(tfm);
3609 ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP;
3613 struct safexcel_alg_template safexcel_alg_rfc4309_ccm = {
3614 .type = SAFEXCEL_ALG_TYPE_AEAD,
3615 .algo_mask = SAFEXCEL_ALG_AES | SAFEXCEL_ALG_CBC_MAC_ALL,
3617 .setkey = safexcel_rfc4309_ccm_setkey,
3618 .setauthsize = safexcel_rfc4309_ccm_setauthsize,
3619 .encrypt = safexcel_rfc4309_ccm_encrypt,
3620 .decrypt = safexcel_rfc4309_ccm_decrypt,
3621 .ivsize = EIP197_AEAD_IPSEC_IV_SIZE,
3622 .maxauthsize = AES_BLOCK_SIZE,
3624 .cra_name = "rfc4309(ccm(aes))",
3625 .cra_driver_name = "safexcel-rfc4309-ccm-aes",
3626 .cra_priority = SAFEXCEL_CRA_PRIORITY,
3627 .cra_flags = CRYPTO_ALG_ASYNC |
3628 CRYPTO_ALG_KERN_DRIVER_ONLY,
3630 .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
3632 .cra_init = safexcel_rfc4309_ccm_cra_init,
3633 .cra_exit = safexcel_aead_cra_exit,
3634 .cra_module = THIS_MODULE,