Skip to content

Commit 77932c6

Browse files
cristibirsancristibirsan
committed
Merge branch 'at91-5.10-trunk/crypto' into linux-5.10-at91
2 parents b31cd46 + df9f807 commit 77932c6

2 files changed

Lines changed: 95 additions & 39 deletions

File tree

‎drivers/crypto/atmel-aes.c‎

Lines changed: 66 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -143,6 +143,7 @@ struct atmel_aes_xts_ctx {
143143
struct atmel_aes_base_ctx base;
144144

145145
u32 key2[AES_KEYSIZE_256 / sizeof(u32)];
146+
struct crypto_skcipher *fallback_tfm;
146147
};
147148

148149
#if IS_ENABLED(CONFIG_CRYPTO_DEV_ATMEL_AUTHENC)
@@ -155,6 +156,7 @@ struct atmel_aes_authenc_ctx {
155156
struct atmel_aes_reqctx {
156157
unsigned long mode;
157158
u8 lastc[AES_BLOCK_SIZE];
159+
struct skcipher_request fallback_req;
158160
};
159161

160162
#if IS_ENABLED(CONFIG_CRYPTO_DEV_ATMEL_AUTHENC)
@@ -1083,12 +1085,49 @@ static int atmel_aes_ctr_start(struct atmel_aes_dev *dd)
10831085
return atmel_aes_ctr_transfer(dd);
10841086
}
10851087

