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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 	tfm->reqsize = sizeof(struct rk_cipher_rctx) +
449 		crypto_skcipher_reqsize(ctx->fallback_tfm);
450 
451 	return 0;
452 }
453 
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