1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2019 HiSilicon Limited. */
3 
4 #include <crypto/aes.h>
5 #include <crypto/algapi.h>
6 #include <crypto/authenc.h>
7 #include <crypto/des.h>
8 #include <crypto/hash.h>
9 #include <crypto/internal/aead.h>
10 #include <crypto/internal/des.h>
11 #include <crypto/sha1.h>
12 #include <crypto/sha2.h>
13 #include <crypto/skcipher.h>
14 #include <crypto/xts.h>
15 #include <linux/crypto.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/idr.h>
18 
19 #include "sec.h"
20 #include "sec_crypto.h"
21 
22 #define SEC_PRIORITY		4001
23 #define SEC_XTS_MIN_KEY_SIZE	(2 * AES_MIN_KEY_SIZE)
24 #define SEC_XTS_MAX_KEY_SIZE	(2 * AES_MAX_KEY_SIZE)
25 #define SEC_DES3_2KEY_SIZE	(2 * DES_KEY_SIZE)
26 #define SEC_DES3_3KEY_SIZE	(3 * DES_KEY_SIZE)
27 
28 /* SEC sqe(bd) bit operational relative MACRO */
29 #define SEC_DE_OFFSET		1
30 #define SEC_CIPHER_OFFSET	4
31 #define SEC_SCENE_OFFSET	3
32 #define SEC_DST_SGL_OFFSET	2
33 #define SEC_SRC_SGL_OFFSET	7
34 #define SEC_CKEY_OFFSET		9
35 #define SEC_CMODE_OFFSET	12
36 #define SEC_AKEY_OFFSET         5
37 #define SEC_AEAD_ALG_OFFSET     11
38 #define SEC_AUTH_OFFSET		6
39 
40 #define SEC_FLAG_OFFSET		7
41 #define SEC_FLAG_MASK		0x0780
42 #define SEC_TYPE_MASK		0x0F
43 #define SEC_DONE_MASK		0x0001
44 
45 #define SEC_TOTAL_IV_SZ		(SEC_IV_SIZE * QM_Q_DEPTH)
46 #define SEC_SGL_SGE_NR		128
47 #define SEC_CIPHER_AUTH		0xfe
48 #define SEC_AUTH_CIPHER		0x1
49 #define SEC_MAX_MAC_LEN		64
50 #define SEC_MAX_AAD_LEN		65535
51 #define SEC_TOTAL_MAC_SZ	(SEC_MAX_MAC_LEN * QM_Q_DEPTH)
52 
53 #define SEC_PBUF_SZ			512
54 #define SEC_PBUF_IV_OFFSET		SEC_PBUF_SZ
55 #define SEC_PBUF_MAC_OFFSET		(SEC_PBUF_SZ + SEC_IV_SIZE)
56 #define SEC_PBUF_PKG		(SEC_PBUF_SZ + SEC_IV_SIZE +	\
57 			SEC_MAX_MAC_LEN * 2)
58 #define SEC_PBUF_NUM		(PAGE_SIZE / SEC_PBUF_PKG)
59 #define SEC_PBUF_PAGE_NUM	(QM_Q_DEPTH / SEC_PBUF_NUM)
60 #define SEC_PBUF_LEFT_SZ	(SEC_PBUF_PKG * (QM_Q_DEPTH -	\
61 			SEC_PBUF_PAGE_NUM * SEC_PBUF_NUM))
62 #define SEC_TOTAL_PBUF_SZ	(PAGE_SIZE * SEC_PBUF_PAGE_NUM +	\
63 			SEC_PBUF_LEFT_SZ)
64 
65 #define SEC_SQE_LEN_RATE	4
66 #define SEC_SQE_CFLAG		2
67 #define SEC_SQE_AEAD_FLAG	3
68 #define SEC_SQE_DONE		0x1
69 
70 /* Get an en/de-cipher queue cyclically to balance load over queues of TFM */
71 static inline int sec_alloc_queue_id(struct sec_ctx *ctx, struct sec_req *req)
72 {
73 	if (req->c_req.encrypt)
74 		return (u32)atomic_inc_return(&ctx->enc_qcyclic) %
75 				 ctx->hlf_q_num;
76 
77 	return (u32)atomic_inc_return(&ctx->dec_qcyclic) % ctx->hlf_q_num +
78 				 ctx->hlf_q_num;
79 }
80 
81 static inline void sec_free_queue_id(struct sec_ctx *ctx, struct sec_req *req)
82 {
83 	if (req->c_req.encrypt)
84 		atomic_dec(&ctx->enc_qcyclic);
85 	else
86 		atomic_dec(&ctx->dec_qcyclic);
87 }
88 
89 static int sec_alloc_req_id(struct sec_req *req, struct sec_qp_ctx *qp_ctx)
90 {
91 	int req_id;
92 
93 	mutex_lock(&qp_ctx->req_lock);
94 
95 	req_id = idr_alloc_cyclic(&qp_ctx->req_idr, NULL,
96 				  0, QM_Q_DEPTH, GFP_ATOMIC);
97 	mutex_unlock(&qp_ctx->req_lock);
98 	if (unlikely(req_id < 0)) {
99 		dev_err(req->ctx->dev, "alloc req id fail!\n");
100 		return req_id;
101 	}
102 
103 	req->qp_ctx = qp_ctx;
104 	qp_ctx->req_list[req_id] = req;
105 
106 	return req_id;
107 }
108 
109 static void sec_free_req_id(struct sec_req *req)
110 {
111 	struct sec_qp_ctx *qp_ctx = req->qp_ctx;
112 	int req_id = req->req_id;
113 
114 	if (unlikely(req_id < 0 || req_id >= QM_Q_DEPTH)) {
115 		dev_err(req->ctx->dev, "free request id invalid!\n");
116 		return;
117 	}
118 
119 	qp_ctx->req_list[req_id] = NULL;
120 	req->qp_ctx = NULL;
121 
122 	mutex_lock(&qp_ctx->req_lock);
123 	idr_remove(&qp_ctx->req_idr, req_id);
124 	mutex_unlock(&qp_ctx->req_lock);
125 }
126 
127 static int sec_aead_verify(struct sec_req *req)
128 {
129 	struct aead_request *aead_req = req->aead_req.aead_req;
130 	struct crypto_aead *tfm = crypto_aead_reqtfm(aead_req);
131 	size_t authsize = crypto_aead_authsize(tfm);
132 	u8 *mac_out = req->aead_req.out_mac;
133 	u8 *mac = mac_out + SEC_MAX_MAC_LEN;
134 	struct scatterlist *sgl = aead_req->src;
135 	size_t sz;
136 
137 	sz = sg_pcopy_to_buffer(sgl, sg_nents(sgl), mac, authsize,
138 				aead_req->cryptlen + aead_req->assoclen -
139 				authsize);
140 	if (unlikely(sz != authsize || memcmp(mac_out, mac, sz))) {
141 		dev_err(req->ctx->dev, "aead verify failure!\n");
142 		return -EBADMSG;
143 	}
144 
145 	return 0;
146 }
147 
148 static void sec_req_cb(struct hisi_qp *qp, void *resp)
149 {
150 	struct sec_qp_ctx *qp_ctx = qp->qp_ctx;
151 	struct sec_dfx *dfx = &qp_ctx->ctx->sec->debug.dfx;
152 	struct sec_sqe *bd = resp;
153 	struct sec_ctx *ctx;
154 	struct sec_req *req;
155 	u16 done, flag;
156 	int err = 0;
157 	u8 type;
158 
159 	type = bd->type_cipher_auth & SEC_TYPE_MASK;
160 	if (unlikely(type != SEC_BD_TYPE2)) {
161 		atomic64_inc(&dfx->err_bd_cnt);
162 		pr_err("err bd type [%d]\n", type);
163 		return;
164 	}
165 
166 	req = qp_ctx->req_list[le16_to_cpu(bd->type2.tag)];
167 	if (unlikely(!req)) {
168 		atomic64_inc(&dfx->invalid_req_cnt);
169 		atomic_inc(&qp->qp_status.used);
170 		return;
171 	}
172 	req->err_type = bd->type2.error_type;
173 	ctx = req->ctx;
174 	done = le16_to_cpu(bd->type2.done_flag) & SEC_DONE_MASK;
175 	flag = (le16_to_cpu(bd->type2.done_flag) &
176 		SEC_FLAG_MASK) >> SEC_FLAG_OFFSET;
177 	if (unlikely(req->err_type || done != SEC_SQE_DONE ||
178 	    (ctx->alg_type == SEC_SKCIPHER && flag != SEC_SQE_CFLAG) ||
179 	    (ctx->alg_type == SEC_AEAD && flag != SEC_SQE_AEAD_FLAG))) {
180 		dev_err_ratelimited(ctx->dev,
181 			"err_type[%d],done[%d],flag[%d]\n",
182 			req->err_type, done, flag);
183 		err = -EIO;
184 		atomic64_inc(&dfx->done_flag_cnt);
185 	}
186 
187 	if (ctx->alg_type == SEC_AEAD && !req->c_req.encrypt)
188 		err = sec_aead_verify(req);
189 
190 	atomic64_inc(&dfx->recv_cnt);
191 
192 	ctx->req_op->buf_unmap(ctx, req);
193 
194 	ctx->req_op->callback(ctx, req, err);
195 }
196 
197 static int sec_bd_send(struct sec_ctx *ctx, struct sec_req *req)
198 {
199 	struct sec_qp_ctx *qp_ctx = req->qp_ctx;
200 	int ret;
201 
202 	if (ctx->fake_req_limit <=
203 	    atomic_read(&qp_ctx->qp->qp_status.used) &&
204 	    !(req->flag & CRYPTO_TFM_REQ_MAY_BACKLOG))
205 		return -EBUSY;
206 
207 	mutex_lock(&qp_ctx->req_lock);
208 	ret = hisi_qp_send(qp_ctx->qp, &req->sec_sqe);
209 
210 	if (ctx->fake_req_limit <=
211 	    atomic_read(&qp_ctx->qp->qp_status.used) && !ret) {
212 		list_add_tail(&req->backlog_head, &qp_ctx->backlog);
213 		atomic64_inc(&ctx->sec->debug.dfx.send_cnt);
214 		atomic64_inc(&ctx->sec->debug.dfx.send_busy_cnt);
215 		mutex_unlock(&qp_ctx->req_lock);
216 		return -EBUSY;
217 	}
218 	mutex_unlock(&qp_ctx->req_lock);
219 
220 	if (unlikely(ret == -EBUSY))
221 		return -ENOBUFS;
222 
223 	if (likely(!ret)) {
224 		ret = -EINPROGRESS;
225 		atomic64_inc(&ctx->sec->debug.dfx.send_cnt);
226 	}
227 
228 	return ret;
229 }
230 
231 /* Get DMA memory resources */
232 static int sec_alloc_civ_resource(struct device *dev, struct sec_alg_res *res)
233 {
234 	int i;
235 
236 	res->c_ivin = dma_alloc_coherent(dev, SEC_TOTAL_IV_SZ,
237 					 &res->c_ivin_dma, GFP_KERNEL);
238 	if (!res->c_ivin)
239 		return -ENOMEM;
240 
241 	for (i = 1; i < QM_Q_DEPTH; i++) {
242 		res[i].c_ivin_dma = res->c_ivin_dma + i * SEC_IV_SIZE;
243 		res[i].c_ivin = res->c_ivin + i * SEC_IV_SIZE;
244 	}
245 
246 	return 0;
247 }
248 
249 static void sec_free_civ_resource(struct device *dev, struct sec_alg_res *res)
250 {
251 	if (res->c_ivin)
252 		dma_free_coherent(dev, SEC_TOTAL_IV_SZ,
253 				  res->c_ivin, res->c_ivin_dma);
254 }
255 
256 static int sec_alloc_mac_resource(struct device *dev, struct sec_alg_res *res)
257 {
258 	int i;
259 
260 	res->out_mac = dma_alloc_coherent(dev, SEC_TOTAL_MAC_SZ << 1,
261 					  &res->out_mac_dma, GFP_KERNEL);
262 	if (!res->out_mac)
263 		return -ENOMEM;
264 
265 	for (i = 1; i < QM_Q_DEPTH; i++) {
266 		res[i].out_mac_dma = res->out_mac_dma +
267 				     i * (SEC_MAX_MAC_LEN << 1);
268 		res[i].out_mac = res->out_mac + i * (SEC_MAX_MAC_LEN << 1);
269 	}
270 
271 	return 0;
272 }
273 
274 static void sec_free_mac_resource(struct device *dev, struct sec_alg_res *res)
275 {
276 	if (res->out_mac)
277 		dma_free_coherent(dev, SEC_TOTAL_MAC_SZ << 1,
278 				  res->out_mac, res->out_mac_dma);
279 }
280 
281 static void sec_free_pbuf_resource(struct device *dev, struct sec_alg_res *res)
282 {
283 	if (res->pbuf)
284 		dma_free_coherent(dev, SEC_TOTAL_PBUF_SZ,
285 				  res->pbuf, res->pbuf_dma);
286 }
287 
288 /*
289  * To improve performance, pbuffer is used for
290  * small packets (< 512Bytes) as IOMMU translation using.
291  */
292 static int sec_alloc_pbuf_resource(struct device *dev, struct sec_alg_res *res)
293 {
294 	int pbuf_page_offset;
295 	int i, j, k;
296 
297 	res->pbuf = dma_alloc_coherent(dev, SEC_TOTAL_PBUF_SZ,
298 				&res->pbuf_dma, GFP_KERNEL);
299 	if (!res->pbuf)
300 		return -ENOMEM;
301 
302 	/*
303 	 * SEC_PBUF_PKG contains data pbuf, iv and
304 	 * out_mac : <SEC_PBUF|SEC_IV|SEC_MAC>
305 	 * Every PAGE contains six SEC_PBUF_PKG
306 	 * The sec_qp_ctx contains QM_Q_DEPTH numbers of SEC_PBUF_PKG
307 	 * So we need SEC_PBUF_PAGE_NUM numbers of PAGE
308 	 * for the SEC_TOTAL_PBUF_SZ
309 	 */
310 	for (i = 0; i <= SEC_PBUF_PAGE_NUM; i++) {
311 		pbuf_page_offset = PAGE_SIZE * i;
312 		for (j = 0; j < SEC_PBUF_NUM; j++) {
313 			k = i * SEC_PBUF_NUM + j;
314 			if (k == QM_Q_DEPTH)
315 				break;
316 			res[k].pbuf = res->pbuf +
317 				j * SEC_PBUF_PKG + pbuf_page_offset;
318 			res[k].pbuf_dma = res->pbuf_dma +
319 				j * SEC_PBUF_PKG + pbuf_page_offset;
320 		}
321 	}
322 
323 	return 0;
324 }
325 
326 static int sec_alg_resource_alloc(struct sec_ctx *ctx,
327 				  struct sec_qp_ctx *qp_ctx)
328 {
329 	struct sec_alg_res *res = qp_ctx->res;
330 	struct device *dev = ctx->dev;
331 	int ret;
332 
333 	ret = sec_alloc_civ_resource(dev, res);
334 	if (ret)
335 		return ret;
336 
337 	if (ctx->alg_type == SEC_AEAD) {
338 		ret = sec_alloc_mac_resource(dev, res);
339 		if (ret)
340 			goto alloc_fail;
341 	}
342 	if (ctx->pbuf_supported) {
343 		ret = sec_alloc_pbuf_resource(dev, res);
344 		if (ret) {
345 			dev_err(dev, "fail to alloc pbuf dma resource!\n");
346 			goto alloc_pbuf_fail;
347 		}
348 	}
349 
350 	return 0;
351 
352 alloc_pbuf_fail:
353 	if (ctx->alg_type == SEC_AEAD)
354 		sec_free_mac_resource(dev, qp_ctx->res);
355 alloc_fail:
356 	sec_free_civ_resource(dev, res);
357 	return ret;
358 }
359 
360 static void sec_alg_resource_free(struct sec_ctx *ctx,
361 				  struct sec_qp_ctx *qp_ctx)
362 {
363 	struct device *dev = ctx->dev;
364 
365 	sec_free_civ_resource(dev, qp_ctx->res);
366 
367 	if (ctx->pbuf_supported)
368 		sec_free_pbuf_resource(dev, qp_ctx->res);
369 	if (ctx->alg_type == SEC_AEAD)
370 		sec_free_mac_resource(dev, qp_ctx->res);
371 }
372 
373 static int sec_create_qp_ctx(struct hisi_qm *qm, struct sec_ctx *ctx,
374 			     int qp_ctx_id, int alg_type)
375 {
376 	struct device *dev = ctx->dev;
377 	struct sec_qp_ctx *qp_ctx;
378 	struct hisi_qp *qp;
379 	int ret = -ENOMEM;
380 
381 	qp_ctx = &ctx->qp_ctx[qp_ctx_id];
382 	qp = ctx->qps[qp_ctx_id];
383 	qp->req_type = 0;
384 	qp->qp_ctx = qp_ctx;
385 	qp->req_cb = sec_req_cb;
386 	qp_ctx->qp = qp;
387 	qp_ctx->ctx = ctx;
388 
389 	mutex_init(&qp_ctx->req_lock);
390 	idr_init(&qp_ctx->req_idr);
391 	INIT_LIST_HEAD(&qp_ctx->backlog);
392 
393 	qp_ctx->c_in_pool = hisi_acc_create_sgl_pool(dev, QM_Q_DEPTH,
394 						     SEC_SGL_SGE_NR);
395 	if (IS_ERR(qp_ctx->c_in_pool)) {
396 		dev_err(dev, "fail to create sgl pool for input!\n");
397 		goto err_destroy_idr;
398 	}
399 
400 	qp_ctx->c_out_pool = hisi_acc_create_sgl_pool(dev, QM_Q_DEPTH,
401 						      SEC_SGL_SGE_NR);
402 	if (IS_ERR(qp_ctx->c_out_pool)) {
403 		dev_err(dev, "fail to create sgl pool for output!\n");
404 		goto err_free_c_in_pool;
405 	}
406 
407 	ret = sec_alg_resource_alloc(ctx, qp_ctx);
408 	if (ret)
409 		goto err_free_c_out_pool;
410 
411 	ret = hisi_qm_start_qp(qp, 0);
412 	if (ret < 0)
413 		goto err_queue_free;
414 
415 	return 0;
416 
417 err_queue_free:
418 	sec_alg_resource_free(ctx, qp_ctx);
419 err_free_c_out_pool:
420 	hisi_acc_free_sgl_pool(dev, qp_ctx->c_out_pool);
421 err_free_c_in_pool:
422 	hisi_acc_free_sgl_pool(dev, qp_ctx->c_in_pool);
423 err_destroy_idr:
424 	idr_destroy(&qp_ctx->req_idr);
425 	return ret;
426 }
427 
428 static void sec_release_qp_ctx(struct sec_ctx *ctx,
429 			       struct sec_qp_ctx *qp_ctx)
430 {
431 	struct device *dev = ctx->dev;
432 
433 	hisi_qm_stop_qp(qp_ctx->qp);
434 	sec_alg_resource_free(ctx, qp_ctx);
435 
436 	hisi_acc_free_sgl_pool(dev, qp_ctx->c_out_pool);
437 	hisi_acc_free_sgl_pool(dev, qp_ctx->c_in_pool);
438 
439 	idr_destroy(&qp_ctx->req_idr);
440 }
441 
442 static int sec_ctx_base_init(struct sec_ctx *ctx)
443 {
444 	struct sec_dev *sec;
445 	int i, ret;
446 
447 	ctx->qps = sec_create_qps();
448 	if (!ctx->qps) {
449 		pr_err("Can not create sec qps!\n");
450 		return -ENODEV;
451 	}
452 
453 	sec = container_of(ctx->qps[0]->qm, struct sec_dev, qm);
454 	ctx->sec = sec;
455 	ctx->dev = &sec->qm.pdev->dev;
456 	ctx->hlf_q_num = sec->ctx_q_num >> 1;
457 
458 	ctx->pbuf_supported = ctx->sec->iommu_used;
459 
460 	/* Half of queue depth is taken as fake requests limit in the queue. */
461 	ctx->fake_req_limit = QM_Q_DEPTH >> 1;
462 	ctx->qp_ctx = kcalloc(sec->ctx_q_num, sizeof(struct sec_qp_ctx),
463 			      GFP_KERNEL);
464 	if (!ctx->qp_ctx) {
465 		ret = -ENOMEM;
466 		goto err_destroy_qps;
467 	}
468 
469 	for (i = 0; i < sec->ctx_q_num; i++) {
470 		ret = sec_create_qp_ctx(&sec->qm, ctx, i, 0);
471 		if (ret)
472 			goto err_sec_release_qp_ctx;
473 	}
474 
475 	return 0;
476 
477 err_sec_release_qp_ctx:
478 	for (i = i - 1; i >= 0; i--)
479 		sec_release_qp_ctx(ctx, &ctx->qp_ctx[i]);
480 	kfree(ctx->qp_ctx);
481 err_destroy_qps:
482 	sec_destroy_qps(ctx->qps, sec->ctx_q_num);
483 	return ret;
484 }
485 
486 static void sec_ctx_base_uninit(struct sec_ctx *ctx)
487 {
488 	int i;
489 
490 	for (i = 0; i < ctx->sec->ctx_q_num; i++)
491 		sec_release_qp_ctx(ctx, &ctx->qp_ctx[i]);
492 
493 	sec_destroy_qps(ctx->qps, ctx->sec->ctx_q_num);
494 	kfree(ctx->qp_ctx);
495 }
496 
497 static int sec_cipher_init(struct sec_ctx *ctx)
498 {
499 	struct sec_cipher_ctx *c_ctx = &ctx->c_ctx;
500 
501 	c_ctx->c_key = dma_alloc_coherent(ctx->dev, SEC_MAX_KEY_SIZE,
502 					  &c_ctx->c_key_dma, GFP_KERNEL);
503 	if (!c_ctx->c_key)
504 		return -ENOMEM;
505 
506 	return 0;
507 }
508 
509 static void sec_cipher_uninit(struct sec_ctx *ctx)
510 {
511 	struct sec_cipher_ctx *c_ctx = &ctx->c_ctx;
512 
513 	memzero_explicit(c_ctx->c_key, SEC_MAX_KEY_SIZE);
514 	dma_free_coherent(ctx->dev, SEC_MAX_KEY_SIZE,
515 			  c_ctx->c_key, c_ctx->c_key_dma);
516 }
517 
518 static int sec_auth_init(struct sec_ctx *ctx)
519 {
520 	struct sec_auth_ctx *a_ctx = &ctx->a_ctx;
521 
522 	a_ctx->a_key = dma_alloc_coherent(ctx->dev, SEC_MAX_KEY_SIZE,
523 					  &a_ctx->a_key_dma, GFP_KERNEL);
524 	if (!a_ctx->a_key)
525 		return -ENOMEM;
526 
527 	return 0;
528 }
529 
530 static void sec_auth_uninit(struct sec_ctx *ctx)
531 {
532 	struct sec_auth_ctx *a_ctx = &ctx->a_ctx;
533 
534 	memzero_explicit(a_ctx->a_key, SEC_MAX_KEY_SIZE);
535 	dma_free_coherent(ctx->dev, SEC_MAX_KEY_SIZE,
536 			  a_ctx->a_key, a_ctx->a_key_dma);
537 }
538 
539 static int sec_skcipher_init(struct crypto_skcipher *tfm)
540 {
541 	struct sec_ctx *ctx = crypto_skcipher_ctx(tfm);
542 	int ret;
543 
544 	ctx->alg_type = SEC_SKCIPHER;
545 	crypto_skcipher_set_reqsize(tfm, sizeof(struct sec_req));
546 	ctx->c_ctx.ivsize = crypto_skcipher_ivsize(tfm);
547 	if (ctx->c_ctx.ivsize > SEC_IV_SIZE) {
548 		pr_err("get error skcipher iv size!\n");
549 		return -EINVAL;
550 	}
551 
552 	ret = sec_ctx_base_init(ctx);
553 	if (ret)
554 		return ret;
555 
556 	ret = sec_cipher_init(ctx);
557 	if (ret)
558 		goto err_cipher_init;
559 
560 	return 0;
561 
562 err_cipher_init:
563 	sec_ctx_base_uninit(ctx);
564 	return ret;
565 }
566 
567 static void sec_skcipher_uninit(struct crypto_skcipher *tfm)
568 {
569 	struct sec_ctx *ctx = crypto_skcipher_ctx(tfm);
570 
571 	sec_cipher_uninit(ctx);
572 	sec_ctx_base_uninit(ctx);
573 }
574 
575 static int sec_skcipher_3des_setkey(struct crypto_skcipher *tfm, const u8 *key,
576 				    const u32 keylen,
577 				    const enum sec_cmode c_mode)
578 {
579 	struct sec_ctx *ctx = crypto_skcipher_ctx(tfm);
580 	struct sec_cipher_ctx *c_ctx = &ctx->c_ctx;
581 	int ret;
582 
583 	ret = verify_skcipher_des3_key(tfm, key);
584 	if (ret)
585 		return ret;
586 
587 	switch (keylen) {
588 	case SEC_DES3_2KEY_SIZE:
589 		c_ctx->c_key_len = SEC_CKEY_3DES_2KEY;
590 		break;
591 	case SEC_DES3_3KEY_SIZE:
592 		c_ctx->c_key_len = SEC_CKEY_3DES_3KEY;
593 		break;
594 	default:
595 		return -EINVAL;
596 	}
597 
598 	return 0;
599 }
600 
601 static int sec_skcipher_aes_sm4_setkey(struct sec_cipher_ctx *c_ctx,
602 				       const u32 keylen,
603 				       const enum sec_cmode c_mode)
604 {
605 	if (c_mode == SEC_CMODE_XTS) {
606 		switch (keylen) {
607 		case SEC_XTS_MIN_KEY_SIZE:
608 			c_ctx->c_key_len = SEC_CKEY_128BIT;
609 			break;
610 		case SEC_XTS_MAX_KEY_SIZE:
611 			c_ctx->c_key_len = SEC_CKEY_256BIT;
612 			break;
613 		default:
614 			pr_err("hisi_sec2: xts mode key error!\n");
615 			return -EINVAL;
616 		}
617 	} else {
618 		switch (keylen) {
619 		case AES_KEYSIZE_128:
620 			c_ctx->c_key_len = SEC_CKEY_128BIT;
621 			break;
622 		case AES_KEYSIZE_192:
623 			c_ctx->c_key_len = SEC_CKEY_192BIT;
624 			break;
625 		case AES_KEYSIZE_256:
626 			c_ctx->c_key_len = SEC_CKEY_256BIT;
627 			break;
628 		default:
629 			pr_err("hisi_sec2: aes key error!\n");
630 			return -EINVAL;
631 		}
632 	}
633 
634 	return 0;
635 }
636 
637 static int sec_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key,
638 			       const u32 keylen, const enum sec_calg c_alg,
639 			       const enum sec_cmode c_mode)
640 {
641 	struct sec_ctx *ctx = crypto_skcipher_ctx(tfm);
642 	struct sec_cipher_ctx *c_ctx = &ctx->c_ctx;
643 	struct device *dev = ctx->dev;
644 	int ret;
645 
646 	if (c_mode == SEC_CMODE_XTS) {
647 		ret = xts_verify_key(tfm, key, keylen);
648 		if (ret) {
649 			dev_err(dev, "xts mode key err!\n");
650 			return ret;
651 		}
652 	}
653 
654 	c_ctx->c_alg  = c_alg;
655 	c_ctx->c_mode = c_mode;
656 
657 	switch (c_alg) {
658 	case SEC_CALG_3DES:
659 		ret = sec_skcipher_3des_setkey(tfm, key, keylen, c_mode);
660 		break;
661 	case SEC_CALG_AES:
662 	case SEC_CALG_SM4:
663 		ret = sec_skcipher_aes_sm4_setkey(c_ctx, keylen, c_mode);
664 		break;
665 	default:
666 		return -EINVAL;
667 	}
668 
669 	if (ret) {
670 		dev_err(dev, "set sec key err!\n");
671 		return ret;
672 	}
673 
674 	memcpy(c_ctx->c_key, key, keylen);
675 
676 	return 0;
677 }
678 
679 #define GEN_SEC_SETKEY_FUNC(name, c_alg, c_mode)			\
680 static int sec_setkey_##name(struct crypto_skcipher *tfm, const u8 *key,\
681 	u32 keylen)							\
682 {									\
683 	return sec_skcipher_setkey(tfm, key, keylen, c_alg, c_mode);	\
684 }
685 
686 GEN_SEC_SETKEY_FUNC(aes_ecb, SEC_CALG_AES, SEC_CMODE_ECB)
687 GEN_SEC_SETKEY_FUNC(aes_cbc, SEC_CALG_AES, SEC_CMODE_CBC)
688 GEN_SEC_SETKEY_FUNC(aes_xts, SEC_CALG_AES, SEC_CMODE_XTS)
689 
690 GEN_SEC_SETKEY_FUNC(3des_ecb, SEC_CALG_3DES, SEC_CMODE_ECB)
691 GEN_SEC_SETKEY_FUNC(3des_cbc, SEC_CALG_3DES, SEC_CMODE_CBC)
692 
693 GEN_SEC_SETKEY_FUNC(sm4_xts, SEC_CALG_SM4, SEC_CMODE_XTS)
694 GEN_SEC_SETKEY_FUNC(sm4_cbc, SEC_CALG_SM4, SEC_CMODE_CBC)
695 
696 static int sec_cipher_pbuf_map(struct sec_ctx *ctx, struct sec_req *req,
697 			struct scatterlist *src)
698 {
699 	struct aead_request *aead_req = req->aead_req.aead_req;
700 	struct sec_cipher_req *c_req = &req->c_req;
701 	struct sec_qp_ctx *qp_ctx = req->qp_ctx;
702 	struct device *dev = ctx->dev;
703 	int copy_size, pbuf_length;
704 	int req_id = req->req_id;
705 
706 	if (ctx->alg_type == SEC_AEAD)
707 		copy_size = aead_req->cryptlen + aead_req->assoclen;
708 	else
709 		copy_size = c_req->c_len;
710 
711 	pbuf_length = sg_copy_to_buffer(src, sg_nents(src),
712 							qp_ctx->res[req_id].pbuf,
713 							copy_size);
714 	if (unlikely(pbuf_length != copy_size)) {
715 		dev_err(dev, "copy src data to pbuf error!\n");
716 		return -EINVAL;
717 	}
718 
719 	c_req->c_in_dma = qp_ctx->res[req_id].pbuf_dma;
720 	c_req->c_out_dma = c_req->c_in_dma;
721 
722 	return 0;
723 }
724 
725 static void sec_cipher_pbuf_unmap(struct sec_ctx *ctx, struct sec_req *req,
726 			struct scatterlist *dst)
727 {
728 	struct aead_request *aead_req = req->aead_req.aead_req;
729 	struct sec_cipher_req *c_req = &req->c_req;
730 	struct sec_qp_ctx *qp_ctx = req->qp_ctx;
731 	struct device *dev = ctx->dev;
732 	int copy_size, pbuf_length;
733 	int req_id = req->req_id;
734 
735 	if (ctx->alg_type == SEC_AEAD)
736 		copy_size = c_req->c_len + aead_req->assoclen;
737 	else
738 		copy_size = c_req->c_len;
739 
740 	pbuf_length = sg_copy_from_buffer(dst, sg_nents(dst),
741 				qp_ctx->res[req_id].pbuf,
742 				copy_size);
743 	if (unlikely(pbuf_length != copy_size))
744 		dev_err(dev, "copy pbuf data to dst error!\n");
745 }
746 
747 static int sec_cipher_map(struct sec_ctx *ctx, struct sec_req *req,
748 			  struct scatterlist *src, struct scatterlist *dst)
749 {
750 	struct sec_cipher_req *c_req = &req->c_req;
751 	struct sec_aead_req *a_req = &req->aead_req;
752 	struct sec_qp_ctx *qp_ctx = req->qp_ctx;
753 	struct sec_alg_res *res = &qp_ctx->res[req->req_id];
754 	struct device *dev = ctx->dev;
755 	int ret;
756 
757 	if (req->use_pbuf) {
758 		ret = sec_cipher_pbuf_map(ctx, req, src);
759 		c_req->c_ivin = res->pbuf + SEC_PBUF_IV_OFFSET;
760 		c_req->c_ivin_dma = res->pbuf_dma + SEC_PBUF_IV_OFFSET;
761 		if (ctx->alg_type == SEC_AEAD) {
762 			a_req->out_mac = res->pbuf + SEC_PBUF_MAC_OFFSET;
763 			a_req->out_mac_dma = res->pbuf_dma +
764 					SEC_PBUF_MAC_OFFSET;
765 		}
766 
767 		return ret;
768 	}
769 	c_req->c_ivin = res->c_ivin;
770 	c_req->c_ivin_dma = res->c_ivin_dma;
771 	if (ctx->alg_type == SEC_AEAD) {
772 		a_req->out_mac = res->out_mac;
773 		a_req->out_mac_dma = res->out_mac_dma;
774 	}
775 
776 	c_req->c_in = hisi_acc_sg_buf_map_to_hw_sgl(dev, src,
777 						    qp_ctx->c_in_pool,
778 						    req->req_id,
779 						    &c_req->c_in_dma);
780 
781 	if (IS_ERR(c_req->c_in)) {
782 		dev_err(dev, "fail to dma map input sgl buffers!\n");
783 		return PTR_ERR(c_req->c_in);
784 	}
785 
786 	if (dst == src) {
787 		c_req->c_out = c_req->c_in;
788 		c_req->c_out_dma = c_req->c_in_dma;
789 	} else {
790 		c_req->c_out = hisi_acc_sg_buf_map_to_hw_sgl(dev, dst,
791 							     qp_ctx->c_out_pool,
792 							     req->req_id,
793 							     &c_req->c_out_dma);
794 
795 		if (IS_ERR(c_req->c_out)) {
796 			dev_err(dev, "fail to dma map output sgl buffers!\n");
797 			hisi_acc_sg_buf_unmap(dev, src, c_req->c_in);
798 			return PTR_ERR(c_req->c_out);
799 		}
800 	}
801 
802 	return 0;
803 }
804 
805 static void sec_cipher_unmap(struct sec_ctx *ctx, struct sec_req *req,
806 			     struct scatterlist *src, struct scatterlist *dst)
807 {
808 	struct sec_cipher_req *c_req = &req->c_req;
809 	struct device *dev = ctx->dev;
810 
811 	if (req->use_pbuf) {
812 		sec_cipher_pbuf_unmap(ctx, req, dst);
813 	} else {
814 		if (dst != src)
815 			hisi_acc_sg_buf_unmap(dev, src, c_req->c_in);
816 
817 		hisi_acc_sg_buf_unmap(dev, dst, c_req->c_out);
818 	}
819 }
820 
821 static int sec_skcipher_sgl_map(struct sec_ctx *ctx, struct sec_req *req)
822 {
823 	struct skcipher_request *sq = req->c_req.sk_req;
824 
825 	return sec_cipher_map(ctx, req, sq->src, sq->dst);
826 }
827 
828 static void sec_skcipher_sgl_unmap(struct sec_ctx *ctx, struct sec_req *req)
829 {
830 	struct skcipher_request *sq = req->c_req.sk_req;
831 
832 	sec_cipher_unmap(ctx, req, sq->src, sq->dst);
833 }
834 
835 static int sec_aead_aes_set_key(struct sec_cipher_ctx *c_ctx,
836 				struct crypto_authenc_keys *keys)
837 {
838 	switch (keys->enckeylen) {
839 	case AES_KEYSIZE_128:
840 		c_ctx->c_key_len = SEC_CKEY_128BIT;
841 		break;
842 	case AES_KEYSIZE_192:
843 		c_ctx->c_key_len = SEC_CKEY_192BIT;
844 		break;
845 	case AES_KEYSIZE_256:
846 		c_ctx->c_key_len = SEC_CKEY_256BIT;
847 		break;
848 	default:
849 		pr_err("hisi_sec2: aead aes key error!\n");
850 		return -EINVAL;
851 	}
852 	memcpy(c_ctx->c_key, keys->enckey, keys->enckeylen);
853 
854 	return 0;
855 }
856 
857 static int sec_aead_auth_set_key(struct sec_auth_ctx *ctx,
858 				 struct crypto_authenc_keys *keys)
859 {
860 	struct crypto_shash *hash_tfm = ctx->hash_tfm;
861 	int blocksize, digestsize, ret;
862 
863 	if (!keys->authkeylen) {
864 		pr_err("hisi_sec2: aead auth key error!\n");
865 		return -EINVAL;
866 	}
867 
868 	blocksize = crypto_shash_blocksize(hash_tfm);
869 	digestsize = crypto_shash_digestsize(hash_tfm);
870 	if (keys->authkeylen > blocksize) {
871 		ret = crypto_shash_tfm_digest(hash_tfm, keys->authkey,
872 					      keys->authkeylen, ctx->a_key);
873 		if (ret) {
874 			pr_err("hisi_sec2: aead auth digest error!\n");
875 			return -EINVAL;
876 		}
877 		ctx->a_key_len = digestsize;
878 	} else {
879 		memcpy(ctx->a_key, keys->authkey, keys->authkeylen);
880 		ctx->a_key_len = keys->authkeylen;
881 	}
882 
883 	return 0;
884 }
885 
886 static int sec_aead_setkey(struct crypto_aead *tfm, const u8 *key,
887 			   const u32 keylen, const enum sec_hash_alg a_alg,
888 			   const enum sec_calg c_alg,
889 			   const enum sec_mac_len mac_len,
890 			   const enum sec_cmode c_mode)
891 {
892 	struct sec_ctx *ctx = crypto_aead_ctx(tfm);
893 	struct sec_cipher_ctx *c_ctx = &ctx->c_ctx;
894 	struct device *dev = ctx->dev;
895 	struct crypto_authenc_keys keys;
896 	int ret;
897 
898 	ctx->a_ctx.a_alg = a_alg;
899 	ctx->c_ctx.c_alg = c_alg;
900 	ctx->a_ctx.mac_len = mac_len;
901 	c_ctx->c_mode = c_mode;
902 
903 	if (crypto_authenc_extractkeys(&keys, key, keylen))
904 		goto bad_key;
905 
906 	ret = sec_aead_aes_set_key(c_ctx, &keys);
907 	if (ret) {
908 		dev_err(dev, "set sec cipher key err!\n");
909 		goto bad_key;
910 	}
911 
912 	ret = sec_aead_auth_set_key(&ctx->a_ctx, &keys);
913 	if (ret) {
914 		dev_err(dev, "set sec auth key err!\n");
915 		goto bad_key;
916 	}
917 
918 	return 0;
919 
920 bad_key:
921 	memzero_explicit(&keys, sizeof(struct crypto_authenc_keys));
922 	return -EINVAL;
923 }
924 
925 
926 #define GEN_SEC_AEAD_SETKEY_FUNC(name, aalg, calg, maclen, cmode)	\
927 static int sec_setkey_##name(struct crypto_aead *tfm, const u8 *key,	\
928 	u32 keylen)							\
929 {									\
930 	return sec_aead_setkey(tfm, key, keylen, aalg, calg, maclen, cmode);\
931 }
932 
933 GEN_SEC_AEAD_SETKEY_FUNC(aes_cbc_sha1, SEC_A_HMAC_SHA1,
934 			 SEC_CALG_AES, SEC_HMAC_SHA1_MAC, SEC_CMODE_CBC)
935 GEN_SEC_AEAD_SETKEY_FUNC(aes_cbc_sha256, SEC_A_HMAC_SHA256,
936 			 SEC_CALG_AES, SEC_HMAC_SHA256_MAC, SEC_CMODE_CBC)
937 GEN_SEC_AEAD_SETKEY_FUNC(aes_cbc_sha512, SEC_A_HMAC_SHA512,
938 			 SEC_CALG_AES, SEC_HMAC_SHA512_MAC, SEC_CMODE_CBC)
939 
940 static int sec_aead_sgl_map(struct sec_ctx *ctx, struct sec_req *req)
941 {
942 	struct aead_request *aq = req->aead_req.aead_req;
943 
944 	return sec_cipher_map(ctx, req, aq->src, aq->dst);
945 }
946 
947 static void sec_aead_sgl_unmap(struct sec_ctx *ctx, struct sec_req *req)
948 {
949 	struct aead_request *aq = req->aead_req.aead_req;
950 
951 	sec_cipher_unmap(ctx, req, aq->src, aq->dst);
952 }
953 
954 static int sec_request_transfer(struct sec_ctx *ctx, struct sec_req *req)
955 {
956 	int ret;
957 
958 	ret = ctx->req_op->buf_map(ctx, req);
959 	if (unlikely(ret))
960 		return ret;
961 
962 	ctx->req_op->do_transfer(ctx, req);
963 
964 	ret = ctx->req_op->bd_fill(ctx, req);
965 	if (unlikely(ret))
966 		goto unmap_req_buf;
967 
968 	return ret;
969 
970 unmap_req_buf:
971 	ctx->req_op->buf_unmap(ctx, req);
972 	return ret;
973 }
974 
975 static void sec_request_untransfer(struct sec_ctx *ctx, struct sec_req *req)
976 {
977 	ctx->req_op->buf_unmap(ctx, req);
978 }
979 
980 static void sec_skcipher_copy_iv(struct sec_ctx *ctx, struct sec_req *req)
981 {
982 	struct skcipher_request *sk_req = req->c_req.sk_req;
983 	struct sec_cipher_req *c_req = &req->c_req;
984 
985 	memcpy(c_req->c_ivin, sk_req->iv, ctx->c_ctx.ivsize);
986 }
987 
988 static int sec_skcipher_bd_fill(struct sec_ctx *ctx, struct sec_req *req)
989 {
990 	struct sec_cipher_ctx *c_ctx = &ctx->c_ctx;
991 	struct sec_cipher_req *c_req = &req->c_req;
992 	struct sec_sqe *sec_sqe = &req->sec_sqe;
993 	u8 scene, sa_type, da_type;
994 	u8 bd_type, cipher;
995 	u8 de = 0;
996 
997 	memset(sec_sqe, 0, sizeof(struct sec_sqe));
998 
999 	sec_sqe->type2.c_key_addr = cpu_to_le64(c_ctx->c_key_dma);
1000 	sec_sqe->type2.c_ivin_addr = cpu_to_le64(c_req->c_ivin_dma);
1001 	sec_sqe->type2.data_src_addr = cpu_to_le64(c_req->c_in_dma);
1002 	sec_sqe->type2.data_dst_addr = cpu_to_le64(c_req->c_out_dma);
1003 
1004 	sec_sqe->type2.icvw_kmode |= cpu_to_le16(((u16)c_ctx->c_mode) <<
1005 						SEC_CMODE_OFFSET);
1006 	sec_sqe->type2.c_alg = c_ctx->c_alg;
1007 	sec_sqe->type2.icvw_kmode |= cpu_to_le16(((u16)c_ctx->c_key_len) <<
1008 						SEC_CKEY_OFFSET);
1009 
1010 	bd_type = SEC_BD_TYPE2;
1011 	if (c_req->encrypt)
1012 		cipher = SEC_CIPHER_ENC << SEC_CIPHER_OFFSET;
1013 	else
1014 		cipher = SEC_CIPHER_DEC << SEC_CIPHER_OFFSET;
1015 	sec_sqe->type_cipher_auth = bd_type | cipher;
1016 
1017 	if (req->use_pbuf)
1018 		sa_type = SEC_PBUF << SEC_SRC_SGL_OFFSET;
1019 	else
1020 		sa_type = SEC_SGL << SEC_SRC_SGL_OFFSET;
1021 	scene = SEC_COMM_SCENE << SEC_SCENE_OFFSET;
1022 	if (c_req->c_in_dma != c_req->c_out_dma)
1023 		de = 0x1 << SEC_DE_OFFSET;
1024 
1025 	sec_sqe->sds_sa_type = (de | scene | sa_type);
1026 
1027 	/* Just set DST address type */
1028 	if (req->use_pbuf)
1029 		da_type = SEC_PBUF << SEC_DST_SGL_OFFSET;
1030 	else
1031 		da_type = SEC_SGL << SEC_DST_SGL_OFFSET;
1032 	sec_sqe->sdm_addr_type |= da_type;
1033 
1034 	sec_sqe->type2.clen_ivhlen |= cpu_to_le32(c_req->c_len);
1035 	sec_sqe->type2.tag = cpu_to_le16((u16)req->req_id);
1036 
1037 	return 0;
1038 }
1039 
1040 static void sec_update_iv(struct sec_req *req, enum sec_alg_type alg_type)
1041 {
1042 	struct aead_request *aead_req = req->aead_req.aead_req;
1043 	struct skcipher_request *sk_req = req->c_req.sk_req;
1044 	u32 iv_size = req->ctx->c_ctx.ivsize;
1045 	struct scatterlist *sgl;
1046 	unsigned int cryptlen;
1047 	size_t sz;
1048 	u8 *iv;
1049 
1050 	if (req->c_req.encrypt)
1051 		sgl = alg_type == SEC_SKCIPHER ? sk_req->dst : aead_req->dst;
1052 	else
1053 		sgl = alg_type == SEC_SKCIPHER ? sk_req->src : aead_req->src;
1054 
1055 	if (alg_type == SEC_SKCIPHER) {
1056 		iv = sk_req->iv;
1057 		cryptlen = sk_req->cryptlen;
1058 	} else {
1059 		iv = aead_req->iv;
1060 		cryptlen = aead_req->cryptlen;
1061 	}
1062 
1063 	sz = sg_pcopy_to_buffer(sgl, sg_nents(sgl), iv, iv_size,
1064 				cryptlen - iv_size);
1065 	if (unlikely(sz != iv_size))
1066 		dev_err(req->ctx->dev, "copy output iv error!\n");
1067 }
1068 
1069 static struct sec_req *sec_back_req_clear(struct sec_ctx *ctx,
1070 				struct sec_qp_ctx *qp_ctx)
1071 {
1072 	struct sec_req *backlog_req = NULL;
1073 
1074 	mutex_lock(&qp_ctx->req_lock);
1075 	if (ctx->fake_req_limit >=
1076 	    atomic_read(&qp_ctx->qp->qp_status.used) &&
1077 	    !list_empty(&qp_ctx->backlog)) {
1078 		backlog_req = list_first_entry(&qp_ctx->backlog,
1079 				typeof(*backlog_req), backlog_head);
1080 		list_del(&backlog_req->backlog_head);
1081 	}
1082 	mutex_unlock(&qp_ctx->req_lock);
1083 
1084 	return backlog_req;
1085 }
1086 
1087 static void sec_skcipher_callback(struct sec_ctx *ctx, struct sec_req *req,
1088 				  int err)
1089 {
1090 	struct skcipher_request *sk_req = req->c_req.sk_req;
1091 	struct sec_qp_ctx *qp_ctx = req->qp_ctx;
1092 	struct skcipher_request *backlog_sk_req;
1093 	struct sec_req *backlog_req;
1094 
1095 	sec_free_req_id(req);
1096 
1097 	/* IV output at encrypto of CBC mode */
1098 	if (!err && ctx->c_ctx.c_mode == SEC_CMODE_CBC && req->c_req.encrypt)
1099 		sec_update_iv(req, SEC_SKCIPHER);
1100 
1101 	while (1) {
1102 		backlog_req = sec_back_req_clear(ctx, qp_ctx);
1103 		if (!backlog_req)
1104 			break;
1105 
1106 		backlog_sk_req = backlog_req->c_req.sk_req;
1107 		backlog_sk_req->base.complete(&backlog_sk_req->base,
1108 						-EINPROGRESS);
1109 		atomic64_inc(&ctx->sec->debug.dfx.recv_busy_cnt);
1110 	}
1111 
1112 	sk_req->base.complete(&sk_req->base, err);
1113 }
1114 
1115 static void sec_aead_copy_iv(struct sec_ctx *ctx, struct sec_req *req)
1116 {
1117 	struct aead_request *aead_req = req->aead_req.aead_req;
1118 	struct sec_cipher_req *c_req = &req->c_req;
1119 
1120 	memcpy(c_req->c_ivin, aead_req->iv, ctx->c_ctx.ivsize);
1121 }
1122 
1123 static void sec_auth_bd_fill_ex(struct sec_auth_ctx *ctx, int dir,
1124 			       struct sec_req *req, struct sec_sqe *sec_sqe)
1125 {
1126 	struct sec_aead_req *a_req = &req->aead_req;
1127 	struct sec_cipher_req *c_req = &req->c_req;
1128 	struct aead_request *aq = a_req->aead_req;
1129 
1130 	sec_sqe->type2.a_key_addr = cpu_to_le64(ctx->a_key_dma);
1131 
1132 	sec_sqe->type2.mac_key_alg =
1133 			cpu_to_le32(ctx->mac_len / SEC_SQE_LEN_RATE);
1134 
1135 	sec_sqe->type2.mac_key_alg |=
1136 			cpu_to_le32((u32)((ctx->a_key_len) /
1137 			SEC_SQE_LEN_RATE) << SEC_AKEY_OFFSET);
1138 
1139 	sec_sqe->type2.mac_key_alg |=
1140 			cpu_to_le32((u32)(ctx->a_alg) << SEC_AEAD_ALG_OFFSET);
1141 
1142 	sec_sqe->type_cipher_auth |= SEC_AUTH_TYPE1 << SEC_AUTH_OFFSET;
1143 
1144 	if (dir)
1145 		sec_sqe->sds_sa_type &= SEC_CIPHER_AUTH;
1146 	else
1147 		sec_sqe->sds_sa_type |= SEC_AUTH_CIPHER;
1148 
1149 	sec_sqe->type2.alen_ivllen = cpu_to_le32(c_req->c_len + aq->assoclen);
1150 
1151 	sec_sqe->type2.cipher_src_offset = cpu_to_le16((u16)aq->assoclen);
1152 
1153 	sec_sqe->type2.mac_addr = cpu_to_le64(a_req->out_mac_dma);
1154 }
1155 
1156 static int sec_aead_bd_fill(struct sec_ctx *ctx, struct sec_req *req)
1157 {
1158 	struct sec_auth_ctx *auth_ctx = &ctx->a_ctx;
1159 	struct sec_sqe *sec_sqe = &req->sec_sqe;
1160 	int ret;
1161 
1162 	ret = sec_skcipher_bd_fill(ctx, req);
1163 	if (unlikely(ret)) {
1164 		dev_err(ctx->dev, "skcipher bd fill is error!\n");
1165 		return ret;
1166 	}
1167 
1168 	sec_auth_bd_fill_ex(auth_ctx, req->c_req.encrypt, req, sec_sqe);
1169 
1170 	return 0;
1171 }
1172 
1173 static void sec_aead_callback(struct sec_ctx *c, struct sec_req *req, int err)
1174 {
1175 	struct aead_request *a_req = req->aead_req.aead_req;
1176 	struct crypto_aead *tfm = crypto_aead_reqtfm(a_req);
1177 	struct sec_aead_req *aead_req = &req->aead_req;
1178 	struct sec_cipher_req *c_req = &req->c_req;
1179 	size_t authsize = crypto_aead_authsize(tfm);
1180 	struct sec_qp_ctx *qp_ctx = req->qp_ctx;
1181 	struct aead_request *backlog_aead_req;
1182 	struct sec_req *backlog_req;
1183 	size_t sz;
1184 
1185 	if (!err && c->c_ctx.c_mode == SEC_CMODE_CBC && c_req->encrypt)
1186 		sec_update_iv(req, SEC_AEAD);
1187 
1188 	/* Copy output mac */
1189 	if (!err && c_req->encrypt) {
1190 		struct scatterlist *sgl = a_req->dst;
1191 
1192 		sz = sg_pcopy_from_buffer(sgl, sg_nents(sgl),
1193 					  aead_req->out_mac,
1194 					  authsize, a_req->cryptlen +
1195 					  a_req->assoclen);
1196 
1197 		if (unlikely(sz != authsize)) {
1198 			dev_err(c->dev, "copy out mac err!\n");
1199 			err = -EINVAL;
1200 		}
1201 	}
1202 
1203 	sec_free_req_id(req);
1204 
1205 	while (1) {
1206 		backlog_req = sec_back_req_clear(c, qp_ctx);
1207 		if (!backlog_req)
1208 			break;
1209 
1210 		backlog_aead_req = backlog_req->aead_req.aead_req;
1211 		backlog_aead_req->base.complete(&backlog_aead_req->base,
1212 						-EINPROGRESS);
1213 		atomic64_inc(&c->sec->debug.dfx.recv_busy_cnt);
1214 	}
1215 
1216 	a_req->base.complete(&a_req->base, err);
1217 }
1218 
1219 static void sec_request_uninit(struct sec_ctx *ctx, struct sec_req *req)
1220 {
1221 	sec_free_req_id(req);
1222 	sec_free_queue_id(ctx, req);
1223 }
1224 
1225 static int sec_request_init(struct sec_ctx *ctx, struct sec_req *req)
1226 {
1227 	struct sec_qp_ctx *qp_ctx;
1228 	int queue_id;
1229 
1230 	/* To load balance */
1231 	queue_id = sec_alloc_queue_id(ctx, req);
1232 	qp_ctx = &ctx->qp_ctx[queue_id];
1233 
1234 	req->req_id = sec_alloc_req_id(req, qp_ctx);
1235 	if (unlikely(req->req_id < 0)) {
1236 		sec_free_queue_id(ctx, req);
1237 		return req->req_id;
1238 	}
1239 
1240 	return 0;
1241 }
1242 
1243 static int sec_process(struct sec_ctx *ctx, struct sec_req *req)
1244 {
1245 	struct sec_cipher_req *c_req = &req->c_req;
1246 	int ret;
1247 
1248 	ret = sec_request_init(ctx, req);
1249 	if (unlikely(ret))
1250 		return ret;
1251 
1252 	ret = sec_request_transfer(ctx, req);
1253 	if (unlikely(ret))
1254 		goto err_uninit_req;
1255 
1256 	/* Output IV as decrypto */
1257 	if (ctx->c_ctx.c_mode == SEC_CMODE_CBC && !req->c_req.encrypt)
1258 		sec_update_iv(req, ctx->alg_type);
1259 
1260 	ret = ctx->req_op->bd_send(ctx, req);
1261 	if (unlikely((ret != -EBUSY && ret != -EINPROGRESS) ||
1262 		(ret == -EBUSY && !(req->flag & CRYPTO_TFM_REQ_MAY_BACKLOG)))) {
1263 		dev_err_ratelimited(ctx->dev, "send sec request failed!\n");
1264 		goto err_send_req;
1265 	}
1266 
1267 	return ret;
1268 
1269 err_send_req:
1270 	/* As failing, restore the IV from user */
1271 	if (ctx->c_ctx.c_mode == SEC_CMODE_CBC && !req->c_req.encrypt) {
1272 		if (ctx->alg_type == SEC_SKCIPHER)
1273 			memcpy(req->c_req.sk_req->iv, c_req->c_ivin,
1274 			       ctx->c_ctx.ivsize);
1275 		else
1276 			memcpy(req->aead_req.aead_req->iv, c_req->c_ivin,
1277 			       ctx->c_ctx.ivsize);
1278 	}
1279 
1280 	sec_request_untransfer(ctx, req);
1281 err_uninit_req:
1282 	sec_request_uninit(ctx, req);
1283 	return ret;
1284 }
1285 
1286 static const struct sec_req_op sec_skcipher_req_ops = {
1287 	.buf_map	= sec_skcipher_sgl_map,
1288 	.buf_unmap	= sec_skcipher_sgl_unmap,
1289 	.do_transfer	= sec_skcipher_copy_iv,
1290 	.bd_fill	= sec_skcipher_bd_fill,
1291 	.bd_send	= sec_bd_send,
1292 	.callback	= sec_skcipher_callback,
1293 	.process	= sec_process,
1294 };
1295 
1296 static const struct sec_req_op sec_aead_req_ops = {
1297 	.buf_map	= sec_aead_sgl_map,
1298 	.buf_unmap	= sec_aead_sgl_unmap,
1299 	.do_transfer	= sec_aead_copy_iv,
1300 	.bd_fill	= sec_aead_bd_fill,
1301 	.bd_send	= sec_bd_send,
1302 	.callback	= sec_aead_callback,
1303 	.process	= sec_process,
1304 };
1305 
1306 static int sec_skcipher_ctx_init(struct crypto_skcipher *tfm)
1307 {
1308 	struct sec_ctx *ctx = crypto_skcipher_ctx(tfm);
1309 
1310 	ctx->req_op = &sec_skcipher_req_ops;
1311 
1312 	return sec_skcipher_init(tfm);
1313 }
1314 
1315 static void sec_skcipher_ctx_exit(struct crypto_skcipher *tfm)
1316 {
1317 	sec_skcipher_uninit(tfm);
1318 }
1319 
1320 static int sec_aead_init(struct crypto_aead *tfm)
1321 {
1322 	struct sec_ctx *ctx = crypto_aead_ctx(tfm);
1323 	int ret;
1324 
1325 	crypto_aead_set_reqsize(tfm, sizeof(struct sec_req));
1326 	ctx->alg_type = SEC_AEAD;
1327 	ctx->c_ctx.ivsize = crypto_aead_ivsize(tfm);
1328 	if (ctx->c_ctx.ivsize > SEC_IV_SIZE) {
1329 		dev_err(ctx->dev, "get error aead iv size!\n");
1330 		return -EINVAL;
1331 	}
1332 
1333 	ctx->req_op = &sec_aead_req_ops;
1334 	ret = sec_ctx_base_init(ctx);
1335 	if (ret)
1336 		return ret;
1337 
1338 	ret = sec_auth_init(ctx);
1339 	if (ret)
1340 		goto err_auth_init;
1341 
1342 	ret = sec_cipher_init(ctx);
1343 	if (ret)
1344 		goto err_cipher_init;
1345 
1346 	return ret;
1347 
1348 err_cipher_init:
1349 	sec_auth_uninit(ctx);
1350 err_auth_init:
1351 	sec_ctx_base_uninit(ctx);
1352 	return ret;
1353 }
1354 
1355 static void sec_aead_exit(struct crypto_aead *tfm)
1356 {
1357 	struct sec_ctx *ctx = crypto_aead_ctx(tfm);
1358 
1359 	sec_cipher_uninit(ctx);
1360 	sec_auth_uninit(ctx);
1361 	sec_ctx_base_uninit(ctx);
1362 }
1363 
1364 static int sec_aead_ctx_init(struct crypto_aead *tfm, const char *hash_name)
1365 {
1366 	struct sec_ctx *ctx = crypto_aead_ctx(tfm);
1367 	struct sec_auth_ctx *auth_ctx = &ctx->a_ctx;
1368 	int ret;
1369 
1370 	ret = sec_aead_init(tfm);
1371 	if (ret) {
1372 		pr_err("hisi_sec2: aead init error!\n");
1373 		return ret;
1374 	}
1375 
1376 	auth_ctx->hash_tfm = crypto_alloc_shash(hash_name, 0, 0);
1377 	if (IS_ERR(auth_ctx->hash_tfm)) {
1378 		dev_err(ctx->dev, "aead alloc shash error!\n");
1379 		sec_aead_exit(tfm);
1380 		return PTR_ERR(auth_ctx->hash_tfm);
1381 	}
1382 
1383 	return 0;
1384 }
1385 
1386 static void sec_aead_ctx_exit(struct crypto_aead *tfm)
1387 {
1388 	struct sec_ctx *ctx = crypto_aead_ctx(tfm);
1389 
1390 	crypto_free_shash(ctx->a_ctx.hash_tfm);
1391 	sec_aead_exit(tfm);
1392 }
1393 
1394 static int sec_aead_sha1_ctx_init(struct crypto_aead *tfm)
1395 {
1396 	return sec_aead_ctx_init(tfm, "sha1");
1397 }
1398 
1399 static int sec_aead_sha256_ctx_init(struct crypto_aead *tfm)
1400 {
1401 	return sec_aead_ctx_init(tfm, "sha256");
1402 }
1403 
1404 static int sec_aead_sha512_ctx_init(struct crypto_aead *tfm)
1405 {
1406 	return sec_aead_ctx_init(tfm, "sha512");
1407 }
1408 
1409 
1410 static int sec_skcipher_cryptlen_ckeck(struct sec_ctx *ctx,
1411 	struct sec_req *sreq)
1412 {
1413 	u32 cryptlen = sreq->c_req.sk_req->cryptlen;
1414 	struct device *dev = ctx->dev;
1415 	u8 c_mode = ctx->c_ctx.c_mode;
1416 	int ret = 0;
1417 
1418 	switch (c_mode) {
1419 	case SEC_CMODE_XTS:
1420 		if (unlikely(cryptlen < AES_BLOCK_SIZE)) {
1421 			dev_err(dev, "skcipher XTS mode input length error!\n");
1422 			ret = -EINVAL;
1423 		}
1424 		break;
1425 	case SEC_CMODE_ECB:
1426 	case SEC_CMODE_CBC:
1427 		if (unlikely(cryptlen & (AES_BLOCK_SIZE - 1))) {
1428 			dev_err(dev, "skcipher AES input length error!\n");
1429 			ret = -EINVAL;
1430 		}
1431 		break;
1432 	default:
1433 		ret = -EINVAL;
1434 	}
1435 
1436 	return ret;
1437 }
1438 
1439 static int sec_skcipher_param_check(struct sec_ctx *ctx, struct sec_req *sreq)
1440 {
1441 	struct skcipher_request *sk_req = sreq->c_req.sk_req;
1442 	struct device *dev = ctx->dev;
1443 	u8 c_alg = ctx->c_ctx.c_alg;
1444 
1445 	if (unlikely(!sk_req->src || !sk_req->dst)) {
1446 		dev_err(dev, "skcipher input param error!\n");
1447 		return -EINVAL;
1448 	}
1449 	sreq->c_req.c_len = sk_req->cryptlen;
1450 
1451 	if (ctx->pbuf_supported && sk_req->cryptlen <= SEC_PBUF_SZ)
1452 		sreq->use_pbuf = true;
1453 	else
1454 		sreq->use_pbuf = false;
1455 
1456 	if (c_alg == SEC_CALG_3DES) {
1457 		if (unlikely(sk_req->cryptlen & (DES3_EDE_BLOCK_SIZE - 1))) {
1458 			dev_err(dev, "skcipher 3des input length error!\n");
1459 			return -EINVAL;
1460 		}
1461 		return 0;
1462 	} else if (c_alg == SEC_CALG_AES || c_alg == SEC_CALG_SM4) {
1463 		return sec_skcipher_cryptlen_ckeck(ctx, sreq);
1464 	}
1465 
1466 	dev_err(dev, "skcipher algorithm error!\n");
1467 
1468 	return -EINVAL;
1469 }
1470 
1471 static int sec_skcipher_crypto(struct skcipher_request *sk_req, bool encrypt)
1472 {
1473 	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(sk_req);
1474 	struct sec_req *req = skcipher_request_ctx(sk_req);
1475 	struct sec_ctx *ctx = crypto_skcipher_ctx(tfm);
1476 	int ret;
1477 
1478 	if (!sk_req->cryptlen)
1479 		return 0;
1480 
1481 	req->flag = sk_req->base.flags;
1482 	req->c_req.sk_req = sk_req;
1483 	req->c_req.encrypt = encrypt;
1484 	req->ctx = ctx;
1485 
1486 	ret = sec_skcipher_param_check(ctx, req);
1487 	if (unlikely(ret))
1488 		return -EINVAL;
1489 
1490 	return ctx->req_op->process(ctx, req);
1491 }
1492 
1493 static int sec_skcipher_encrypt(struct skcipher_request *sk_req)
1494 {
1495 	return sec_skcipher_crypto(sk_req, true);
1496 }
1497 
1498 static int sec_skcipher_decrypt(struct skcipher_request *sk_req)
1499 {
1500 	return sec_skcipher_crypto(sk_req, false);
1501 }
1502 
1503 #define SEC_SKCIPHER_GEN_ALG(sec_cra_name, sec_set_key, sec_min_key_size, \
1504 	sec_max_key_size, ctx_init, ctx_exit, blk_size, iv_size)\
1505 {\
1506 	.base = {\
1507 		.cra_name = sec_cra_name,\
1508 		.cra_driver_name = "hisi_sec_"sec_cra_name,\
1509 		.cra_priority = SEC_PRIORITY,\
1510 		.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY,\
1511 		.cra_blocksize = blk_size,\
1512 		.cra_ctxsize = sizeof(struct sec_ctx),\
1513 		.cra_module = THIS_MODULE,\
1514 	},\
1515 	.init = ctx_init,\
1516 	.exit = ctx_exit,\
1517 	.setkey = sec_set_key,\
1518 	.decrypt = sec_skcipher_decrypt,\
1519 	.encrypt = sec_skcipher_encrypt,\
1520 	.min_keysize = sec_min_key_size,\
1521 	.max_keysize = sec_max_key_size,\
1522 	.ivsize = iv_size,\
1523 },
1524 
1525 #define SEC_SKCIPHER_ALG(name, key_func, min_key_size, \
1526 	max_key_size, blk_size, iv_size) \
1527 	SEC_SKCIPHER_GEN_ALG(name, key_func, min_key_size, max_key_size, \
1528 	sec_skcipher_ctx_init, sec_skcipher_ctx_exit, blk_size, iv_size)
1529 
1530 static struct skcipher_alg sec_skciphers[] = {
1531 	SEC_SKCIPHER_ALG("ecb(aes)", sec_setkey_aes_ecb,
1532 			 AES_MIN_KEY_SIZE, AES_MAX_KEY_SIZE,
1533 			 AES_BLOCK_SIZE, 0)
1534 
1535 	SEC_SKCIPHER_ALG("cbc(aes)", sec_setkey_aes_cbc,
1536 			 AES_MIN_KEY_SIZE, AES_MAX_KEY_SIZE,
1537 			 AES_BLOCK_SIZE, AES_BLOCK_SIZE)
1538 
1539 	SEC_SKCIPHER_ALG("xts(aes)", sec_setkey_aes_xts,
1540 			 SEC_XTS_MIN_KEY_SIZE, SEC_XTS_MAX_KEY_SIZE,
1541 			 AES_BLOCK_SIZE, AES_BLOCK_SIZE)
1542 
1543 	SEC_SKCIPHER_ALG("ecb(des3_ede)", sec_setkey_3des_ecb,
1544 			 SEC_DES3_2KEY_SIZE, SEC_DES3_3KEY_SIZE,
1545 			 DES3_EDE_BLOCK_SIZE, 0)
1546 
1547 	SEC_SKCIPHER_ALG("cbc(des3_ede)", sec_setkey_3des_cbc,
1548 			 SEC_DES3_2KEY_SIZE, SEC_DES3_3KEY_SIZE,
1549 			 DES3_EDE_BLOCK_SIZE, DES3_EDE_BLOCK_SIZE)
1550 
1551 	SEC_SKCIPHER_ALG("xts(sm4)", sec_setkey_sm4_xts,
1552 			 SEC_XTS_MIN_KEY_SIZE, SEC_XTS_MIN_KEY_SIZE,
1553 			 AES_BLOCK_SIZE, AES_BLOCK_SIZE)
1554 
1555 	SEC_SKCIPHER_ALG("cbc(sm4)", sec_setkey_sm4_cbc,
1556 			 AES_MIN_KEY_SIZE, AES_MIN_KEY_SIZE,
1557 			 AES_BLOCK_SIZE, AES_BLOCK_SIZE)
1558 };
1559 
1560 static int sec_aead_param_check(struct sec_ctx *ctx, struct sec_req *sreq)
1561 {
1562 	struct aead_request *req = sreq->aead_req.aead_req;
1563 	struct crypto_aead *tfm = crypto_aead_reqtfm(req);
1564 	size_t authsize = crypto_aead_authsize(tfm);
1565 	struct device *dev = ctx->dev;
1566 	u8 c_alg = ctx->c_ctx.c_alg;
1567 
1568 	if (unlikely(!req->src || !req->dst || !req->cryptlen ||
1569 		req->assoclen > SEC_MAX_AAD_LEN)) {
1570 		dev_err(dev, "aead input param error!\n");
1571 		return -EINVAL;
1572 	}
1573 
1574 	if (ctx->pbuf_supported && (req->cryptlen + req->assoclen) <=
1575 		SEC_PBUF_SZ)
1576 		sreq->use_pbuf = true;
1577 	else
1578 		sreq->use_pbuf = false;
1579 
1580 	/* Support AES only */
1581 	if (unlikely(c_alg != SEC_CALG_AES)) {
1582 		dev_err(dev, "aead crypto alg error!\n");
1583 		return -EINVAL;
1584 	}
1585 	if (sreq->c_req.encrypt)
1586 		sreq->c_req.c_len = req->cryptlen;
1587 	else
1588 		sreq->c_req.c_len = req->cryptlen - authsize;
1589 
1590 	if (unlikely(sreq->c_req.c_len & (AES_BLOCK_SIZE - 1))) {
1591 		dev_err(dev, "aead crypto length error!\n");
1592 		return -EINVAL;
1593 	}
1594 
1595 	return 0;
1596 }
1597 
1598 static int sec_aead_crypto(struct aead_request *a_req, bool encrypt)
1599 {
1600 	struct crypto_aead *tfm = crypto_aead_reqtfm(a_req);
1601 	struct sec_req *req = aead_request_ctx(a_req);
1602 	struct sec_ctx *ctx = crypto_aead_ctx(tfm);
1603 	int ret;
1604 
1605 	req->flag = a_req->base.flags;
1606 	req->aead_req.aead_req = a_req;
1607 	req->c_req.encrypt = encrypt;
1608 	req->ctx = ctx;
1609 
1610 	ret = sec_aead_param_check(ctx, req);
1611 	if (unlikely(ret))
1612 		return -EINVAL;
1613 
1614 	return ctx->req_op->process(ctx, req);
1615 }
1616 
1617 static int sec_aead_encrypt(struct aead_request *a_req)
1618 {
1619 	return sec_aead_crypto(a_req, true);
1620 }
1621 
1622 static int sec_aead_decrypt(struct aead_request *a_req)
1623 {
1624 	return sec_aead_crypto(a_req, false);
1625 }
1626 
1627 #define SEC_AEAD_GEN_ALG(sec_cra_name, sec_set_key, ctx_init,\
1628 			 ctx_exit, blk_size, iv_size, max_authsize)\
1629 {\
1630 	.base = {\
1631 		.cra_name = sec_cra_name,\
1632 		.cra_driver_name = "hisi_sec_"sec_cra_name,\
1633 		.cra_priority = SEC_PRIORITY,\
1634 		.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY,\
1635 		.cra_blocksize = blk_size,\
1636 		.cra_ctxsize = sizeof(struct sec_ctx),\
1637 		.cra_module = THIS_MODULE,\
1638 	},\
1639 	.init = ctx_init,\
1640 	.exit = ctx_exit,\
1641 	.setkey = sec_set_key,\
1642 	.decrypt = sec_aead_decrypt,\
1643 	.encrypt = sec_aead_encrypt,\
1644 	.ivsize = iv_size,\
1645 	.maxauthsize = max_authsize,\
1646 }
1647 
1648 #define SEC_AEAD_ALG(algname, keyfunc, aead_init, blksize, ivsize, authsize)\
1649 	SEC_AEAD_GEN_ALG(algname, keyfunc, aead_init,\
1650 			sec_aead_ctx_exit, blksize, ivsize, authsize)
1651 
1652 static struct aead_alg sec_aeads[] = {
1653 	SEC_AEAD_ALG("authenc(hmac(sha1),cbc(aes))",
1654 		     sec_setkey_aes_cbc_sha1, sec_aead_sha1_ctx_init,
1655 		     AES_BLOCK_SIZE, AES_BLOCK_SIZE, SHA1_DIGEST_SIZE),
1656 
1657 	SEC_AEAD_ALG("authenc(hmac(sha256),cbc(aes))",
1658 		     sec_setkey_aes_cbc_sha256, sec_aead_sha256_ctx_init,
1659 		     AES_BLOCK_SIZE, AES_BLOCK_SIZE, SHA256_DIGEST_SIZE),
1660 
1661 	SEC_AEAD_ALG("authenc(hmac(sha512),cbc(aes))",
1662 		     sec_setkey_aes_cbc_sha512, sec_aead_sha512_ctx_init,
1663 		     AES_BLOCK_SIZE, AES_BLOCK_SIZE, SHA512_DIGEST_SIZE),
1664 };
1665 
1666 int sec_register_to_crypto(struct hisi_qm *qm)
1667 {
1668 	int ret;
1669 
1670 	/* To avoid repeat register */
1671 	ret = crypto_register_skciphers(sec_skciphers,
1672 					ARRAY_SIZE(sec_skciphers));
1673 	if (ret)
1674 		return ret;
1675 
1676 	ret = crypto_register_aeads(sec_aeads, ARRAY_SIZE(sec_aeads));
1677 	if (ret)
1678 		crypto_unregister_skciphers(sec_skciphers,
1679 					    ARRAY_SIZE(sec_skciphers));
1680 	return ret;
1681 }
1682 
1683 void sec_unregister_from_crypto(struct hisi_qm *qm)
1684 {
1685 	crypto_unregister_skciphers(sec_skciphers,
1686 				    ARRAY_SIZE(sec_skciphers));
1687 	crypto_unregister_aeads(sec_aeads, ARRAY_SIZE(sec_aeads));
1688 }
1689