1088+
static int atmel_aes_xts_fallback(struct skcipher_request *req, bool enc)
1089+
{
1090+
struct atmel_aes_reqctx *rctx = skcipher_request_ctx(req);
1091+
struct atmel_aes_xts_ctx *ctx = crypto_skcipher_ctx(
1092+
crypto_skcipher_reqtfm(req));
1093+
1094+
skcipher_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
1095+
skcipher_request_set_callback(&rctx->fallback_req, req->base.flags,
1096+
req->base.complete, req->base.data);
1097+
skcipher_request_set_crypt(&rctx->fallback_req, req->src, req->dst,
1098+
req->cryptlen, req->iv);
1099+
1100+
return enc ? crypto_skcipher_encrypt(&rctx->fallback_req) :
1101+
crypto_skcipher_decrypt(&rctx->fallback_req);
1102+
}
1103+
10861104
static int atmel_aes_crypt(struct skcipher_request *req, unsigned long mode)
10871105
{
10881106
struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
10891107
struct atmel_aes_base_ctx *ctx = crypto_skcipher_ctx(skcipher);
10901108
struct atmel_aes_reqctx *rctx;
10911109
struct atmel_aes_dev *dd;
1110+
u32 opmode = mode & AES_FLAGS_OPMODE_MASK;
1111+
1112+
if (opmode == AES_FLAGS_XTS) {
1113+
if (req->cryptlen < XTS_BLOCK_SIZE)
1114+
return -EINVAL;
1115+
1116+
if (!IS_ALIGNED(req->cryptlen, XTS_BLOCK_SIZE))
1117+
return atmel_aes_xts_fallback(req,
1118+
mode & AES_FLAGS_ENCRYPT);
1119+
}
1120+
1121+
/*
1122+
* ECB, CBC, CFB, OFB or CTR mode require the plaintext and ciphertext
1123+
* to have a positve integer length.
1124+
*/
1125+
if (!req->cryptlen && opmode != AES_FLAGS_XTS)
1126+
return 0;
1127+
1128+
if ((opmode == AES_FLAGS_ECB || opmode == AES_FLAGS_CBC) &&
1129+
!IS_ALIGNED(req->cryptlen, crypto_skcipher_blocksize(skcipher)))
1130+
return -EINVAL;
10921131

10931132
switch (mode & AES_FLAGS_OPMODE_MASK) {
10941133
case AES_FLAGS_CFB8:
@@ -1120,7 +1159,7 @@ static int atmel_aes_crypt(struct skcipher_request *req, unsigned long mode)
11201159
rctx = skcipher_request_ctx(req);
11211160
rctx->mode = mode;
11221161

1123-
if ((mode & AES_FLAGS_OPMODE_MASK) != AES_FLAGS_ECB &&
1162+
if (opmode != AES_FLAGS_ECB &&
11241163
!(mode & AES_FLAGS_ENCRYPT) && req->src == req->dst) {
11251164
unsigned int ivsize = crypto_skcipher_ivsize(skcipher);
11261165

@@ -1290,7 +1329,7 @@ static struct skcipher_alg aes_algs[] = {
12901329
{
12911330
.base.cra_name = "ofb(aes)",
12921331
.base.cra_driver_name = "atmel-ofb-aes",
1293-
.base.cra_blocksize = AES_BLOCK_SIZE,
1332+
.base.cra_blocksize = 1,
12941333
.base.cra_ctxsize = sizeof(struct atmel_aes_ctx),
12951334

12961335
.init = atmel_aes_init_tfm,
@@ -1849,6 +1888,13 @@ static int atmel_aes_xts_setkey(struct crypto_skcipher *tfm, const u8 *key,
18491888
if (err)
18501889
return err;
18511890

1891+
crypto_skcipher_clear_flags(ctx->fallback_tfm, CRYPTO_TFM_REQ_MASK);
1892+
crypto_skcipher_set_flags(ctx->fallback_tfm, tfm->base.crt_flags &
1893+
CRYPTO_TFM_REQ_MASK);
1894+
err = crypto_skcipher_setkey(ctx->fallback_tfm, key, keylen);
1895+
if (err)
1896+
return err;
1897+
18521898
memcpy(ctx->base.key, key, keylen/2);
18531899
memcpy(ctx->key2, key + keylen/2, keylen/2);
18541900
ctx->base.keylen = keylen/2;
@@ -1869,18 +1915,33 @@ static int atmel_aes_xts_decrypt(struct skcipher_request *req)
18691915
static int atmel_aes_xts_init_tfm(struct crypto_skcipher *tfm)
18701916
{
18711917
struct atmel_aes_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
1918+
const char *tfm_name = crypto_tfm_alg_name(&tfm->base);
18721919

1873-
crypto_skcipher_set_reqsize(tfm, sizeof(struct atmel_aes_reqctx));
1920+
ctx->fallback_tfm = crypto_alloc_skcipher(tfm_name, 0,
1921+
CRYPTO_ALG_NEED_FALLBACK);
1922+
if (IS_ERR(ctx->fallback_tfm))
1923+
return PTR_ERR(ctx->fallback_tfm);
1924+
1925+
crypto_skcipher_set_reqsize(tfm, sizeof(struct atmel_aes_reqctx) +
1926+
crypto_skcipher_reqsize(ctx->fallback_tfm));
18741927
ctx->base.start = atmel_aes_xts_start;
18751928

18761929
return 0;
18771930
}
18781931

1932+
static void atmel_aes_xts_exit_tfm(struct crypto_skcipher *tfm)
1933+
{
1934+
struct atmel_aes_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
1935+
1936+
crypto_free_skcipher(ctx->fallback_tfm);
1937+
}
1938+
18791939
static struct skcipher_alg aes_xts_alg = {
18801940
.base.cra_name = "xts(aes)",
18811941
.base.cra_driver_name = "atmel-xts-aes",
18821942
.base.cra_blocksize = AES_BLOCK_SIZE,
18831943
.base.cra_ctxsize = sizeof(struct atmel_aes_xts_ctx),
1944+
.base.cra_flags = CRYPTO_ALG_NEED_FALLBACK,
18841945

18851946
.min_keysize = 2 * AES_MIN_KEY_SIZE,
18861947
.max_keysize = 2 * AES_MAX_KEY_SIZE,
@@ -1889,6 +1950,7 @@ static struct skcipher_alg aes_xts_alg = {
18891950
.encrypt = atmel_aes_xts_encrypt,
18901951
.decrypt = atmel_aes_xts_decrypt,
18911952
.init = atmel_aes_xts_init_tfm,
1953+
.exit = atmel_aes_xts_exit_tfm,
18921954
};
18931955

18941956
#if IS_ENABLED(CONFIG_CRYPTO_DEV_ATMEL_AUTHENC)
@@ -2358,7 +2420,7 @@ static void atmel_aes_unregister_algs(struct atmel_aes_dev *dd)
23582420

23592421
static void atmel_aes_crypto_alg_init(struct crypto_alg *alg)
23602422
{
2361-
alg->cra_flags = CRYPTO_ALG_ASYNC;
2423+
alg->cra_flags |= CRYPTO_ALG_ASYNC;
23622424
alg->cra_alignmask = 0xf;
23632425
alg->cra_priority = ATMEL_AES_PRIORITY;
23642426
alg->cra_module = THIS_MODULE;

‎drivers/crypto/atmel-tdes.c‎

Lines changed: 29 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -196,20 +196,14 @@ static void atmel_tdes_write_n(struct atmel_tdes_dev *dd, u32 offset,
196196
atmel_tdes_write(dd, offset, *value);
197197
}
198198

199-
static struct atmel_tdes_dev *atmel_tdes_find_dev(struct atmel_tdes_ctx *ctx)
199+
static struct atmel_tdes_dev *atmel_tdes_dev_alloc(void)
200200
{
201-
struct atmel_tdes_dev *tdes_dd = NULL;
202-
struct atmel_tdes_dev *tmp;
201+
struct atmel_tdes_dev *tmp, *tdes_dd = NULL;
203202

204203
spin_lock_bh(&atmel_tdes.lock);
205-
if (!ctx->dd) {
206-
list_for_each_entry(tmp, &atmel_tdes.dev_list, list) {
207-
tdes_dd = tmp;
208-
break;
209-
}
210-
ctx->dd = tdes_dd;
211-
} else {
212-
tdes_dd = ctx->dd;
204+
list_for_each_entry(tmp, &atmel_tdes.dev_list, list) {
205+
tdes_dd = tmp;
206+
break;
213207
}
214208
spin_unlock_bh(&atmel_tdes.lock);
215209

@@ -320,7 +314,7 @@ static int atmel_tdes_crypt_pdc_stop(struct atmel_tdes_dev *dd)
320314
dd->buf_out, dd->buflen, dd->dma_size, 1);
321315
if (count != dd->dma_size) {
322316
err = -EINVAL;
323-
pr_err("not all data converted: %zu\n", count);
317+
dev_dbg(dd->dev, "not all data converted: %zu\n", count);
324318
}
325319
}
326320

@@ -337,24 +331,24 @@ static int atmel_tdes_buff_init(struct atmel_tdes_dev *dd)
337331
dd->buflen &= ~(DES_BLOCK_SIZE - 1);
338332

339333
if (!dd->buf_in || !dd->buf_out) {
340-
dev_err(dd->dev, "unable to alloc pages.\n");
334+
dev_dbg(dd->dev, "unable to alloc pages.\n");
341335
goto err_alloc;
342336
}
343337

344338
/* MAP here */
345339
dd->dma_addr_in = dma_map_single(dd->dev, dd->buf_in,
346340
dd->buflen, DMA_TO_DEVICE);
347-
if (dma_mapping_error(dd->dev, dd->dma_addr_in)) {
348-
dev_err(dd->dev, "dma %zd bytes error\n", dd->buflen);
349-
err = -EINVAL;
341+
err = dma_mapping_error(dd->dev, dd->dma_addr_in);
342+
if (err) {
343+
dev_dbg(dd->dev, "dma %zd bytes error\n", dd->buflen);
350344
goto err_map_in;
351345
}
352346

353347
dd->dma_addr_out = dma_map_single(dd->dev, dd->buf_out,
354348
dd->buflen, DMA_FROM_DEVICE);
355-
if (dma_mapping_error(dd->dev, dd->dma_addr_out)) {
356-
dev_err(dd->dev, "dma %zd bytes error\n", dd->buflen);
357-
err = -EINVAL;
349+
err = dma_mapping_error(dd->dev, dd->dma_addr_out);
350+
if (err) {
351+
dev_dbg(dd->dev, "dma %zd bytes error\n", dd->buflen);
358352
goto err_map_out;
359353
}
360354

@@ -367,8 +361,6 @@ static int atmel_tdes_buff_init(struct atmel_tdes_dev *dd)
367361
err_alloc:
368362
free_page((unsigned long)dd->buf_out);
369363
free_page((unsigned long)dd->buf_in);
370-
if (err)
371-
pr_err("error: %d\n", err);
372364
return err;
373365
}
374366

@@ -520,14 +512,14 @@ static int atmel_tdes_crypt_start(struct atmel_tdes_dev *dd)
520512

521513
err = dma_map_sg(dd->dev, dd->in_sg, 1, DMA_TO_DEVICE);
522514
if (!err) {
523-
dev_err(dd->dev, "dma_map_sg() error\n");
515+
dev_dbg(dd->dev, "dma_map_sg() error\n");
524516
return -EINVAL;
525517
}
526518

527519
err = dma_map_sg(dd->dev, dd->out_sg, 1,
528520
DMA_FROM_DEVICE);
529521
if (!err) {
530-
dev_err(dd->dev, "dma_map_sg() error\n");
522+
dev_dbg(dd->dev, "dma_map_sg() error\n");
531523
dma_unmap_sg(dd->dev, dd->in_sg, 1,
532524
DMA_TO_DEVICE);
533525
return -EINVAL;
@@ -646,7 +638,6 @@ static int atmel_tdes_handle_queue(struct atmel_tdes_dev *dd,
646638
rctx->mode &= TDES_FLAGS_MODE_MASK;
647639
dd->flags = (dd->flags & ~TDES_FLAGS_MODE_MASK) | rctx->mode;
648640
dd->ctx = ctx;
649-
ctx->dd = dd;
650641

651642
err = atmel_tdes_write_ctrl(dd);
652643
if (!err)
@@ -679,7 +670,7 @@ static int atmel_tdes_crypt_dma_stop(struct atmel_tdes_dev *dd)
679670
dd->buf_out, dd->buflen, dd->dma_size, 1);
680671
if (count != dd->dma_size) {
681672
err = -EINVAL;
682-
pr_err("not all data converted: %zu\n", count);
673+
dev_dbg(dd->dev, "not all data converted: %zu\n", count);
683674
}
684675
}
685676
}
@@ -691,35 +682,39 @@ static int atmel_tdes_crypt(struct skcipher_request *req, unsigned long mode)
691682
struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
692683
struct atmel_tdes_ctx *ctx = crypto_skcipher_ctx(skcipher);
693684
struct atmel_tdes_reqctx *rctx = skcipher_request_ctx(req);
685+
struct device *dev = ctx->dd->dev;
686+
687+
if (!req->cryptlen)
688+
return 0;
694689

695690
switch (mode & TDES_FLAGS_OPMODE_MASK) {
696691
case TDES_FLAGS_CFB8:
697692
if (!IS_ALIGNED(req->cryptlen, CFB8_BLOCK_SIZE)) {
698-
pr_err("request size is not exact amount of CFB8 blocks\n");
693+
dev_dbg(dev, "request size is not exact amount of CFB8 blocks\n");
699694
return -EINVAL;
700695
}
701696
ctx->block_size = CFB8_BLOCK_SIZE;
702697
break;
703698

704699
case TDES_FLAGS_CFB16:
705700
if (!IS_ALIGNED(req->cryptlen, CFB16_BLOCK_SIZE)) {
706-
pr_err("request size is not exact amount of CFB16 blocks\n");
701+
dev_dbg(dev, "request size is not exact amount of CFB16 blocks\n");
707702
return -EINVAL;
708703
}
709704
ctx->block_size = CFB16_BLOCK_SIZE;
710705
break;
711706

712707
case TDES_FLAGS_CFB32:
713708
if (!IS_ALIGNED(req->cryptlen, CFB32_BLOCK_SIZE)) {
714-
pr_err("request size is not exact amount of CFB32 blocks\n");
709+
dev_dbg(dev, "request size is not exact amount of CFB32 blocks\n");
715710
return -EINVAL;
716711
}
717712
ctx->block_size = CFB32_BLOCK_SIZE;
718713
break;
719714

720715
default:
721716
if (!IS_ALIGNED(req->cryptlen, DES_BLOCK_SIZE)) {
722-
pr_err("request size is not exact amount of DES blocks\n");
717+
dev_dbg(dev, "request size is not exact amount of DES blocks\n");
723718
return -EINVAL;
724719
}
725720
ctx->block_size = DES_BLOCK_SIZE;
@@ -897,14 +892,13 @@ static int atmel_tdes_ofb_decrypt(struct skcipher_request *req)
897892
static int atmel_tdes_init_tfm(struct crypto_skcipher *tfm)
898893
{
899894
struct atmel_tdes_ctx *ctx = crypto_skcipher_ctx(tfm);
900-
struct atmel_tdes_dev *dd;
901-
902-
crypto_skcipher_set_reqsize(tfm, sizeof(struct atmel_tdes_reqctx));
903895

904-
dd = atmel_tdes_find_dev(ctx);
905-
if (!dd)
896+
ctx->dd = atmel_tdes_dev_alloc();
897+
if (!ctx->dd)
906898
return -ENODEV;
907899

900+
crypto_skcipher_set_reqsize(tfm, sizeof(struct atmel_tdes_reqctx));
901+
908902
return 0;
909903
}
910904

@@ -999,7 +993,7 @@ static struct skcipher_alg tdes_algs[] = {
999993
{
1000994
.base.cra_name = "ofb(des)",
1001995
.base.cra_driver_name = "atmel-ofb-des",
1002-
.base.cra_blocksize = DES_BLOCK_SIZE,
996+
.base.cra_blocksize = 1,
1003997
.base.cra_alignmask = 0x7,
1004998

1005999
.min_keysize = DES_KEY_SIZE,

0 commit comments

Comments
 (0)