1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * sun4i-ss-cipher.c - hardware cryptographic accelerator for Allwinner A20 SoC
4  *
5  * Copyright (C) 2013-2015 Corentin LABBE <clabbe.montjoie@gmail.com>
6  *
7  * This file add support for AES cipher with 128,192,256 bits
8  * keysize in CBC and ECB mode.
9  * Add support also for DES and 3DES in CBC and ECB mode.
10  *
11  * You could find the datasheet in Documentation/arm/sunxi.rst
12  */
13 #include "sun4i-ss.h"
14 
15 static int noinline_for_stack sun4i_ss_opti_poll(struct skcipher_request *areq)
16 {
17 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
18 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
19 	struct sun4i_ss_ctx *ss = op->ss;
20 	unsigned int ivsize = crypto_skcipher_ivsize(tfm);
21 	struct sun4i_cipher_req_ctx *ctx = skcipher_request_ctx(areq);
22 	u32 mode = ctx->mode;
23 	/* when activating SS, the default FIFO space is SS_RX_DEFAULT(32) */
24 	u32 rx_cnt = SS_RX_DEFAULT;
25 	u32 tx_cnt = 0;
26 	u32 spaces;
27 	u32 v;
28 	int err = 0;
29 	unsigned int i;
30 	unsigned int ileft = areq->cryptlen;
31 	unsigned int oleft = areq->cryptlen;
32 	unsigned int todo;
33 	unsigned long pi = 0, po = 0; /* progress for in and out */
34 	bool miter_err;
35 	struct sg_mapping_iter mi, mo;
36 	unsigned int oi, oo; /* offset for in and out */
37 	unsigned long flags;
38 	struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
39 	struct sun4i_ss_alg_template *algt;
40 
41 	if (!areq->cryptlen)
42 		return 0;
43 
44 	if (!areq->src || !areq->dst) {
45 		dev_err_ratelimited(ss->dev, "ERROR: Some SGs are NULL\n");
46 		return -EINVAL;
47 	}
48 
49 	if (areq->iv && ivsize > 0 && mode & SS_DECRYPTION) {
50 		scatterwalk_map_and_copy(ctx->backup_iv, areq->src,
51 					 areq->cryptlen - ivsize, ivsize, 0);
52 	}
53 
54 	if (IS_ENABLED(CONFIG_CRYPTO_DEV_SUN4I_SS_DEBUG)) {
55 		algt = container_of(alg, struct sun4i_ss_alg_template, alg.crypto);
56 		algt->stat_opti++;
57 		algt->stat_bytes += areq->cryptlen;
58 	}
59 
60 	spin_lock_irqsave(&ss->slock, flags);
61 
62 	for (i = 0; i < op->keylen / 4; i++)
63 		writesl(ss->base + SS_KEY0 + i * 4, &op->key[i], 1);
64 
65 	if (areq->iv) {
66 		for (i = 0; i < 4 && i < ivsize / 4; i++) {
67 			v = *(u32 *)(areq->iv + i * 4);
68 			writesl(ss->base + SS_IV0 + i * 4, &v, 1);
69 		}
70 	}
71 	writel(mode, ss->base + SS_CTL);
72 
73 
74 	ileft = areq->cryptlen / 4;
75 	oleft = areq->cryptlen / 4;
76 	oi = 0;
77 	oo = 0;
78 	do {
79 		if (ileft) {
80 			sg_miter_start(&mi, areq->src, sg_nents(areq->src),
81 					SG_MITER_FROM_SG | SG_MITER_ATOMIC);
82 			if (pi)
83 				sg_miter_skip(&mi, pi);
84 			miter_err = sg_miter_next(&mi);
85 			if (!miter_err || !mi.addr) {
86 				dev_err_ratelimited(ss->dev, "ERROR: sg_miter return null\n");
87 				err = -EINVAL;
88 				goto release_ss;
89 			}
90 			todo = min(rx_cnt, ileft);
91 			todo = min_t(size_t, todo, (mi.length - oi) / 4);
92 			if (todo) {
93 				ileft -= todo;
94 				writesl(ss->base + SS_RXFIFO, mi.addr + oi, todo);
95 				oi += todo * 4;
96 			}
97 			if (oi == mi.length) {
98 				pi += mi.length;
99 				oi = 0;
100 			}
101 			sg_miter_stop(&mi);
102 		}
103 
104 		spaces = readl(ss->base + SS_FCSR);
105 		rx_cnt = SS_RXFIFO_SPACES(spaces);
106 		tx_cnt = SS_TXFIFO_SPACES(spaces);
107 
108 		sg_miter_start(&mo, areq->dst, sg_nents(areq->dst),
109 			       SG_MITER_TO_SG | SG_MITER_ATOMIC);
110 		if (po)
111 			sg_miter_skip(&mo, po);
112 		miter_err = sg_miter_next(&mo);
113 		if (!miter_err || !mo.addr) {
114 			dev_err_ratelimited(ss->dev, "ERROR: sg_miter return null\n");
115 			err = -EINVAL;
116 			goto release_ss;
117 		}
118 		todo = min(tx_cnt, oleft);
119 		todo = min_t(size_t, todo, (mo.length - oo) / 4);
120 		if (todo) {
121 			oleft -= todo;
122 			readsl(ss->base + SS_TXFIFO, mo.addr + oo, todo);
123 			oo += todo * 4;
124 		}
125 		if (oo == mo.length) {
126 			oo = 0;
127 			po += mo.length;
128 		}
129 		sg_miter_stop(&mo);
130 	} while (oleft);
131 
132 	if (areq->iv) {
133 		if (mode & SS_DECRYPTION) {
134 			memcpy(areq->iv, ctx->backup_iv, ivsize);
135 			memzero_explicit(ctx->backup_iv, ivsize);
136 		} else {
137 			scatterwalk_map_and_copy(areq->iv, areq->dst, areq->cryptlen - ivsize,
138 						 ivsize, 0);
139 		}
140 	}
141 
142 release_ss:
143 	writel(0, ss->base + SS_CTL);
144 	spin_unlock_irqrestore(&ss->slock, flags);
145 	return err;
146 }
147 
148 static int noinline_for_stack sun4i_ss_cipher_poll_fallback(struct skcipher_request *areq)
149 {
150 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
151 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
152 	struct sun4i_cipher_req_ctx *ctx = skcipher_request_ctx(areq);
153 	int err;
154 	struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
155 	struct sun4i_ss_alg_template *algt;
156 
157 	if (IS_ENABLED(CONFIG_CRYPTO_DEV_SUN4I_SS_DEBUG)) {
158 		algt = container_of(alg, struct sun4i_ss_alg_template, alg.crypto);
159 		algt->stat_fb++;
160 	}
161 
162 	skcipher_request_set_tfm(&ctx->fallback_req, op->fallback_tfm);
163 	skcipher_request_set_callback(&ctx->fallback_req, areq->base.flags,
164 				      areq->base.complete, areq->base.data);
165 	skcipher_request_set_crypt(&ctx->fallback_req, areq->src, areq->dst,
166 				   areq->cryptlen, areq->iv);
167 	if (ctx->mode & SS_DECRYPTION)
168 		err = crypto_skcipher_decrypt(&ctx->fallback_req);
169 	else
170 		err = crypto_skcipher_encrypt(&ctx->fallback_req);
171 
172 	return err;
173 }
174 
175 /* Generic function that support SG with size not multiple of 4 */
176 static int sun4i_ss_cipher_poll(struct skcipher_request *areq)
177 {
178 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
179 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
180 	struct sun4i_ss_ctx *ss = op->ss;
181 	int no_chunk = 1;
182 	struct scatterlist *in_sg = areq->src;
183 	struct scatterlist *out_sg = areq->dst;
184 	unsigned int ivsize = crypto_skcipher_ivsize(tfm);
185 	struct sun4i_cipher_req_ctx *ctx = skcipher_request_ctx(areq);
186 	struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
187 	struct sun4i_ss_alg_template *algt;
188 	u32 mode = ctx->mode;
189 	/* when activating SS, the default FIFO space is SS_RX_DEFAULT(32) */
190 	u32 rx_cnt = SS_RX_DEFAULT;
191 	u32 tx_cnt = 0;
192 	u32 v;
193 	u32 spaces;
194 	int err = 0;
195 	unsigned int i;
196 	unsigned int ileft = areq->cryptlen;
197 	unsigned int oleft = areq->cryptlen;
198 	unsigned int todo;
199 	struct sg_mapping_iter mi, mo;
200 	unsigned long pi = 0, po = 0; /* progress for in and out */
201 	bool miter_err;
202 	unsigned int oi, oo;	/* offset for in and out */
203 	unsigned int ob = 0;	/* offset in buf */
204 	unsigned int obo = 0;	/* offset in bufo*/
205 	unsigned int obl = 0;	/* length of data in bufo */
206 	unsigned long flags;
207 	bool need_fallback = false;
208 
209 	if (!areq->cryptlen)
210 		return 0;
211 
212 	if (!areq->src || !areq->dst) {
213 		dev_err_ratelimited(ss->dev, "ERROR: Some SGs are NULL\n");
214 		return -EINVAL;
215 	}
216 
217 	algt = container_of(alg, struct sun4i_ss_alg_template, alg.crypto);
218 	if (areq->cryptlen % algt->alg.crypto.base.cra_blocksize)
219 		need_fallback = true;
220 
221 	/*
222 	 * if we have only SGs with size multiple of 4,
223 	 * we can use the SS optimized function
224 	 */
225 	while (in_sg && no_chunk == 1) {
226 		if ((in_sg->length | in_sg->offset) & 3u)
227 			no_chunk = 0;
228 		in_sg = sg_next(in_sg);
229 	}
230 	while (out_sg && no_chunk == 1) {
231 		if ((out_sg->length | out_sg->offset) & 3u)
232 			no_chunk = 0;
233 		out_sg = sg_next(out_sg);
234 	}
235 
236 	if (no_chunk == 1 && !need_fallback)
237 		return sun4i_ss_opti_poll(areq);
238 
239 	if (need_fallback)
240 		return sun4i_ss_cipher_poll_fallback(areq);
241 
242 	if (areq->iv && ivsize > 0 && mode & SS_DECRYPTION) {
243 		scatterwalk_map_and_copy(ctx->backup_iv, areq->src,
244 					 areq->cryptlen - ivsize, ivsize, 0);
245 	}
246 
247 	if (IS_ENABLED(CONFIG_CRYPTO_DEV_SUN4I_SS_DEBUG)) {
248 		algt->stat_req++;
249 		algt->stat_bytes += areq->cryptlen;
250 	}
251 
252 	spin_lock_irqsave(&ss->slock, flags);
253 
254 	for (i = 0; i < op->keylen / 4; i++)
255 		writesl(ss->base + SS_KEY0 + i * 4, &op->key[i], 1);
256 
257 	if (areq->iv) {
258 		for (i = 0; i < 4 && i < ivsize / 4; i++) {
259 			v = *(u32 *)(areq->iv + i * 4);
260 			writesl(ss->base + SS_IV0 + i * 4, &v, 1);
261 		}
262 	}
263 	writel(mode, ss->base + SS_CTL);
264 
265 	ileft = areq->cryptlen;
266 	oleft = areq->cryptlen;
267 	oi = 0;
268 	oo = 0;
269 
270 	while (oleft) {
271 		if (ileft) {
272 			sg_miter_start(&mi, areq->src, sg_nents(areq->src),
273 				       SG_MITER_FROM_SG | SG_MITER_ATOMIC);
274 			if (pi)
275 				sg_miter_skip(&mi, pi);
276 			miter_err = sg_miter_next(&mi);
277 			if (!miter_err || !mi.addr) {
278 				dev_err_ratelimited(ss->dev, "ERROR: sg_miter return null\n");
279 				err = -EINVAL;
280 				goto release_ss;
281 			}
282 			/*
283 			 * todo is the number of consecutive 4byte word that we
284 			 * can read from current SG
285 			 */
286 			todo = min(rx_cnt, ileft / 4);
287 			todo = min_t(size_t, todo, (mi.length - oi) / 4);
288 			if (todo && !ob) {
289 				writesl(ss->base + SS_RXFIFO, mi.addr + oi,
290 					todo);
291 				ileft -= todo * 4;
292 				oi += todo * 4;
293 			} else {
294 				/*
295 				 * not enough consecutive bytes, so we need to
296 				 * linearize in buf. todo is in bytes
297 				 * After that copy, if we have a multiple of 4
298 				 * we need to be able to write all buf in one
299 				 * pass, so it is why we min() with rx_cnt
300 				 */
301 				todo = min(rx_cnt * 4 - ob, ileft);
302 				todo = min_t(size_t, todo, mi.length - oi);
303 				memcpy(ss->buf + ob, mi.addr + oi, todo);
304 				ileft -= todo;
305 				oi += todo;
306 				ob += todo;
307 				if (!(ob % 4)) {
308 					writesl(ss->base + SS_RXFIFO, ss->buf,
309 						ob / 4);
310 					ob = 0;
311 				}
312 			}
313 			if (oi == mi.length) {
314 				pi += mi.length;
315 				oi = 0;
316 			}
317 			sg_miter_stop(&mi);
318 		}
319 
320 		spaces = readl(ss->base + SS_FCSR);
321 		rx_cnt = SS_RXFIFO_SPACES(spaces);
322 		tx_cnt = SS_TXFIFO_SPACES(spaces);
323 
324 		if (!tx_cnt)
325 			continue;
326 		sg_miter_start(&mo, areq->dst, sg_nents(areq->dst),
327 			       SG_MITER_TO_SG | SG_MITER_ATOMIC);
328 		if (po)
329 			sg_miter_skip(&mo, po);
330 		miter_err = sg_miter_next(&mo);
331 		if (!miter_err || !mo.addr) {
332 			dev_err_ratelimited(ss->dev, "ERROR: sg_miter return null\n");
333 			err = -EINVAL;
334 			goto release_ss;
335 		}
336 		/* todo in 4bytes word */
337 		todo = min(tx_cnt, oleft / 4);
338 		todo = min_t(size_t, todo, (mo.length - oo) / 4);
339 
340 		if (todo) {
341 			readsl(ss->base + SS_TXFIFO, mo.addr + oo, todo);
342 			oleft -= todo * 4;
343 			oo += todo * 4;
344 			if (oo == mo.length) {
345 				po += mo.length;
346 				oo = 0;
347 			}
348 		} else {
349 			/*
350 			 * read obl bytes in bufo, we read at maximum for
351 			 * emptying the device
352 			 */
353 			readsl(ss->base + SS_TXFIFO, ss->bufo, tx_cnt);
354 			obl = tx_cnt * 4;
355 			obo = 0;
356 			do {
357 				/*
358 				 * how many bytes we can copy ?
359 				 * no more than remaining SG size
360 				 * no more than remaining buffer
361 				 * no need to test against oleft
362 				 */
363 				todo = min_t(size_t,
364 					     mo.length - oo, obl - obo);
365 				memcpy(mo.addr + oo, ss->bufo + obo, todo);
366 				oleft -= todo;
367 				obo += todo;
368 				oo += todo;
369 				if (oo == mo.length) {
370 					po += mo.length;
371 					sg_miter_next(&mo);
372 					oo = 0;
373 				}
374 			} while (obo < obl);
375 			/* bufo must be fully used here */
376 		}
377 		sg_miter_stop(&mo);
378 	}
379 	if (areq->iv) {
380 		if (mode & SS_DECRYPTION) {
381 			memcpy(areq->iv, ctx->backup_iv, ivsize);
382 			memzero_explicit(ctx->backup_iv, ivsize);
383 		} else {
384 			scatterwalk_map_and_copy(areq->iv, areq->dst, areq->cryptlen - ivsize,
385 						 ivsize, 0);
386 		}
387 	}
388 
389 release_ss:
390 	writel(0, ss->base + SS_CTL);
391 	spin_unlock_irqrestore(&ss->slock, flags);
392 
393 	return err;
394 }
395 
396 /* CBC AES */
397 int sun4i_ss_cbc_aes_encrypt(struct skcipher_request *areq)
398 {
399 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
400 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
401 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
402 
403 	rctx->mode = SS_OP_AES | SS_CBC | SS_ENABLED | SS_ENCRYPTION |
404 		op->keymode;
405 	return sun4i_ss_cipher_poll(areq);
406 }
407 
408 int sun4i_ss_cbc_aes_decrypt(struct skcipher_request *areq)
409 {
410 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
411 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
412 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
413 
414 	rctx->mode = SS_OP_AES | SS_CBC | SS_ENABLED | SS_DECRYPTION |
415 		op->keymode;
416 	return sun4i_ss_cipher_poll(areq);
417 }
418 
419 /* ECB AES */
420 int sun4i_ss_ecb_aes_encrypt(struct skcipher_request *areq)
421 {
422 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
423 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
424 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
425 
426 	rctx->mode = SS_OP_AES | SS_ECB | SS_ENABLED | SS_ENCRYPTION |
427 		op->keymode;
428 	return sun4i_ss_cipher_poll(areq);
429 }
430 
431 int sun4i_ss_ecb_aes_decrypt(struct skcipher_request *areq)
432 {
433 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
434 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
435 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
436 
437 	rctx->mode = SS_OP_AES | SS_ECB | SS_ENABLED | SS_DECRYPTION |
438 		op->keymode;
439 	return sun4i_ss_cipher_poll(areq);
440 }
441 
442 /* CBC DES */
443 int sun4i_ss_cbc_des_encrypt(struct skcipher_request *areq)
444 {
445 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
446 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
447 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
448 
449 	rctx->mode = SS_OP_DES | SS_CBC | SS_ENABLED | SS_ENCRYPTION |
450 		op->keymode;
451 	return sun4i_ss_cipher_poll(areq);
452 }
453 
454 int sun4i_ss_cbc_des_decrypt(struct skcipher_request *areq)
455 {
456 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
457 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
458 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
459 
460 	rctx->mode = SS_OP_DES | SS_CBC | SS_ENABLED | SS_DECRYPTION |
461 		op->keymode;
462 	return sun4i_ss_cipher_poll(areq);
463 }
464 
465 /* ECB DES */
466 int sun4i_ss_ecb_des_encrypt(struct skcipher_request *areq)
467 {
468 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
469 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
470 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
471 
472 	rctx->mode = SS_OP_DES | SS_ECB | SS_ENABLED | SS_ENCRYPTION |
473 		op->keymode;
474 	return sun4i_ss_cipher_poll(areq);
475 }
476 
477 int sun4i_ss_ecb_des_decrypt(struct skcipher_request *areq)
478 {
479 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
480 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
481 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
482 
483 	rctx->mode = SS_OP_DES | SS_ECB | SS_ENABLED | SS_DECRYPTION |
484 		op->keymode;
485 	return sun4i_ss_cipher_poll(areq);
486 }
487 
488 /* CBC 3DES */
489 int sun4i_ss_cbc_des3_encrypt(struct skcipher_request *areq)
490 {
491 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
492 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
493 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
494 
495 	rctx->mode = SS_OP_3DES | SS_CBC | SS_ENABLED | SS_ENCRYPTION |
496 		op->keymode;
497 	return sun4i_ss_cipher_poll(areq);
498 }
499 
500 int sun4i_ss_cbc_des3_decrypt(struct skcipher_request *areq)
501 {
502 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
503 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
504 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
505 
506 	rctx->mode = SS_OP_3DES | SS_CBC | SS_ENABLED | SS_DECRYPTION |
507 		op->keymode;
508 	return sun4i_ss_cipher_poll(areq);
509 }
510 
511 /* ECB 3DES */
512 int sun4i_ss_ecb_des3_encrypt(struct skcipher_request *areq)
513 {
514 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
515 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
516 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
517 
518 	rctx->mode = SS_OP_3DES | SS_ECB | SS_ENABLED | SS_ENCRYPTION |
519 		op->keymode;
520 	return sun4i_ss_cipher_poll(areq);
521 }
522 
523 int sun4i_ss_ecb_des3_decrypt(struct skcipher_request *areq)
524 {
525 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
526 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
527 	struct sun4i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
528 
529 	rctx->mode = SS_OP_3DES | SS_ECB | SS_ENABLED | SS_DECRYPTION |
530 		op->keymode;
531 	return sun4i_ss_cipher_poll(areq);
532 }
533 
534 int sun4i_ss_cipher_init(struct crypto_tfm *tfm)
535 {
536 	struct sun4i_tfm_ctx *op = crypto_tfm_ctx(tfm);
537 	struct sun4i_ss_alg_template *algt;
538 	const char *name = crypto_tfm_alg_name(tfm);
539 	int err;
540 
541 	memset(op, 0, sizeof(struct sun4i_tfm_ctx));
542 
543 	algt = container_of(tfm->__crt_alg, struct sun4i_ss_alg_template,
544 			    alg.crypto.base);
545 	op->ss = algt->ss;
546 
547 	op->fallback_tfm = crypto_alloc_skcipher(name, 0, CRYPTO_ALG_NEED_FALLBACK);
548 	if (IS_ERR(op->fallback_tfm)) {
549 		dev_err(op->ss->dev, "ERROR: Cannot allocate fallback for %s %ld\n",
550 			name, PTR_ERR(op->fallback_tfm));
551 		return PTR_ERR(op->fallback_tfm);
552 	}
553 
554 	crypto_skcipher_set_reqsize(__crypto_skcipher_cast(tfm),
555 				    sizeof(struct sun4i_cipher_req_ctx) +
556 				    crypto_skcipher_reqsize(op->fallback_tfm));
557 
558 	err = pm_runtime_resume_and_get(op->ss->dev);
559 	if (err < 0)
560 		goto error_pm;
561 
562 	return 0;
563 error_pm:
564 	crypto_free_skcipher(op->fallback_tfm);
565 	return err;
566 }
567 
568 void sun4i_ss_cipher_exit(struct crypto_tfm *tfm)
569 {
570 	struct sun4i_tfm_ctx *op = crypto_tfm_ctx(tfm);
571 
572 	crypto_free_skcipher(op->fallback_tfm);
573 	pm_runtime_put(op->ss->dev);
574 }
575 
576 /* check and set the AES key, prepare the mode to be used */
577 int sun4i_ss_aes_setkey(struct crypto_skcipher *tfm, const u8 *key,
578 			unsigned int keylen)
579 {
580 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
581 	struct sun4i_ss_ctx *ss = op->ss;
582 
583 	switch (keylen) {
584 	case 128 / 8:
585 		op->keymode = SS_AES_128BITS;
586 		break;
587 	case 192 / 8:
588 		op->keymode = SS_AES_192BITS;
589 		break;
590 	case 256 / 8:
591 		op->keymode = SS_AES_256BITS;
592 		break;
593 	default:
594 		dev_dbg(ss->dev, "ERROR: Invalid keylen %u\n", keylen);
595 		return -EINVAL;
596 	}
597 	op->keylen = keylen;
598 	memcpy(op->key, key, keylen);
599 
600 	crypto_skcipher_clear_flags(op->fallback_tfm, CRYPTO_TFM_REQ_MASK);
601 	crypto_skcipher_set_flags(op->fallback_tfm, tfm->base.crt_flags & CRYPTO_TFM_REQ_MASK);
602 
603 	return crypto_skcipher_setkey(op->fallback_tfm, key, keylen);
604 }
605 
606 /* check and set the DES key, prepare the mode to be used */
607 int sun4i_ss_des_setkey(struct crypto_skcipher *tfm, const u8 *key,
608 			unsigned int keylen)
609 {
610 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
611 	int err;
612 
613 	err = verify_skcipher_des_key(tfm, key);
614 	if (err)
615 		return err;
616 
617 	op->keylen = keylen;
618 	memcpy(op->key, key, keylen);
619 
620 	crypto_skcipher_clear_flags(op->fallback_tfm, CRYPTO_TFM_REQ_MASK);
621 	crypto_skcipher_set_flags(op->fallback_tfm, tfm->base.crt_flags & CRYPTO_TFM_REQ_MASK);
622 
623 	return crypto_skcipher_setkey(op->fallback_tfm, key, keylen);
624 }
625 
626 /* check and set the 3DES key, prepare the mode to be used */
627 int sun4i_ss_des3_setkey(struct crypto_skcipher *tfm, const u8 *key,
628 			 unsigned int keylen)
629 {
630 	struct sun4i_tfm_ctx *op = crypto_skcipher_ctx(tfm);
631 	int err;
632 
633 	err = verify_skcipher_des3_key(tfm, key);
634 	if (err)
635 		return err;
636 
637 	op->keylen = keylen;
638 	memcpy(op->key, key, keylen);
639 
640 	crypto_skcipher_clear_flags(op->fallback_tfm, CRYPTO_TFM_REQ_MASK);
641 	crypto_skcipher_set_flags(op->fallback_tfm, tfm->base.crt_flags & CRYPTO_TFM_REQ_MASK);
642 
643 	return crypto_skcipher_setkey(op->fallback_tfm, key, keylen);
644 }
645