1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Crypto acceleration support for Rockchip RK3288
4 *
5 * Copyright (c) 2015, Fuzhou Rockchip Electronics Co., Ltd
6 *
7 * Author: Zain Wang <zain.wang@rock-chips.com>
8 *
9 * Some ideas are from marvell-cesa.c and s5p-sss.c driver.
10 */
11
12 #include <crypto/engine.h>
13 #include <crypto/internal/skcipher.h>
14 #include <crypto/scatterwalk.h>
15 #include <linux/device.h>
16 #include <linux/err.h>
17 #include <linux/kernel.h>
18 #include <linux/string.h>
19 #include "rk3288_crypto.h"
20
21 #define RK_CRYPTO_DEC BIT(0)
22
rk_cipher_need_fallback(struct skcipher_request * req)23 static int rk_cipher_need_fallback(struct skcipher_request *req)
24 {
25 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
26 struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
27 struct rk_crypto_tmp *algt = container_of(alg, struct rk_crypto_tmp, alg.skcipher.base);
28 struct scatterlist *sgs, *sgd;
29 unsigned int stodo, dtodo, len;
30 unsigned int bs = crypto_skcipher_blocksize(tfm);
31
32 if (!req->cryptlen)
33 return true;
34
35 len = req->cryptlen;
36 sgs = req->src;
37 sgd = req->dst;
38 while (sgs && sgd) {
39 if (!IS_ALIGNED(sgs->offset, sizeof(u32))) {
40 algt->stat_fb_align++;
41 return true;
42 }
43 if (!IS_ALIGNED(sgd->offset, sizeof(u32))) {
44 algt->stat_fb_align++;
45 return true;
46 }
47 stodo = min(len, sgs->length);
48 if (stodo % bs) {
49 algt->stat_fb_len++;
50 return true;
51 }
52 dtodo = min(len, sgd->length);
53 if (dtodo % bs) {
54 algt->stat_fb_len++;
55 return true;
56 }
57 if (stodo != dtodo) {
58 algt->stat_fb_sgdiff++;
59 return true;
60 }
61 len -= stodo;
62 sgs = sg_next(sgs);
63 sgd = sg_next(sgd);
64 }
65 return false;
66 }
67
rk_cipher_fallback(struct skcipher_request * areq)68 static int rk_cipher_fallback(struct skcipher_request *areq)
69 {
70 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
71 struct rk_cipher_ctx *op = crypto_skcipher_ctx(tfm);
72 struct rk_cipher_rctx *rctx = skcipher_request_ctx(areq);
73 struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
74 struct rk_crypto_tmp *algt = container_of(alg, struct rk_crypto_tmp, alg.skcipher.base);
75 int err;
76
77 algt->stat_fb++;
78
79 skcipher_request_set_tfm(&rctx->fallback_req, op->fallback_tfm);
80 skcipher_request_set_callback(&rctx->fallback_req, areq->base.flags,
81 areq->base.complete, areq->base.data);
82 skcipher_request_set_crypt(&rctx->fallback_req, areq->src, areq->dst,
83 areq->cryptlen, areq->iv);
84 if (rctx->mode & RK_CRYPTO_DEC)
85 err = crypto_skcipher_decrypt(&rctx->fallback_req);
86 else
87 err = crypto_skcipher_encrypt(&rctx->fallback_req);
88 return err;
89 }
90
rk_cipher_handle_req(struct skcipher_request * req)91 static int rk_cipher_handle_req(struct skcipher_request *req)
92 {
93 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
94 struct rk_crypto_info *rkc;
95 struct crypto_engine *engine;
96
97 if (rk_cipher_need_fallback(req))
98 return rk_cipher_fallback(req);
99
100 rkc = get_rk_crypto();
101
102 engine = rkc->engine;
103 rctx->dev = rkc;
104
105 return crypto_transfer_skcipher_request_to_engine(engine, req);
106 }
107
rk_aes_setkey(struct crypto_skcipher * cipher,const u8 * key,unsigned int keylen)108 static int rk_aes_setkey(struct crypto_skcipher *cipher,
109 const u8 *key, unsigned int keylen)
110 {
111 struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
112 struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
113
114 if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
115 keylen != AES_KEYSIZE_256)
116 return -EINVAL;
117 ctx->keylen = keylen;
118 memcpy(ctx->key, key, keylen);
119
120 return crypto_skcipher_setkey(ctx->fallback_tfm, key, keylen);
121 }
122
rk_des_setkey(struct crypto_skcipher * cipher,const u8 * key,unsigned int keylen)123 static int rk_des_setkey(struct crypto_skcipher *cipher,
124 const u8 *key, unsigned int keylen)
125 {
126 struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(cipher);
127 int err;
128
129 err = verify_skcipher_des_key(cipher, key);
130 if (err)
131 return err;
132
133 ctx->keylen = keylen;
134 memcpy(ctx->key, key, keylen);
135
136 return crypto_skcipher_setkey(ctx->fallback_tfm, key, keylen);
137 }
138
rk_tdes_setkey(struct crypto_skcipher * cipher,const u8 * key,unsigned int keylen)139 static int rk_tdes_setkey(struct crypto_skcipher *cipher,
140 const u8 *key, unsigned int keylen)
141 {
142 struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(cipher);
143 int err;
144
145 err = verify_skcipher_des3_key(cipher, key);
146 if (err)
147 return err;
148
149 ctx->keylen = keylen;
150 memcpy(ctx->key, key, keylen);
151
152 return crypto_skcipher_setkey(ctx->fallback_tfm, key, keylen);
153 }
154
rk_aes_ecb_encrypt(struct skcipher_request * req)155 static int rk_aes_ecb_encrypt(struct skcipher_request *req)
156 {
157 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
158
159 rctx->mode = RK_CRYPTO_AES_ECB_MODE;
160 return rk_cipher_handle_req(req);
161 }
162
rk_aes_ecb_decrypt(struct skcipher_request * req)163 static int rk_aes_ecb_decrypt(struct skcipher_request *req)
164 {
165 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
166
167 rctx->mode = RK_CRYPTO_AES_ECB_MODE | RK_CRYPTO_DEC;
168 return rk_cipher_handle_req(req);
169 }
170
rk_aes_cbc_encrypt(struct skcipher_request * req)171 static int rk_aes_cbc_encrypt(struct skcipher_request *req)
172 {
173 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
174
175 rctx->mode = RK_CRYPTO_AES_CBC_MODE;
176 return rk_cipher_handle_req(req);
177 }
178
rk_aes_cbc_decrypt(struct skcipher_request * req)179 static int rk_aes_cbc_decrypt(struct skcipher_request *req)
180 {
181 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
182
183 rctx->mode = RK_CRYPTO_AES_CBC_MODE | RK_CRYPTO_DEC;
184 return rk_cipher_handle_req(req);
185 }
186
rk_des_ecb_encrypt(struct skcipher_request * req)187 static int rk_des_ecb_encrypt(struct skcipher_request *req)
188 {
189 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
190
191 rctx->mode = 0;
192 return rk_cipher_handle_req(req);
193 }
194
rk_des_ecb_decrypt(struct skcipher_request * req)195 static int rk_des_ecb_decrypt(struct skcipher_request *req)
196 {
197 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
198
199 rctx->mode = RK_CRYPTO_DEC;
200 return rk_cipher_handle_req(req);
201 }
202
rk_des_cbc_encrypt(struct skcipher_request * req)203 static int rk_des_cbc_encrypt(struct skcipher_request *req)
204 {
205 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
206
207 rctx->mode = RK_CRYPTO_TDES_CHAINMODE_CBC;
208 return rk_cipher_handle_req(req);
209 }
210
rk_des_cbc_decrypt(struct skcipher_request * req)211 static int rk_des_cbc_decrypt(struct skcipher_request *req)
212 {
213 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
214
215 rctx->mode = RK_CRYPTO_TDES_CHAINMODE_CBC | RK_CRYPTO_DEC;
216 return rk_cipher_handle_req(req);
217 }
218
rk_des3_ede_ecb_encrypt(struct skcipher_request * req)219 static int rk_des3_ede_ecb_encrypt(struct skcipher_request *req)
220 {
221 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
222
223 rctx->mode = RK_CRYPTO_TDES_SELECT;
224 return rk_cipher_handle_req(req);
225 }
226
rk_des3_ede_ecb_decrypt(struct skcipher_request * req)227 static int rk_des3_ede_ecb_decrypt(struct skcipher_request *req)
228 {
229 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
230
231 rctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_DEC;
232 return rk_cipher_handle_req(req);
233 }
234
rk_des3_ede_cbc_encrypt(struct skcipher_request * req)235 static int rk_des3_ede_cbc_encrypt(struct skcipher_request *req)
236 {
237 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
238
239 rctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_TDES_CHAINMODE_CBC;
240 return rk_cipher_handle_req(req);
241 }
242
rk_des3_ede_cbc_decrypt(struct skcipher_request * req)243 static int rk_des3_ede_cbc_decrypt(struct skcipher_request *req)
244 {
245 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
246
247 rctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_TDES_CHAINMODE_CBC |
248 RK_CRYPTO_DEC;
249 return rk_cipher_handle_req(req);
250 }
251
rk_cipher_hw_init(struct rk_crypto_info * dev,struct skcipher_request * req)252 static void rk_cipher_hw_init(struct rk_crypto_info *dev, struct skcipher_request *req)
253 {
254 struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(req);
255 struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
256 struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
257 struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(cipher);
258 u32 block, conf_reg = 0;
259
260 block = crypto_tfm_alg_blocksize(tfm);
261
262 if (block == DES_BLOCK_SIZE) {
263 rctx->mode |= RK_CRYPTO_TDES_FIFO_MODE |
264 RK_CRYPTO_TDES_BYTESWAP_KEY |
265 RK_CRYPTO_TDES_BYTESWAP_IV;
266 CRYPTO_WRITE(dev, RK_CRYPTO_TDES_CTRL, rctx->mode);
267 memcpy_toio(dev->reg + RK_CRYPTO_TDES_KEY1_0, ctx->key, ctx->keylen);
268 conf_reg = RK_CRYPTO_DESSEL;
269 } else {
270 rctx->mode |= RK_CRYPTO_AES_FIFO_MODE |
271 RK_CRYPTO_AES_KEY_CHANGE |
272 RK_CRYPTO_AES_BYTESWAP_KEY |
273 RK_CRYPTO_AES_BYTESWAP_IV;
274 if (ctx->keylen == AES_KEYSIZE_192)
275 rctx->mode |= RK_CRYPTO_AES_192BIT_key;
276 else if (ctx->keylen == AES_KEYSIZE_256)
277 rctx->mode |= RK_CRYPTO_AES_256BIT_key;
278 CRYPTO_WRITE(dev, RK_CRYPTO_AES_CTRL, rctx->mode);
279 memcpy_toio(dev->reg + RK_CRYPTO_AES_KEY_0, ctx->key, ctx->keylen);
280 }
281 conf_reg |= RK_CRYPTO_BYTESWAP_BTFIFO |
282 RK_CRYPTO_BYTESWAP_BRFIFO;
283 CRYPTO_WRITE(dev, RK_CRYPTO_CONF, conf_reg);
284 CRYPTO_WRITE(dev, RK_CRYPTO_INTENA,
285 RK_CRYPTO_BCDMA_ERR_ENA | RK_CRYPTO_BCDMA_DONE_ENA);
286 }
287
crypto_dma_start(struct rk_crypto_info * dev,struct scatterlist * sgs,struct scatterlist * sgd,unsigned int todo)288 static void crypto_dma_start(struct rk_crypto_info *dev,
289 struct scatterlist *sgs,
290 struct scatterlist *sgd, unsigned int todo)
291 {
292 CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAS, sg_dma_address(sgs));
293 CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAL, todo);
294 CRYPTO_WRITE(dev, RK_CRYPTO_BTDMAS, sg_dma_address(sgd));
295 CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, RK_CRYPTO_BLOCK_START |
296 _SBF(RK_CRYPTO_BLOCK_START, 16));
297 }
298
rk_cipher_run(struct crypto_engine * engine,void * async_req)299 static int rk_cipher_run(struct crypto_engine *engine, void *async_req)
300 {
301 struct skcipher_request *areq = container_of(async_req, struct skcipher_request, base);
302 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
303 struct rk_cipher_rctx *rctx = skcipher_request_ctx(areq);
304 struct scatterlist *sgs, *sgd;
305 int err = 0;
306 int ivsize = crypto_skcipher_ivsize(tfm);
307 int offset;
308 u8 iv[AES_BLOCK_SIZE];
309 u8 biv[AES_BLOCK_SIZE];
310 u8 *ivtouse = areq->iv;
311 unsigned int len = areq->cryptlen;
312 unsigned int todo;
313 struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
314 struct rk_crypto_tmp *algt = container_of(alg, struct rk_crypto_tmp, alg.skcipher.base);
315 struct rk_crypto_info *rkc = rctx->dev;
316
317 err = pm_runtime_resume_and_get(rkc->dev);
318 if (err)
319 return err;
320
321 algt->stat_req++;
322 rkc->nreq++;
323
324 ivsize = crypto_skcipher_ivsize(tfm);
325 if (areq->iv && crypto_skcipher_ivsize(tfm) > 0) {
326 if (rctx->mode & RK_CRYPTO_DEC) {
327 offset = areq->cryptlen - ivsize;
328 scatterwalk_map_and_copy(rctx->backup_iv, areq->src,
329 offset, ivsize, 0);
330 }
331 }
332
333 sgs = areq->src;
334 sgd = areq->dst;
335
336 while (sgs && sgd && len) {
337 if (!sgs->length) {
338 sgs = sg_next(sgs);
339 sgd = sg_next(sgd);
340 continue;
341 }
342 if (rctx->mode & RK_CRYPTO_DEC) {
343 /* we backup last block of source to be used as IV at next step */
344 offset = sgs->length - ivsize;
345 scatterwalk_map_and_copy(biv, sgs, offset, ivsize, 0);
346 }
347 if (sgs == sgd) {
348 err = dma_map_sg(rkc->dev, sgs, 1, DMA_BIDIRECTIONAL);
349 if (err <= 0) {
350 err = -EINVAL;
351 goto theend_iv;
352 }
353 } else {
354 err = dma_map_sg(rkc->dev, sgs, 1, DMA_TO_DEVICE);
355 if (err <= 0) {
356 err = -EINVAL;
357 goto theend_iv;
358 }
359 err = dma_map_sg(rkc->dev, sgd, 1, DMA_FROM_DEVICE);
360 if (err <= 0) {
361 err = -EINVAL;
362 goto theend_sgs;
363 }
364 }
365 err = 0;
366 rk_cipher_hw_init(rkc, areq);
367 if (ivsize) {
368 if (ivsize == DES_BLOCK_SIZE)
369 memcpy_toio(rkc->reg + RK_CRYPTO_TDES_IV_0, ivtouse, ivsize);
370 else
371 memcpy_toio(rkc->reg + RK_CRYPTO_AES_IV_0, ivtouse, ivsize);
372 }
373 reinit_completion(&rkc->complete);
374 rkc->status = 0;
375
376 todo = min(sg_dma_len(sgs), len);
377 len -= todo;
378 crypto_dma_start(rkc, sgs, sgd, todo / 4);
379 wait_for_completion_interruptible_timeout(&rkc->complete,
380 msecs_to_jiffies(2000));
381 if (!rkc->status) {
382 dev_err(rkc->dev, "DMA timeout\n");
383 err = -EFAULT;
384 goto theend;
385 }
386 if (sgs == sgd) {
387 dma_unmap_sg(rkc->dev, sgs, 1, DMA_BIDIRECTIONAL);
388 } else {
389 dma_unmap_sg(rkc->dev, sgs, 1, DMA_TO_DEVICE);
390 dma_unmap_sg(rkc->dev, sgd, 1, DMA_FROM_DEVICE);
391 }
392 if (rctx->mode & RK_CRYPTO_DEC) {
393 memcpy(iv, biv, ivsize);
394 ivtouse = iv;
395 } else {
396 offset = sgd->length - ivsize;
397 scatterwalk_map_and_copy(iv, sgd, offset, ivsize, 0);
398 ivtouse = iv;
399 }
400 sgs = sg_next(sgs);
401 sgd = sg_next(sgd);
402 }
403
404 if (areq->iv && ivsize > 0) {
405 offset = areq->cryptlen - ivsize;
406 if (rctx->mode & RK_CRYPTO_DEC) {
407 memcpy(areq->iv, rctx->backup_iv, ivsize);
408 memzero_explicit(rctx->backup_iv, ivsize);
409 } else {
410 scatterwalk_map_and_copy(areq->iv, areq->dst, offset,
411 ivsize, 0);
412 }
413 }
414
415 theend:
416 pm_runtime_put_autosuspend(rkc->dev);
417
418 local_bh_disable();
419 crypto_finalize_skcipher_request(engine, areq, err);
420 local_bh_enable();
421 return 0;
422
423 theend_sgs:
424 if (sgs == sgd) {
425 dma_unmap_sg(rkc->dev, sgs, 1, DMA_BIDIRECTIONAL);
426 } else {
427 dma_unmap_sg(rkc->dev, sgs, 1, DMA_TO_DEVICE);
428 dma_unmap_sg(rkc->dev, sgd, 1, DMA_FROM_DEVICE);
429 }
430 theend_iv:
431 return err;
432 }
433
rk_cipher_tfm_init(struct crypto_skcipher * tfm)434 static int rk_cipher_tfm_init(struct crypto_skcipher *tfm)
435 {
436 struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
437 const char *name = crypto_tfm_alg_name(&tfm->base);
438 struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
439 struct rk_crypto_tmp *algt = container_of(alg, struct rk_crypto_tmp, alg.skcipher.base);
440
441 ctx->fallback_tfm = crypto_alloc_skcipher(name, 0, CRYPTO_ALG_NEED_FALLBACK);
442 if (IS_ERR(ctx->fallback_tfm)) {
443 dev_err(algt->dev->dev, "ERROR: Cannot allocate fallback for %s %ld\n",
444 name, PTR_ERR(ctx->fallback_tfm));
445 return PTR_ERR(ctx->fallback_tfm);
446 }
447
448 crypto_skcipher_set_reqsize(tfm, sizeof(struct rk_cipher_rctx) +
449 crypto_skcipher_reqsize(ctx->fallback_tfm));
450
451 return 0;
452 }
453
rk_cipher_tfm_exit(struct crypto_skcipher * tfm)454 static void rk_cipher_tfm_exit(struct crypto_skcipher *tfm)
455 {
456 struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
457
458 memzero_explicit(ctx->key, ctx->keylen);
459 crypto_free_skcipher(ctx->fallback_tfm);
460 }
461
462 struct rk_crypto_tmp rk_ecb_aes_alg = {
463 .type = CRYPTO_ALG_TYPE_SKCIPHER,
464 .alg.skcipher.base = {
465 .base.cra_name = "ecb(aes)",
466 .base.cra_driver_name = "ecb-aes-rk",
467 .base.cra_priority = 300,
468 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
469 .base.cra_blocksize = AES_BLOCK_SIZE,
470 .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
471 .base.cra_alignmask = 0x0f,
472 .base.cra_module = THIS_MODULE,
473
474 .init = rk_cipher_tfm_init,
475 .exit = rk_cipher_tfm_exit,
476 .min_keysize = AES_MIN_KEY_SIZE,
477 .max_keysize = AES_MAX_KEY_SIZE,
478 .setkey = rk_aes_setkey,
479 .encrypt = rk_aes_ecb_encrypt,
480 .decrypt = rk_aes_ecb_decrypt,
481 },
482 .alg.skcipher.op = {
483 .do_one_request = rk_cipher_run,
484 },
485 };
486
487 struct rk_crypto_tmp rk_cbc_aes_alg = {
488 .type = CRYPTO_ALG_TYPE_SKCIPHER,
489 .alg.skcipher.base = {
490 .base.cra_name = "cbc(aes)",
491 .base.cra_driver_name = "cbc-aes-rk",
492 .base.cra_priority = 300,
493 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
494 .base.cra_blocksize = AES_BLOCK_SIZE,
495 .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
496 .base.cra_alignmask = 0x0f,
497 .base.cra_module = THIS_MODULE,
498
499 .init = rk_cipher_tfm_init,
500 .exit = rk_cipher_tfm_exit,
501 .min_keysize = AES_MIN_KEY_SIZE,
502 .max_keysize = AES_MAX_KEY_SIZE,
503 .ivsize = AES_BLOCK_SIZE,
504 .setkey = rk_aes_setkey,
505 .encrypt = rk_aes_cbc_encrypt,
506 .decrypt = rk_aes_cbc_decrypt,
507 },
508 .alg.skcipher.op = {
509 .do_one_request = rk_cipher_run,
510 },
511 };
512
513 struct rk_crypto_tmp rk_ecb_des_alg = {
514 .type = CRYPTO_ALG_TYPE_SKCIPHER,
515 .alg.skcipher.base = {
516 .base.cra_name = "ecb(des)",
517 .base.cra_driver_name = "ecb-des-rk",
518 .base.cra_priority = 300,
519 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
520 .base.cra_blocksize = DES_BLOCK_SIZE,
521 .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
522 .base.cra_alignmask = 0x07,
523 .base.cra_module = THIS_MODULE,
524
525 .init = rk_cipher_tfm_init,
526 .exit = rk_cipher_tfm_exit,
527 .min_keysize = DES_KEY_SIZE,
528 .max_keysize = DES_KEY_SIZE,
529 .setkey = rk_des_setkey,
530 .encrypt = rk_des_ecb_encrypt,
531 .decrypt = rk_des_ecb_decrypt,
532 },
533 .alg.skcipher.op = {
534 .do_one_request = rk_cipher_run,
535 },
536 };
537
538 struct rk_crypto_tmp rk_cbc_des_alg = {
539 .type = CRYPTO_ALG_TYPE_SKCIPHER,
540 .alg.skcipher.base = {
541 .base.cra_name = "cbc(des)",
542 .base.cra_driver_name = "cbc-des-rk",
543 .base.cra_priority = 300,
544 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
545 .base.cra_blocksize = DES_BLOCK_SIZE,
546 .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
547 .base.cra_alignmask = 0x07,
548 .base.cra_module = THIS_MODULE,
549
550 .init = rk_cipher_tfm_init,
551 .exit = rk_cipher_tfm_exit,
552 .min_keysize = DES_KEY_SIZE,
553 .max_keysize = DES_KEY_SIZE,
554 .ivsize = DES_BLOCK_SIZE,
555 .setkey = rk_des_setkey,
556 .encrypt = rk_des_cbc_encrypt,
557 .decrypt = rk_des_cbc_decrypt,
558 },
559 .alg.skcipher.op = {
560 .do_one_request = rk_cipher_run,
561 },
562 };
563
564 struct rk_crypto_tmp rk_ecb_des3_ede_alg = {
565 .type = CRYPTO_ALG_TYPE_SKCIPHER,
566 .alg.skcipher.base = {
567 .base.cra_name = "ecb(des3_ede)",
568 .base.cra_driver_name = "ecb-des3-ede-rk",
569 .base.cra_priority = 300,
570 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
571 .base.cra_blocksize = DES_BLOCK_SIZE,
572 .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
573 .base.cra_alignmask = 0x07,
574 .base.cra_module = THIS_MODULE,
575
576 .init = rk_cipher_tfm_init,
577 .exit = rk_cipher_tfm_exit,
578 .min_keysize = DES3_EDE_KEY_SIZE,
579 .max_keysize = DES3_EDE_KEY_SIZE,
580 .setkey = rk_tdes_setkey,
581 .encrypt = rk_des3_ede_ecb_encrypt,
582 .decrypt = rk_des3_ede_ecb_decrypt,
583 },
584 .alg.skcipher.op = {
585 .do_one_request = rk_cipher_run,
586 },
587 };
588
589 struct rk_crypto_tmp rk_cbc_des3_ede_alg = {
590 .type = CRYPTO_ALG_TYPE_SKCIPHER,
591 .alg.skcipher.base = {
592 .base.cra_name = "cbc(des3_ede)",
593 .base.cra_driver_name = "cbc-des3-ede-rk",
594 .base.cra_priority = 300,
595 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
596 .base.cra_blocksize = DES_BLOCK_SIZE,
597 .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
598 .base.cra_alignmask = 0x07,
599 .base.cra_module = THIS_MODULE,
600
601 .init = rk_cipher_tfm_init,
602 .exit = rk_cipher_tfm_exit,
603 .min_keysize = DES3_EDE_KEY_SIZE,
604 .max_keysize = DES3_EDE_KEY_SIZE,
605 .ivsize = DES_BLOCK_SIZE,
606 .setkey = rk_tdes_setkey,
607 .encrypt = rk_des3_ede_cbc_encrypt,
608 .decrypt = rk_des3_ede_cbc_decrypt,
609 },
610 .alg.skcipher.op = {
611 .do_one_request = rk_cipher_run,
612 },
613 };
614