?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/rockchip: Don't change hdmi reference clock rate
[drm/drm-misc.git] / drivers / crypto / hisilicon / hpre / hpre_crypto.c
blob2a29102612108fcb902b5d2957d1f4800f2ac23d
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2019 HiSilicon Limited. */
3 #include <crypto/akcipher.h>
4 #include <crypto/curve25519.h>
5 #include <crypto/dh.h>
6 #include <crypto/ecc_curve.h>
7 #include <crypto/ecdh.h>
8 #include <crypto/rng.h>
9 #include <crypto/internal/akcipher.h>
10 #include <crypto/internal/kpp.h>
11 #include <crypto/internal/rsa.h>
12 #include <crypto/kpp.h>
13 #include <crypto/scatterwalk.h>
14 #include <linux/dma-mapping.h>
15 #include <linux/fips.h>
16 #include <linux/module.h>
17 #include <linux/time.h>
18 #include "hpre.h"
19
20 struct hpre_ctx;
21
22 #define HPRE_CRYPTO_ALG_PRI 1000
23 #define HPRE_ALIGN_SZ 64
24 #define HPRE_BITS_2_BYTES_SHIFT 3
25 #define HPRE_RSA_512BITS_KSZ 64
26 #define HPRE_RSA_1536BITS_KSZ 192
27 #define HPRE_CRT_PRMS 5
28 #define HPRE_CRT_Q 2
29 #define HPRE_CRT_P 3
30 #define HPRE_CRT_INV 4
31 #define HPRE_DH_G_FLAG 0x02
32 #define HPRE_TRY_SEND_TIMES 100
33 #define HPRE_INVLD_REQ_ID (-1)
34
35 #define HPRE_SQE_ALG_BITS 5
36 #define HPRE_SQE_DONE_SHIFT 30
37 #define HPRE_DH_MAX_P_SZ 512
38
39 #define HPRE_DFX_SEC_TO_US 1000000
40 #define HPRE_DFX_US_TO_NS 1000
41
42 /* due to nist p521 */
43 #define HPRE_ECC_MAX_KSZ 66
44
45 /* size in bytes of the n prime */
46 #define HPRE_ECC_NIST_P192_N_SIZE 24
47 #define HPRE_ECC_NIST_P256_N_SIZE 32
48 #define HPRE_ECC_NIST_P384_N_SIZE 48
49
50 /* size in bytes */
51 #define HPRE_ECC_HW256_KSZ_B 32
52 #define HPRE_ECC_HW384_KSZ_B 48
53
54 /* capability register mask of driver */
55 #define HPRE_DRV_RSA_MASK_CAP BIT(0)
56 #define HPRE_DRV_DH_MASK_CAP BIT(1)
57 #define HPRE_DRV_ECDH_MASK_CAP BIT(2)
58 #define HPRE_DRV_X25519_MASK_CAP BIT(5)
59
60 static DEFINE_MUTEX(hpre_algs_lock);
61 static unsigned int hpre_available_devs;
62
63 typedef void (*hpre_cb)(struct hpre_ctx *ctx, void *sqe);
64
65 struct hpre_rsa_ctx {
66 /* low address: e--->n */
67 char *pubkey;
68 dma_addr_t dma_pubkey;
69
70 /* low address: d--->n */
71 char *prikey;
72 dma_addr_t dma_prikey;
73
74 /* low address: dq->dp->q->p->qinv */
75 char *crt_prikey;
76 dma_addr_t dma_crt_prikey;
77
78 struct crypto_akcipher *soft_tfm;
79 };
80
81 struct hpre_dh_ctx {
82 /*
83 * If base is g we compute the public key
84 * ya = g^xa mod p; [RFC2631 sec 2.1.1]
85 * else if base if the counterpart public key we
86 * compute the shared secret
87 * ZZ = yb^xa mod p; [RFC2631 sec 2.1.1]
88 * low address: d--->n, please refer to Hisilicon HPRE UM
89 */
90 char *xa_p;
91 dma_addr_t dma_xa_p;
92
93 char *g; /* m */
94 dma_addr_t dma_g;
95 };
96
97 struct hpre_ecdh_ctx {
98 /* low address: p->a->k->b */
99 unsigned char *p;
100 dma_addr_t dma_p;
101
102 /* low address: x->y */
103 unsigned char *g;
104 dma_addr_t dma_g;
105 };
106
107 struct hpre_curve25519_ctx {
108 /* low address: p->a->k */
109 unsigned char *p;
110 dma_addr_t dma_p;
111
112 /* gx coordinate */
113 unsigned char *g;
114 dma_addr_t dma_g;
115 };
116
117 struct hpre_ctx {
118 struct hisi_qp *qp;
119 struct device *dev;
120 struct hpre_asym_request **req_list;
121 struct hpre *hpre;
122 spinlock_t req_lock;
123 unsigned int key_sz;
124 bool crt_g2_mode;
125 struct idr req_idr;
126 union {
127 struct hpre_rsa_ctx rsa;
128 struct hpre_dh_ctx dh;
129 struct hpre_ecdh_ctx ecdh;
130 struct hpre_curve25519_ctx curve25519;
131 };
132 /* for ecc algorithms */
133 unsigned int curve_id;
134 };
135
136 struct hpre_asym_request {
137 char *src;
138 char *dst;
139 struct hpre_sqe req;
140 struct hpre_ctx *ctx;
141 union {
142 struct akcipher_request *rsa;
143 struct kpp_request *dh;
144 struct kpp_request *ecdh;
145 struct kpp_request *curve25519;
146 } areq;
147 int err;
148 int req_id;
149 hpre_cb cb;
150 struct timespec64 req_time;
151 };
152
153 static inline unsigned int hpre_align_sz(void)
154 {
155 return ((crypto_dma_align() - 1) | (HPRE_ALIGN_SZ - 1)) + 1;
156 }
157
158 static inline unsigned int hpre_align_pd(void)
159 {
160 return (hpre_align_sz() - 1) & ~(crypto_tfm_ctx_alignment() - 1);
161 }
162
163 static int hpre_alloc_req_id(struct hpre_ctx *ctx)
164 {
165 unsigned long flags;
166 int id;
167
168 spin_lock_irqsave(&ctx->req_lock, flags);
169 id = idr_alloc(&ctx->req_idr, NULL, 0, ctx->qp->sq_depth, GFP_ATOMIC);
170 spin_unlock_irqrestore(&ctx->req_lock, flags);
171
172 return id;
173 }
174
175 static void hpre_free_req_id(struct hpre_ctx *ctx, int req_id)
176 {
177 unsigned long flags;
178
179 spin_lock_irqsave(&ctx->req_lock, flags);
180 idr_remove(&ctx->req_idr, req_id);
181 spin_unlock_irqrestore(&ctx->req_lock, flags);
182 }
183
184 static int hpre_add_req_to_ctx(struct hpre_asym_request *hpre_req)
185 {
186 struct hpre_ctx *ctx;
187 struct hpre_dfx *dfx;
188 int id;
189
190 ctx = hpre_req->ctx;
191 id = hpre_alloc_req_id(ctx);
192 if (unlikely(id < 0))
193 return -EINVAL;
194
195 ctx->req_list[id] = hpre_req;
196 hpre_req->req_id = id;
197
198 dfx = ctx->hpre->debug.dfx;
199 if (atomic64_read(&dfx[HPRE_OVERTIME_THRHLD].value))
200 ktime_get_ts64(&hpre_req->req_time);
201
202 return id;
203 }
204
205 static void hpre_rm_req_from_ctx(struct hpre_asym_request *hpre_req)
206 {
207 struct hpre_ctx *ctx = hpre_req->ctx;
208 int id = hpre_req->req_id;
209
210 if (hpre_req->req_id >= 0) {
211 hpre_req->req_id = HPRE_INVLD_REQ_ID;
212 ctx->req_list[id] = NULL;
213 hpre_free_req_id(ctx, id);
214 }
215 }
216
217 static struct hisi_qp *hpre_get_qp_and_start(u8 type)
218 {
219 struct hisi_qp *qp;
220 int ret;
221
222 qp = hpre_create_qp(type);
223 if (!qp) {
224 pr_err("Can not create hpre qp!\n");
225 return ERR_PTR(-ENODEV);
226 }
227
228 ret = hisi_qm_start_qp(qp, 0);
229 if (ret < 0) {
230 hisi_qm_free_qps(&qp, 1);
231 pci_err(qp->qm->pdev, "Can not start qp!\n");
232 return ERR_PTR(-EINVAL);
233 }
234
235 return qp;
236 }
237
238 static int hpre_get_data_dma_addr(struct hpre_asym_request *hpre_req,
239 struct scatterlist *data, unsigned int len,
240 int is_src, dma_addr_t *tmp)
241 {
242 struct device *dev = hpre_req->ctx->dev;
243 enum dma_data_direction dma_dir;
244
245 if (is_src) {
246 hpre_req->src = NULL;
247 dma_dir = DMA_TO_DEVICE;
248 } else {
249 hpre_req->dst = NULL;
250 dma_dir = DMA_FROM_DEVICE;
251 }
252 *tmp = dma_map_single(dev, sg_virt(data), len, dma_dir);
253 if (unlikely(dma_mapping_error(dev, *tmp))) {
254 dev_err(dev, "dma map data err!\n");
255 return -ENOMEM;
256 }
257
258 return 0;
259 }
260
261 static int hpre_prepare_dma_buf(struct hpre_asym_request *hpre_req,
262 struct scatterlist *data, unsigned int len,
263 int is_src, dma_addr_t *tmp)
264 {
265 struct hpre_ctx *ctx = hpre_req->ctx;
266 struct device *dev = ctx->dev;
267 void *ptr;
268 int shift;
269
270 shift = ctx->key_sz - len;
271 if (unlikely(shift < 0))
272 return -EINVAL;
273
274 ptr = dma_alloc_coherent(dev, ctx->key_sz, tmp, GFP_ATOMIC);
275 if (unlikely(!ptr))
276 return -ENOMEM;
277
278 if (is_src) {
279 scatterwalk_map_and_copy(ptr + shift, data, 0, len, 0);
280 hpre_req->src = ptr;
281 } else {
282 hpre_req->dst = ptr;
283 }
284
285 return 0;
286 }
287
288 static int hpre_hw_data_init(struct hpre_asym_request *hpre_req,
289 struct scatterlist *data, unsigned int len,
290 int is_src, int is_dh)
291 {
292 struct hpre_sqe *msg = &hpre_req->req;
293 struct hpre_ctx *ctx = hpre_req->ctx;
294 dma_addr_t tmp = 0;
295 int ret;
296
297 /* when the data is dh's source, we should format it */
298 if ((sg_is_last(data) && len == ctx->key_sz) &&
299 ((is_dh && !is_src) || !is_dh))
300 ret = hpre_get_data_dma_addr(hpre_req, data, len, is_src, &tmp);
301 else
302 ret = hpre_prepare_dma_buf(hpre_req, data, len, is_src, &tmp);
303
304 if (unlikely(ret))
305 return ret;
306
307 if (is_src)
308 msg->in = cpu_to_le64(tmp);
309 else
310 msg->out = cpu_to_le64(tmp);
311
312 return 0;
313 }
314
315 static void hpre_hw_data_clr_all(struct hpre_ctx *ctx,
316 struct hpre_asym_request *req,
317 struct scatterlist *dst,
318 struct scatterlist *src)
319 {
320 struct device *dev = ctx->dev;
321 struct hpre_sqe *sqe = &req->req;
322 dma_addr_t tmp;
323
324 tmp = le64_to_cpu(sqe->in);
325 if (unlikely(dma_mapping_error(dev, tmp)))
326 return;
327
328 if (src) {
329 if (req->src)
330 dma_free_coherent(dev, ctx->key_sz, req->src, tmp);
331 else
332 dma_unmap_single(dev, tmp, ctx->key_sz, DMA_TO_DEVICE);
333 }
334
335 tmp = le64_to_cpu(sqe->out);
336 if (unlikely(dma_mapping_error(dev, tmp)))
337 return;
338
339 if (req->dst) {
340 if (dst)
341 scatterwalk_map_and_copy(req->dst, dst, 0,
342 ctx->key_sz, 1);
343 dma_free_coherent(dev, ctx->key_sz, req->dst, tmp);
344 } else {
345 dma_unmap_single(dev, tmp, ctx->key_sz, DMA_FROM_DEVICE);
346 }
347 }
348
349 static int hpre_alg_res_post_hf(struct hpre_ctx *ctx, struct hpre_sqe *sqe,
350 void **kreq)
351 {
352 struct hpre_asym_request *req;
353 unsigned int err, done, alg;
354 int id;
355
356 #define HPRE_NO_HW_ERR 0
357 #define HPRE_HW_TASK_DONE 3
358 #define HREE_HW_ERR_MASK GENMASK(10, 0)
359 #define HREE_SQE_DONE_MASK GENMASK(1, 0)
360 #define HREE_ALG_TYPE_MASK GENMASK(4, 0)
361 id = (int)le16_to_cpu(sqe->tag);
362 req = ctx->req_list[id];
363 hpre_rm_req_from_ctx(req);
364 *kreq = req;
365
366 err = (le32_to_cpu(sqe->dw0) >> HPRE_SQE_ALG_BITS) &
367 HREE_HW_ERR_MASK;
368
369 done = (le32_to_cpu(sqe->dw0) >> HPRE_SQE_DONE_SHIFT) &
370 HREE_SQE_DONE_MASK;
371
372 if (likely(err == HPRE_NO_HW_ERR && done == HPRE_HW_TASK_DONE))
373 return 0;
374
375 alg = le32_to_cpu(sqe->dw0) & HREE_ALG_TYPE_MASK;
376 dev_err_ratelimited(ctx->dev, "alg[0x%x] error: done[0x%x], etype[0x%x]\n",
377 alg, done, err);
378
379 return -EINVAL;
380 }
381
382 static int hpre_ctx_set(struct hpre_ctx *ctx, struct hisi_qp *qp, int qlen)
383 {
384 struct hpre *hpre;
385
386 if (!ctx || !qp || qlen < 0)
387 return -EINVAL;
388
389 spin_lock_init(&ctx->req_lock);
390 ctx->qp = qp;
391 ctx->dev = &qp->qm->pdev->dev;
392
393 hpre = container_of(ctx->qp->qm, struct hpre, qm);
394 ctx->hpre = hpre;
395 ctx->req_list = kcalloc(qlen, sizeof(void *), GFP_KERNEL);
396 if (!ctx->req_list)
397 return -ENOMEM;
398 ctx->key_sz = 0;
399 ctx->crt_g2_mode = false;
400 idr_init(&ctx->req_idr);
401
402 return 0;
403 }
404
405 static void hpre_ctx_clear(struct hpre_ctx *ctx, bool is_clear_all)
406 {
407 if (is_clear_all) {
408 idr_destroy(&ctx->req_idr);
409 kfree(ctx->req_list);
410 hisi_qm_free_qps(&ctx->qp, 1);
411 }
412
413 ctx->crt_g2_mode = false;
414 ctx->key_sz = 0;
415 }
416
417 static bool hpre_is_bd_timeout(struct hpre_asym_request *req,
418 u64 overtime_thrhld)
419 {
420 struct timespec64 reply_time;
421 u64 time_use_us;
422
423 ktime_get_ts64(&reply_time);
424 time_use_us = (reply_time.tv_sec - req->req_time.tv_sec) *
425 HPRE_DFX_SEC_TO_US +
426 (reply_time.tv_nsec - req->req_time.tv_nsec) /
427 HPRE_DFX_US_TO_NS;
428
429 if (time_use_us <= overtime_thrhld)
430 return false;
431
432 return true;
433 }
434
435 static void hpre_dh_cb(struct hpre_ctx *ctx, void *resp)
436 {
437 struct hpre_dfx *dfx = ctx->hpre->debug.dfx;
438 struct hpre_asym_request *req;
439 struct kpp_request *areq;
440 u64 overtime_thrhld;
441 int ret;
442
443 ret = hpre_alg_res_post_hf(ctx, resp, (void **)&req);
444 areq = req->areq.dh;
445 areq->dst_len = ctx->key_sz;
446
447 overtime_thrhld = atomic64_read(&dfx[HPRE_OVERTIME_THRHLD].value);
448 if (overtime_thrhld && hpre_is_bd_timeout(req, overtime_thrhld))
449 atomic64_inc(&dfx[HPRE_OVER_THRHLD_CNT].value);
450
451 hpre_hw_data_clr_all(ctx, req, areq->dst, areq->src);
452 kpp_request_complete(areq, ret);
453 atomic64_inc(&dfx[HPRE_RECV_CNT].value);
454 }
455
456 static void hpre_rsa_cb(struct hpre_ctx *ctx, void *resp)
457 {
458 struct hpre_dfx *dfx = ctx->hpre->debug.dfx;
459 struct hpre_asym_request *req;
460 struct akcipher_request *areq;
461 u64 overtime_thrhld;
462 int ret;
463
464 ret = hpre_alg_res_post_hf(ctx, resp, (void **)&req);
465
466 overtime_thrhld = atomic64_read(&dfx[HPRE_OVERTIME_THRHLD].value);
467 if (overtime_thrhld && hpre_is_bd_timeout(req, overtime_thrhld))
468 atomic64_inc(&dfx[HPRE_OVER_THRHLD_CNT].value);
469
470 areq = req->areq.rsa;
471 areq->dst_len = ctx->key_sz;
472 hpre_hw_data_clr_all(ctx, req, areq->dst, areq->src);
473 akcipher_request_complete(areq, ret);
474 atomic64_inc(&dfx[HPRE_RECV_CNT].value);
475 }
476
477 static void hpre_alg_cb(struct hisi_qp *qp, void *resp)
478 {
479 struct hpre_ctx *ctx = qp->qp_ctx;
480 struct hpre_dfx *dfx = ctx->hpre->debug.dfx;
481 struct hpre_sqe *sqe = resp;
482 struct hpre_asym_request *req = ctx->req_list[le16_to_cpu(sqe->tag)];
483
484 if (unlikely(!req)) {
485 atomic64_inc(&dfx[HPRE_INVALID_REQ_CNT].value);
486 return;
487 }
488
489 req->cb(ctx, resp);
490 }
491
492 static void hpre_stop_qp_and_put(struct hisi_qp *qp)
493 {
494 hisi_qm_stop_qp(qp);
495 hisi_qm_free_qps(&qp, 1);
496 }
497
498 static int hpre_ctx_init(struct hpre_ctx *ctx, u8 type)
499 {
500 struct hisi_qp *qp;
501 int ret;
502
503 qp = hpre_get_qp_and_start(type);
504 if (IS_ERR(qp))
505 return PTR_ERR(qp);
506
507 qp->qp_ctx = ctx;
508 qp->req_cb = hpre_alg_cb;
509
510 ret = hpre_ctx_set(ctx, qp, qp->sq_depth);
511 if (ret)
512 hpre_stop_qp_and_put(qp);
513
514 return ret;
515 }
516
517 static int hpre_msg_request_set(struct hpre_ctx *ctx, void *req, bool is_rsa)
518 {
519 struct hpre_asym_request *h_req;
520 struct hpre_sqe *msg;
521 int req_id;
522 void *tmp;
523
524 if (is_rsa) {
525 struct akcipher_request *akreq = req;
526
527 if (akreq->dst_len < ctx->key_sz) {
528 akreq->dst_len = ctx->key_sz;
529 return -EOVERFLOW;
530 }
531
532 tmp = akcipher_request_ctx(akreq);
533 h_req = PTR_ALIGN(tmp, hpre_align_sz());
534 h_req->cb = hpre_rsa_cb;
535 h_req->areq.rsa = akreq;
536 msg = &h_req->req;
537 memset(msg, 0, sizeof(*msg));
538 } else {
539 struct kpp_request *kreq = req;
540
541 if (kreq->dst_len < ctx->key_sz) {
542 kreq->dst_len = ctx->key_sz;
543 return -EOVERFLOW;
544 }
545
546 tmp = kpp_request_ctx(kreq);
547 h_req = PTR_ALIGN(tmp, hpre_align_sz());
548 h_req->cb = hpre_dh_cb;
549 h_req->areq.dh = kreq;
550 msg = &h_req->req;
551 memset(msg, 0, sizeof(*msg));
552 msg->key = cpu_to_le64(ctx->dh.dma_xa_p);
553 }
554
555 msg->in = cpu_to_le64(DMA_MAPPING_ERROR);
556 msg->out = cpu_to_le64(DMA_MAPPING_ERROR);
557 msg->dw0 |= cpu_to_le32(0x1 << HPRE_SQE_DONE_SHIFT);
558 msg->task_len1 = (ctx->key_sz >> HPRE_BITS_2_BYTES_SHIFT) - 1;
559 h_req->ctx = ctx;
560
561 req_id = hpre_add_req_to_ctx(h_req);
562 if (req_id < 0)
563 return -EBUSY;
564
565 msg->tag = cpu_to_le16((u16)req_id);
566
567 return 0;
568 }
569
570 static int hpre_send(struct hpre_ctx *ctx, struct hpre_sqe *msg)
571 {
572 struct hpre_dfx *dfx = ctx->hpre->debug.dfx;
573 int ctr = 0;
574 int ret;
575
576 do {
577 atomic64_inc(&dfx[HPRE_SEND_CNT].value);
578 spin_lock_bh(&ctx->req_lock);
579 ret = hisi_qp_send(ctx->qp, msg);
580 spin_unlock_bh(&ctx->req_lock);
581 if (ret != -EBUSY)
582 break;
583 atomic64_inc(&dfx[HPRE_SEND_BUSY_CNT].value);
584 } while (ctr++ < HPRE_TRY_SEND_TIMES);
585
586 if (likely(!ret))
587 return ret;
588
589 if (ret != -EBUSY)
590 atomic64_inc(&dfx[HPRE_SEND_FAIL_CNT].value);
591
592 return ret;
593 }
594
595 static int hpre_dh_compute_value(struct kpp_request *req)
596 {
597 struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
598 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
599 void *tmp = kpp_request_ctx(req);
600 struct hpre_asym_request *hpre_req = PTR_ALIGN(tmp, hpre_align_sz());
601 struct hpre_sqe *msg = &hpre_req->req;
602 int ret;
603
604 ret = hpre_msg_request_set(ctx, req, false);
605 if (unlikely(ret))
606 return ret;
607
608 if (req->src) {
609 ret = hpre_hw_data_init(hpre_req, req->src, req->src_len, 1, 1);
610 if (unlikely(ret))
611 goto clear_all;
612 } else {
613 msg->in = cpu_to_le64(ctx->dh.dma_g);
614 }
615
616 ret = hpre_hw_data_init(hpre_req, req->dst, req->dst_len, 0, 1);
617 if (unlikely(ret))
618 goto clear_all;
619
620 if (ctx->crt_g2_mode && !req->src)
621 msg->dw0 = cpu_to_le32(le32_to_cpu(msg->dw0) | HPRE_ALG_DH_G2);
622 else
623 msg->dw0 = cpu_to_le32(le32_to_cpu(msg->dw0) | HPRE_ALG_DH);
624
625 /* success */
626 ret = hpre_send(ctx, msg);
627 if (likely(!ret))
628 return -EINPROGRESS;
629
630 clear_all:
631 hpre_rm_req_from_ctx(hpre_req);
632 hpre_hw_data_clr_all(ctx, hpre_req, req->dst, req->src);
633
634 return ret;
635 }
636
637 static int hpre_is_dh_params_length_valid(unsigned int key_sz)
638 {
639 #define _HPRE_DH_GRP1 768
640 #define _HPRE_DH_GRP2 1024
641 #define _HPRE_DH_GRP5 1536
642 #define _HPRE_DH_GRP14 2048
643 #define _HPRE_DH_GRP15 3072
644 #define _HPRE_DH_GRP16 4096
645 switch (key_sz) {
646 case _HPRE_DH_GRP1:
647 case _HPRE_DH_GRP2:
648 case _HPRE_DH_GRP5:
649 case _HPRE_DH_GRP14:
650 case _HPRE_DH_GRP15:
651 case _HPRE_DH_GRP16:
652 return 0;
653 default:
654 return -EINVAL;
655 }
656 }
657
658 static int hpre_dh_set_params(struct hpre_ctx *ctx, struct dh *params)
659 {
660 struct device *dev = ctx->dev;
661 unsigned int sz;
662
663 if (params->p_size > HPRE_DH_MAX_P_SZ)
664 return -EINVAL;
665
666 if (hpre_is_dh_params_length_valid(params->p_size <<
667 HPRE_BITS_2_BYTES_SHIFT))
668 return -EINVAL;
669
670 sz = ctx->key_sz = params->p_size;
671 ctx->dh.xa_p = dma_alloc_coherent(dev, sz << 1,
672 &ctx->dh.dma_xa_p, GFP_KERNEL);
673 if (!ctx->dh.xa_p)
674 return -ENOMEM;
675
676 memcpy(ctx->dh.xa_p + sz, params->p, sz);
677
678 /* If g equals 2 don't copy it */
679 if (params->g_size == 1 && *(char *)params->g == HPRE_DH_G_FLAG) {
680 ctx->crt_g2_mode = true;
681 return 0;
682 }
683
684 ctx->dh.g = dma_alloc_coherent(dev, sz, &ctx->dh.dma_g, GFP_KERNEL);
685 if (!ctx->dh.g) {
686 dma_free_coherent(dev, sz << 1, ctx->dh.xa_p,
687 ctx->dh.dma_xa_p);
688 ctx->dh.xa_p = NULL;
689 return -ENOMEM;
690 }
691
692 memcpy(ctx->dh.g + (sz - params->g_size), params->g, params->g_size);
693
694 return 0;
695 }
696
697 static void hpre_dh_clear_ctx(struct hpre_ctx *ctx, bool is_clear_all)
698 {
699 struct device *dev = ctx->dev;
700 unsigned int sz = ctx->key_sz;
701
702 if (is_clear_all)
703 hisi_qm_stop_qp(ctx->qp);
704
705 if (ctx->dh.g) {
706 dma_free_coherent(dev, sz, ctx->dh.g, ctx->dh.dma_g);
707 ctx->dh.g = NULL;
708 }
709
710 if (ctx->dh.xa_p) {
711 memzero_explicit(ctx->dh.xa_p, sz);
712 dma_free_coherent(dev, sz << 1, ctx->dh.xa_p,
713 ctx->dh.dma_xa_p);
714 ctx->dh.xa_p = NULL;
715 }
716
717 hpre_ctx_clear(ctx, is_clear_all);
718 }
719
720 static int hpre_dh_set_secret(struct crypto_kpp *tfm, const void *buf,
721 unsigned int len)
722 {
723 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
724 struct dh params;
725 int ret;
726
727 if (crypto_dh_decode_key(buf, len, &params) < 0)
728 return -EINVAL;
729
730 /* Free old secret if any */
731 hpre_dh_clear_ctx(ctx, false);
732
733 ret = hpre_dh_set_params(ctx, &params);
734 if (ret < 0)
735 goto err_clear_ctx;
736
737 memcpy(ctx->dh.xa_p + (ctx->key_sz - params.key_size), params.key,
738 params.key_size);
739
740 return 0;
741
742 err_clear_ctx:
743 hpre_dh_clear_ctx(ctx, false);
744 return ret;
745 }
746
747 static unsigned int hpre_dh_max_size(struct crypto_kpp *tfm)
748 {
749 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
750
751 return ctx->key_sz;
752 }
753
754 static int hpre_dh_init_tfm(struct crypto_kpp *tfm)
755 {
756 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
757
758 kpp_set_reqsize(tfm, sizeof(struct hpre_asym_request) + hpre_align_pd());
759
760 return hpre_ctx_init(ctx, HPRE_V2_ALG_TYPE);
761 }
762
763 static void hpre_dh_exit_tfm(struct crypto_kpp *tfm)
764 {
765 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
766
767 hpre_dh_clear_ctx(ctx, true);
768 }
769
770 static void hpre_rsa_drop_leading_zeros(const char **ptr, size_t *len)
771 {
772 while (!**ptr && *len) {
773 (*ptr)++;
774 (*len)--;
775 }
776 }
777
778 static bool hpre_rsa_key_size_is_support(unsigned int len)
779 {
780 unsigned int bits = len << HPRE_BITS_2_BYTES_SHIFT;
781
782 #define _RSA_1024BITS_KEY_WDTH 1024
783 #define _RSA_2048BITS_KEY_WDTH 2048
784 #define _RSA_3072BITS_KEY_WDTH 3072
785 #define _RSA_4096BITS_KEY_WDTH 4096
786
787 switch (bits) {
788 case _RSA_1024BITS_KEY_WDTH:
789 case _RSA_2048BITS_KEY_WDTH:
790 case _RSA_3072BITS_KEY_WDTH:
791 case _RSA_4096BITS_KEY_WDTH:
792 return true;
793 default:
794 return false;
795 }
796 }
797
798 static int hpre_rsa_enc(struct akcipher_request *req)
799 {
800 struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
801 struct hpre_ctx *ctx = akcipher_tfm_ctx(tfm);
802 void *tmp = akcipher_request_ctx(req);
803 struct hpre_asym_request *hpre_req = PTR_ALIGN(tmp, hpre_align_sz());
804 struct hpre_sqe *msg = &hpre_req->req;
805 int ret;
806
807 /* For 512 and 1536 bits key size, use soft tfm instead */
808 if (ctx->key_sz == HPRE_RSA_512BITS_KSZ ||
809 ctx->key_sz == HPRE_RSA_1536BITS_KSZ) {
810 akcipher_request_set_tfm(req, ctx->rsa.soft_tfm);
811 ret = crypto_akcipher_encrypt(req);
812 akcipher_request_set_tfm(req, tfm);
813 return ret;
814 }
815
816 if (unlikely(!ctx->rsa.pubkey))
817 return -EINVAL;
818
819 ret = hpre_msg_request_set(ctx, req, true);
820 if (unlikely(ret))
821 return ret;
822
823 msg->dw0 |= cpu_to_le32(HPRE_ALG_NC_NCRT);
824 msg->key = cpu_to_le64(ctx->rsa.dma_pubkey);
825
826 ret = hpre_hw_data_init(hpre_req, req->src, req->src_len, 1, 0);
827 if (unlikely(ret))
828 goto clear_all;
829
830 ret = hpre_hw_data_init(hpre_req, req->dst, req->dst_len, 0, 0);
831 if (unlikely(ret))
832 goto clear_all;
833
834 /* success */
835 ret = hpre_send(ctx, msg);
836 if (likely(!ret))
837 return -EINPROGRESS;
838
839 clear_all:
840 hpre_rm_req_from_ctx(hpre_req);
841 hpre_hw_data_clr_all(ctx, hpre_req, req->dst, req->src);
842
843 return ret;
844 }
845
846 static int hpre_rsa_dec(struct akcipher_request *req)
847 {
848 struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
849 struct hpre_ctx *ctx = akcipher_tfm_ctx(tfm);
850 void *tmp = akcipher_request_ctx(req);
851 struct hpre_asym_request *hpre_req = PTR_ALIGN(tmp, hpre_align_sz());
852 struct hpre_sqe *msg = &hpre_req->req;
853 int ret;
854
855 /* For 512 and 1536 bits key size, use soft tfm instead */
856 if (ctx->key_sz == HPRE_RSA_512BITS_KSZ ||
857 ctx->key_sz == HPRE_RSA_1536BITS_KSZ) {
858 akcipher_request_set_tfm(req, ctx->rsa.soft_tfm);
859 ret = crypto_akcipher_decrypt(req);
860 akcipher_request_set_tfm(req, tfm);
861 return ret;
862 }
863
864 if (unlikely(!ctx->rsa.prikey))
865 return -EINVAL;
866
867 ret = hpre_msg_request_set(ctx, req, true);
868 if (unlikely(ret))
869 return ret;
870
871 if (ctx->crt_g2_mode) {
872 msg->key = cpu_to_le64(ctx->rsa.dma_crt_prikey);
873 msg->dw0 = cpu_to_le32(le32_to_cpu(msg->dw0) |
874 HPRE_ALG_NC_CRT);
875 } else {
876 msg->key = cpu_to_le64(ctx->rsa.dma_prikey);
877 msg->dw0 = cpu_to_le32(le32_to_cpu(msg->dw0) |
878 HPRE_ALG_NC_NCRT);
879 }
880
881 ret = hpre_hw_data_init(hpre_req, req->src, req->src_len, 1, 0);
882 if (unlikely(ret))
883 goto clear_all;
884
885 ret = hpre_hw_data_init(hpre_req, req->dst, req->dst_len, 0, 0);
886 if (unlikely(ret))
887 goto clear_all;
888
889 /* success */
890 ret = hpre_send(ctx, msg);
891 if (likely(!ret))
892 return -EINPROGRESS;
893
894 clear_all:
895 hpre_rm_req_from_ctx(hpre_req);
896 hpre_hw_data_clr_all(ctx, hpre_req, req->dst, req->src);
897
898 return ret;
899 }
900
901 static int hpre_rsa_set_n(struct hpre_ctx *ctx, const char *value,
902 size_t vlen, bool private)
903 {
904 const char *ptr = value;
905
906 hpre_rsa_drop_leading_zeros(&ptr, &vlen);
907
908 ctx->key_sz = vlen;
909
910 /* if invalid key size provided, we use software tfm */
911 if (!hpre_rsa_key_size_is_support(ctx->key_sz))
912 return 0;
913
914 ctx->rsa.pubkey = dma_alloc_coherent(ctx->dev, vlen << 1,
915 &ctx->rsa.dma_pubkey,
916 GFP_KERNEL);
917 if (!ctx->rsa.pubkey)
918 return -ENOMEM;
919
920 if (private) {
921 ctx->rsa.prikey = dma_alloc_coherent(ctx->dev, vlen << 1,
922 &ctx->rsa.dma_prikey,
923 GFP_KERNEL);
924 if (!ctx->rsa.prikey) {
925 dma_free_coherent(ctx->dev, vlen << 1,
926 ctx->rsa.pubkey,
927 ctx->rsa.dma_pubkey);
928 ctx->rsa.pubkey = NULL;
929 return -ENOMEM;
930 }
931 memcpy(ctx->rsa.prikey + vlen, ptr, vlen);
932 }
933 memcpy(ctx->rsa.pubkey + vlen, ptr, vlen);
934
935 /* Using hardware HPRE to do RSA */
936 return 1;
937 }
938
939 static int hpre_rsa_set_e(struct hpre_ctx *ctx, const char *value,
940 size_t vlen)
941 {
942 const char *ptr = value;
943
944 hpre_rsa_drop_leading_zeros(&ptr, &vlen);
945
946 if (!ctx->key_sz || !vlen || vlen > ctx->key_sz)
947 return -EINVAL;
948
949 memcpy(ctx->rsa.pubkey + ctx->key_sz - vlen, ptr, vlen);
950
951 return 0;
952 }
953
954 static int hpre_rsa_set_d(struct hpre_ctx *ctx, const char *value,
955 size_t vlen)
956 {
957 const char *ptr = value;
958
959 hpre_rsa_drop_leading_zeros(&ptr, &vlen);
960
961 if (!ctx->key_sz || !vlen || vlen > ctx->key_sz)
962 return -EINVAL;
963
964 memcpy(ctx->rsa.prikey + ctx->key_sz - vlen, ptr, vlen);
965
966 return 0;
967 }
968
969 static int hpre_crt_para_get(char *para, size_t para_sz,
970 const char *raw, size_t raw_sz)
971 {
972 const char *ptr = raw;
973 size_t len = raw_sz;
974
975 hpre_rsa_drop_leading_zeros(&ptr, &len);
976 if (!len || len > para_sz)
977 return -EINVAL;
978
979 memcpy(para + para_sz - len, ptr, len);
980
981 return 0;
982 }
983
984 static int hpre_rsa_setkey_crt(struct hpre_ctx *ctx, struct rsa_key *rsa_key)
985 {
986 unsigned int hlf_ksz = ctx->key_sz >> 1;
987 struct device *dev = ctx->dev;
988 u64 offset;
989 int ret;
990
991 ctx->rsa.crt_prikey = dma_alloc_coherent(dev, hlf_ksz * HPRE_CRT_PRMS,
992 &ctx->rsa.dma_crt_prikey,
993 GFP_KERNEL);
994 if (!ctx->rsa.crt_prikey)
995 return -ENOMEM;
996
997 ret = hpre_crt_para_get(ctx->rsa.crt_prikey, hlf_ksz,
998 rsa_key->dq, rsa_key->dq_sz);
999 if (ret)
1000 goto free_key;
1001
1002 offset = hlf_ksz;
1003 ret = hpre_crt_para_get(ctx->rsa.crt_prikey + offset, hlf_ksz,
1004 rsa_key->dp, rsa_key->dp_sz);
1005 if (ret)
1006 goto free_key;
1007
1008 offset = hlf_ksz * HPRE_CRT_Q;
1009 ret = hpre_crt_para_get(ctx->rsa.crt_prikey + offset, hlf_ksz,
1010 rsa_key->q, rsa_key->q_sz);
1011 if (ret)
1012 goto free_key;
1013
1014 offset = hlf_ksz * HPRE_CRT_P;
1015 ret = hpre_crt_para_get(ctx->rsa.crt_prikey + offset, hlf_ksz,
1016 rsa_key->p, rsa_key->p_sz);
1017 if (ret)
1018 goto free_key;
1019
1020 offset = hlf_ksz * HPRE_CRT_INV;
1021 ret = hpre_crt_para_get(ctx->rsa.crt_prikey + offset, hlf_ksz,
1022 rsa_key->qinv, rsa_key->qinv_sz);
1023 if (ret)
1024 goto free_key;
1025
1026 ctx->crt_g2_mode = true;
1027
1028 return 0;
1029
1030 free_key:
1031 offset = hlf_ksz * HPRE_CRT_PRMS;
1032 memzero_explicit(ctx->rsa.crt_prikey, offset);
1033 dma_free_coherent(dev, hlf_ksz * HPRE_CRT_PRMS, ctx->rsa.crt_prikey,
1034 ctx->rsa.dma_crt_prikey);
1035 ctx->rsa.crt_prikey = NULL;
1036 ctx->crt_g2_mode = false;
1037
1038 return ret;
1039 }
1040
1041 /* If it is clear all, all the resources of the QP will be cleaned. */
1042 static void hpre_rsa_clear_ctx(struct hpre_ctx *ctx, bool is_clear_all)
1043 {
1044 unsigned int half_key_sz = ctx->key_sz >> 1;
1045 struct device *dev = ctx->dev;
1046
1047 if (is_clear_all)
1048 hisi_qm_stop_qp(ctx->qp);
1049
1050 if (ctx->rsa.pubkey) {
1051 dma_free_coherent(dev, ctx->key_sz << 1,
1052 ctx->rsa.pubkey, ctx->rsa.dma_pubkey);
1053 ctx->rsa.pubkey = NULL;
1054 }
1055
1056 if (ctx->rsa.crt_prikey) {
1057 memzero_explicit(ctx->rsa.crt_prikey,
1058 half_key_sz * HPRE_CRT_PRMS);
1059 dma_free_coherent(dev, half_key_sz * HPRE_CRT_PRMS,
1060 ctx->rsa.crt_prikey, ctx->rsa.dma_crt_prikey);
1061 ctx->rsa.crt_prikey = NULL;
1062 }
1063
1064 if (ctx->rsa.prikey) {
1065 memzero_explicit(ctx->rsa.prikey, ctx->key_sz);
1066 dma_free_coherent(dev, ctx->key_sz << 1, ctx->rsa.prikey,
1067 ctx->rsa.dma_prikey);
1068 ctx->rsa.prikey = NULL;
1069 }
1070
1071 hpre_ctx_clear(ctx, is_clear_all);
1072 }
1073
1074 /*
1075 * we should judge if it is CRT or not,
1076 * CRT: return true, N-CRT: return false .
1077 */
1078 static bool hpre_is_crt_key(struct rsa_key *key)
1079 {
1080 u16 len = key->p_sz + key->q_sz + key->dp_sz + key->dq_sz +
1081 key->qinv_sz;
1082
1083 #define LEN_OF_NCRT_PARA 5
1084
1085 /* N-CRT less than 5 parameters */
1086 return len > LEN_OF_NCRT_PARA;
1087 }
1088
1089 static int hpre_rsa_setkey(struct hpre_ctx *ctx, const void *key,
1090 unsigned int keylen, bool private)
1091 {
1092 struct rsa_key rsa_key;
1093 int ret;
1094
1095 hpre_rsa_clear_ctx(ctx, false);
1096
1097 if (private)
1098 ret = rsa_parse_priv_key(&rsa_key, key, keylen);
1099 else
1100 ret = rsa_parse_pub_key(&rsa_key, key, keylen);
1101 if (ret < 0)
1102 return ret;
1103
1104 ret = hpre_rsa_set_n(ctx, rsa_key.n, rsa_key.n_sz, private);
1105 if (ret <= 0)
1106 return ret;
1107
1108 if (private) {
1109 ret = hpre_rsa_set_d(ctx, rsa_key.d, rsa_key.d_sz);
1110 if (ret < 0)
1111 goto free;
1112
1113 if (hpre_is_crt_key(&rsa_key)) {
1114 ret = hpre_rsa_setkey_crt(ctx, &rsa_key);
1115 if (ret < 0)
1116 goto free;
1117 }
1118 }
1119
1120 ret = hpre_rsa_set_e(ctx, rsa_key.e, rsa_key.e_sz);
1121 if (ret < 0)
1122 goto free;
1123
1124 if ((private && !ctx->rsa.prikey) || !ctx->rsa.pubkey) {
1125 ret = -EINVAL;
1126 goto free;
1127 }
1128
1129 return 0;
1130
1131 free:
1132 hpre_rsa_clear_ctx(ctx, false);
1133 return ret;
1134 }
1135
1136 static int hpre_rsa_setpubkey(struct crypto_akcipher *tfm, const void *key,
1137 unsigned int keylen)
1138 {
1139 struct hpre_ctx *ctx = akcipher_tfm_ctx(tfm);
1140 int ret;
1141
1142 ret = crypto_akcipher_set_pub_key(ctx->rsa.soft_tfm, key, keylen);
1143 if (ret)
1144 return ret;
1145
1146 return hpre_rsa_setkey(ctx, key, keylen, false);
1147 }
1148
1149 static int hpre_rsa_setprivkey(struct crypto_akcipher *tfm, const void *key,
1150 unsigned int keylen)
1151 {
1152 struct hpre_ctx *ctx = akcipher_tfm_ctx(tfm);
1153 int ret;
1154
1155 ret = crypto_akcipher_set_priv_key(ctx->rsa.soft_tfm, key, keylen);
1156 if (ret)
1157 return ret;
1158
1159 return hpre_rsa_setkey(ctx, key, keylen, true);
1160 }
1161
1162 static unsigned int hpre_rsa_max_size(struct crypto_akcipher *tfm)
1163 {
1164 struct hpre_ctx *ctx = akcipher_tfm_ctx(tfm);
1165
1166 /* For 512 and 1536 bits key size, use soft tfm instead */
1167 if (ctx->key_sz == HPRE_RSA_512BITS_KSZ ||
1168 ctx->key_sz == HPRE_RSA_1536BITS_KSZ)
1169 return crypto_akcipher_maxsize(ctx->rsa.soft_tfm);
1170
1171 return ctx->key_sz;
1172 }
1173
1174 static int hpre_rsa_init_tfm(struct crypto_akcipher *tfm)
1175 {
1176 struct hpre_ctx *ctx = akcipher_tfm_ctx(tfm);
1177 int ret;
1178
1179 ctx->rsa.soft_tfm = crypto_alloc_akcipher("rsa-generic", 0, 0);
1180 if (IS_ERR(ctx->rsa.soft_tfm)) {
1181 pr_err("Can not alloc_akcipher!\n");
1182 return PTR_ERR(ctx->rsa.soft_tfm);
1183 }
1184
1185 akcipher_set_reqsize(tfm, sizeof(struct hpre_asym_request) +
1186 hpre_align_pd());
1187
1188 ret = hpre_ctx_init(ctx, HPRE_V2_ALG_TYPE);
1189 if (ret)
1190 crypto_free_akcipher(ctx->rsa.soft_tfm);
1191
1192 return ret;
1193 }
1194
1195 static void hpre_rsa_exit_tfm(struct crypto_akcipher *tfm)
1196 {
1197 struct hpre_ctx *ctx = akcipher_tfm_ctx(tfm);
1198
1199 hpre_rsa_clear_ctx(ctx, true);
1200 crypto_free_akcipher(ctx->rsa.soft_tfm);
1201 }
1202
1203 static void hpre_key_to_big_end(u8 *data, int len)
1204 {
1205 int i, j;
1206
1207 for (i = 0; i < len / 2; i++) {
1208 j = len - i - 1;
1209 swap(data[j], data[i]);
1210 }
1211 }
1212
1213 static void hpre_ecc_clear_ctx(struct hpre_ctx *ctx, bool is_clear_all,
1214 bool is_ecdh)
1215 {
1216 struct device *dev = ctx->dev;
1217 unsigned int sz = ctx->key_sz;
1218 unsigned int shift = sz << 1;
1219
1220 if (is_clear_all)
1221 hisi_qm_stop_qp(ctx->qp);
1222
1223 if (is_ecdh && ctx->ecdh.p) {
1224 /* ecdh: p->a->k->b */
1225 memzero_explicit(ctx->ecdh.p + shift, sz);
1226 dma_free_coherent(dev, sz << 3, ctx->ecdh.p, ctx->ecdh.dma_p);
1227 ctx->ecdh.p = NULL;
1228 } else if (!is_ecdh && ctx->curve25519.p) {
1229 /* curve25519: p->a->k */
1230 memzero_explicit(ctx->curve25519.p + shift, sz);
1231 dma_free_coherent(dev, sz << 2, ctx->curve25519.p,
1232 ctx->curve25519.dma_p);
1233 ctx->curve25519.p = NULL;
1234 }
1235
1236 hpre_ctx_clear(ctx, is_clear_all);
1237 }
1238
1239 /*
1240 * The bits of 192/224/256/384/521 are supported by HPRE,
1241 * and convert the bits like:
1242 * bits<=256, bits=256; 256<bits<=384, bits=384; 384<bits<=576, bits=576;
1243 * If the parameter bit width is insufficient, then we fill in the
1244 * high-order zeros by soft, so TASK_LENGTH1 is 0x3/0x5/0x8;
1245 */
1246 static unsigned int hpre_ecdh_supported_curve(unsigned short id)
1247 {
1248 switch (id) {
1249 case ECC_CURVE_NIST_P192:
1250 case ECC_CURVE_NIST_P256:
1251 return HPRE_ECC_HW256_KSZ_B;
1252 case ECC_CURVE_NIST_P384:
1253 return HPRE_ECC_HW384_KSZ_B;
1254 default:
1255 break;
1256 }
1257
1258 return 0;
1259 }
1260
1261 static void fill_curve_param(void *addr, u64 *param, unsigned int cur_sz, u8 ndigits)
1262 {
1263 unsigned int sz = cur_sz - (ndigits - 1) * sizeof(u64);
1264 u8 i = 0;
1265
1266 while (i < ndigits - 1) {
1267 memcpy(addr + sizeof(u64) * i, &param[i], sizeof(u64));
1268 i++;
1269 }
1270
1271 memcpy(addr + sizeof(u64) * i, &param[ndigits - 1], sz);
1272 hpre_key_to_big_end((u8 *)addr, cur_sz);
1273 }
1274
1275 static int hpre_ecdh_fill_curve(struct hpre_ctx *ctx, struct ecdh *params,
1276 unsigned int cur_sz)
1277 {
1278 unsigned int shifta = ctx->key_sz << 1;
1279 unsigned int shiftb = ctx->key_sz << 2;
1280 void *p = ctx->ecdh.p + ctx->key_sz - cur_sz;
1281 void *a = ctx->ecdh.p + shifta - cur_sz;
1282 void *b = ctx->ecdh.p + shiftb - cur_sz;
1283 void *x = ctx->ecdh.g + ctx->key_sz - cur_sz;
1284 void *y = ctx->ecdh.g + shifta - cur_sz;
1285 const struct ecc_curve *curve = ecc_get_curve(ctx->curve_id);
1286 char *n;
1287
1288 if (unlikely(!curve))
1289 return -EINVAL;
1290
1291 n = kzalloc(ctx->key_sz, GFP_KERNEL);
1292 if (!n)
1293 return -ENOMEM;
1294
1295 fill_curve_param(p, curve->p, cur_sz, curve->g.ndigits);
1296 fill_curve_param(a, curve->a, cur_sz, curve->g.ndigits);
1297 fill_curve_param(b, curve->b, cur_sz, curve->g.ndigits);
1298 fill_curve_param(x, curve->g.x, cur_sz, curve->g.ndigits);
1299 fill_curve_param(y, curve->g.y, cur_sz, curve->g.ndigits);
1300 fill_curve_param(n, curve->n, cur_sz, curve->g.ndigits);
1301
1302 if (params->key_size == cur_sz && memcmp(params->key, n, cur_sz) >= 0) {
1303 kfree(n);
1304 return -EINVAL;
1305 }
1306
1307 kfree(n);
1308 return 0;
1309 }
1310
1311 static unsigned int hpre_ecdh_get_curvesz(unsigned short id)
1312 {
1313 switch (id) {
1314 case ECC_CURVE_NIST_P192:
1315 return HPRE_ECC_NIST_P192_N_SIZE;
1316 case ECC_CURVE_NIST_P256:
1317 return HPRE_ECC_NIST_P256_N_SIZE;
1318 case ECC_CURVE_NIST_P384:
1319 return HPRE_ECC_NIST_P384_N_SIZE;
1320 default:
1321 break;
1322 }
1323
1324 return 0;
1325 }
1326
1327 static int hpre_ecdh_set_param(struct hpre_ctx *ctx, struct ecdh *params)
1328 {
1329 struct device *dev = ctx->dev;
1330 unsigned int sz, shift, curve_sz;
1331 int ret;
1332
1333 ctx->key_sz = hpre_ecdh_supported_curve(ctx->curve_id);
1334 if (!ctx->key_sz)
1335 return -EINVAL;
1336
1337 curve_sz = hpre_ecdh_get_curvesz(ctx->curve_id);
1338 if (!curve_sz || params->key_size > curve_sz)
1339 return -EINVAL;
1340
1341 sz = ctx->key_sz;
1342
1343 if (!ctx->ecdh.p) {
1344 ctx->ecdh.p = dma_alloc_coherent(dev, sz << 3, &ctx->ecdh.dma_p,
1345 GFP_KERNEL);
1346 if (!ctx->ecdh.p)
1347 return -ENOMEM;
1348 }
1349
1350 shift = sz << 2;
1351 ctx->ecdh.g = ctx->ecdh.p + shift;
1352 ctx->ecdh.dma_g = ctx->ecdh.dma_p + shift;
1353
1354 ret = hpre_ecdh_fill_curve(ctx, params, curve_sz);
1355 if (ret) {
1356 dev_err(dev, "failed to fill curve_param, ret = %d!\n", ret);
1357 dma_free_coherent(dev, sz << 3, ctx->ecdh.p, ctx->ecdh.dma_p);
1358 ctx->ecdh.p = NULL;
1359 return ret;
1360 }
1361
1362 return 0;
1363 }
1364
1365 static bool hpre_key_is_zero(char *key, unsigned short key_sz)
1366 {
1367 int i;
1368
1369 for (i = 0; i < key_sz; i++)
1370 if (key[i])
1371 return false;
1372
1373 return true;
1374 }
1375
1376 static int ecdh_gen_privkey(struct hpre_ctx *ctx, struct ecdh *params)
1377 {
1378 struct device *dev = ctx->dev;
1379 int ret;
1380
1381 ret = crypto_get_default_rng();
1382 if (ret) {
1383 dev_err(dev, "failed to get default rng, ret = %d!\n", ret);
1384 return ret;
1385 }
1386
1387 ret = crypto_rng_get_bytes(crypto_default_rng, (u8 *)params->key,
1388 params->key_size);
1389 crypto_put_default_rng();
1390 if (ret)
1391 dev_err(dev, "failed to get rng, ret = %d!\n", ret);
1392
1393 return ret;
1394 }
1395
1396 static int hpre_ecdh_set_secret(struct crypto_kpp *tfm, const void *buf,
1397 unsigned int len)
1398 {
1399 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1400 unsigned int sz, sz_shift, curve_sz;
1401 struct device *dev = ctx->dev;
1402 char key[HPRE_ECC_MAX_KSZ];
1403 struct ecdh params;
1404 int ret;
1405
1406 if (crypto_ecdh_decode_key(buf, len, &params) < 0) {
1407 dev_err(dev, "failed to decode ecdh key!\n");
1408 return -EINVAL;
1409 }
1410
1411 /* Use stdrng to generate private key */
1412 if (!params.key || !params.key_size) {
1413 params.key = key;
1414 curve_sz = hpre_ecdh_get_curvesz(ctx->curve_id);
1415 if (!curve_sz) {
1416 dev_err(dev, "Invalid curve size!\n");
1417 return -EINVAL;
1418 }
1419
1420 params.key_size = curve_sz - 1;
1421 ret = ecdh_gen_privkey(ctx, &params);
1422 if (ret)
1423 return ret;
1424 }
1425
1426 if (hpre_key_is_zero(params.key, params.key_size)) {
1427 dev_err(dev, "Invalid hpre key!\n");
1428 return -EINVAL;
1429 }
1430
1431 hpre_ecc_clear_ctx(ctx, false, true);
1432
1433 ret = hpre_ecdh_set_param(ctx, &params);
1434 if (ret < 0) {
1435 dev_err(dev, "failed to set hpre param, ret = %d!\n", ret);
1436 return ret;
1437 }
1438
1439 sz = ctx->key_sz;
1440 sz_shift = (sz << 1) + sz - params.key_size;
1441 memcpy(ctx->ecdh.p + sz_shift, params.key, params.key_size);
1442
1443 return 0;
1444 }
1445
1446 static void hpre_ecdh_hw_data_clr_all(struct hpre_ctx *ctx,
1447 struct hpre_asym_request *req,
1448 struct scatterlist *dst,
1449 struct scatterlist *src)
1450 {
1451 struct device *dev = ctx->dev;
1452 struct hpre_sqe *sqe = &req->req;
1453 dma_addr_t dma;
1454
1455 dma = le64_to_cpu(sqe->in);
1456 if (unlikely(dma_mapping_error(dev, dma)))
1457 return;
1458
1459 if (src && req->src)
1460 dma_free_coherent(dev, ctx->key_sz << 2, req->src, dma);
1461
1462 dma = le64_to_cpu(sqe->out);
1463 if (unlikely(dma_mapping_error(dev, dma)))
1464 return;
1465
1466 if (req->dst)
1467 dma_free_coherent(dev, ctx->key_sz << 1, req->dst, dma);
1468 if (dst)
1469 dma_unmap_single(dev, dma, ctx->key_sz << 1, DMA_FROM_DEVICE);
1470 }
1471
1472 static void hpre_ecdh_cb(struct hpre_ctx *ctx, void *resp)
1473 {
1474 unsigned int curve_sz = hpre_ecdh_get_curvesz(ctx->curve_id);
1475 struct hpre_dfx *dfx = ctx->hpre->debug.dfx;
1476 struct hpre_asym_request *req = NULL;
1477 struct kpp_request *areq;
1478 u64 overtime_thrhld;
1479 char *p;
1480 int ret;
1481
1482 ret = hpre_alg_res_post_hf(ctx, resp, (void **)&req);
1483 areq = req->areq.ecdh;
1484 areq->dst_len = ctx->key_sz << 1;
1485
1486 overtime_thrhld = atomic64_read(&dfx[HPRE_OVERTIME_THRHLD].value);
1487 if (overtime_thrhld && hpre_is_bd_timeout(req, overtime_thrhld))
1488 atomic64_inc(&dfx[HPRE_OVER_THRHLD_CNT].value);
1489
1490 p = sg_virt(areq->dst);
1491 memmove(p, p + ctx->key_sz - curve_sz, curve_sz);
1492 memmove(p + curve_sz, p + areq->dst_len - curve_sz, curve_sz);
1493
1494 hpre_ecdh_hw_data_clr_all(ctx, req, areq->dst, areq->src);
1495 kpp_request_complete(areq, ret);
1496
1497 atomic64_inc(&dfx[HPRE_RECV_CNT].value);
1498 }
1499
1500 static int hpre_ecdh_msg_request_set(struct hpre_ctx *ctx,
1501 struct kpp_request *req)
1502 {
1503 struct hpre_asym_request *h_req;
1504 struct hpre_sqe *msg;
1505 int req_id;
1506 void *tmp;
1507
1508 if (req->dst_len < ctx->key_sz << 1) {
1509 req->dst_len = ctx->key_sz << 1;
1510 return -EINVAL;
1511 }
1512
1513 tmp = kpp_request_ctx(req);
1514 h_req = PTR_ALIGN(tmp, hpre_align_sz());
1515 h_req->cb = hpre_ecdh_cb;
1516 h_req->areq.ecdh = req;
1517 msg = &h_req->req;
1518 memset(msg, 0, sizeof(*msg));
1519 msg->in = cpu_to_le64(DMA_MAPPING_ERROR);
1520 msg->out = cpu_to_le64(DMA_MAPPING_ERROR);
1521 msg->key = cpu_to_le64(ctx->ecdh.dma_p);
1522
1523 msg->dw0 |= cpu_to_le32(0x1U << HPRE_SQE_DONE_SHIFT);
1524 msg->task_len1 = (ctx->key_sz >> HPRE_BITS_2_BYTES_SHIFT) - 1;
1525 h_req->ctx = ctx;
1526
1527 req_id = hpre_add_req_to_ctx(h_req);
1528 if (req_id < 0)
1529 return -EBUSY;
1530
1531 msg->tag = cpu_to_le16((u16)req_id);
1532 return 0;
1533 }
1534
1535 static int hpre_ecdh_src_data_init(struct hpre_asym_request *hpre_req,
1536 struct scatterlist *data, unsigned int len)
1537 {
1538 struct hpre_sqe *msg = &hpre_req->req;
1539 struct hpre_ctx *ctx = hpre_req->ctx;
1540 struct device *dev = ctx->dev;
1541 unsigned int tmpshift;
1542 dma_addr_t dma = 0;
1543 void *ptr;
1544 int shift;
1545
1546 /* Src_data include gx and gy. */
1547 shift = ctx->key_sz - (len >> 1);
1548 if (unlikely(shift < 0))
1549 return -EINVAL;
1550
1551 ptr = dma_alloc_coherent(dev, ctx->key_sz << 2, &dma, GFP_KERNEL);
1552 if (unlikely(!ptr))
1553 return -ENOMEM;
1554
1555 tmpshift = ctx->key_sz << 1;
1556 scatterwalk_map_and_copy(ptr + tmpshift, data, 0, len, 0);
1557 memcpy(ptr + shift, ptr + tmpshift, len >> 1);
1558 memcpy(ptr + ctx->key_sz + shift, ptr + tmpshift + (len >> 1), len >> 1);
1559
1560 hpre_req->src = ptr;
1561 msg->in = cpu_to_le64(dma);
1562 return 0;
1563 }
1564
1565 static int hpre_ecdh_dst_data_init(struct hpre_asym_request *hpre_req,
1566 struct scatterlist *data, unsigned int len)
1567 {
1568 struct hpre_sqe *msg = &hpre_req->req;
1569 struct hpre_ctx *ctx = hpre_req->ctx;
1570 struct device *dev = ctx->dev;
1571 dma_addr_t dma;
1572
1573 if (unlikely(!data || !sg_is_last(data) || len != ctx->key_sz << 1)) {
1574 dev_err(dev, "data or data length is illegal!\n");
1575 return -EINVAL;
1576 }
1577
1578 hpre_req->dst = NULL;
1579 dma = dma_map_single(dev, sg_virt(data), len, DMA_FROM_DEVICE);
1580 if (unlikely(dma_mapping_error(dev, dma))) {
1581 dev_err(dev, "dma map data err!\n");
1582 return -ENOMEM;
1583 }
1584
1585 msg->out = cpu_to_le64(dma);
1586 return 0;
1587 }
1588
1589 static int hpre_ecdh_compute_value(struct kpp_request *req)
1590 {
1591 struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
1592 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1593 struct device *dev = ctx->dev;
1594 void *tmp = kpp_request_ctx(req);
1595 struct hpre_asym_request *hpre_req = PTR_ALIGN(tmp, hpre_align_sz());
1596 struct hpre_sqe *msg = &hpre_req->req;
1597 int ret;
1598
1599 ret = hpre_ecdh_msg_request_set(ctx, req);
1600 if (unlikely(ret)) {
1601 dev_err(dev, "failed to set ecdh request, ret = %d!\n", ret);
1602 return ret;
1603 }
1604
1605 if (req->src) {
1606 ret = hpre_ecdh_src_data_init(hpre_req, req->src, req->src_len);
1607 if (unlikely(ret)) {
1608 dev_err(dev, "failed to init src data, ret = %d!\n", ret);
1609 goto clear_all;
1610 }
1611 } else {
1612 msg->in = cpu_to_le64(ctx->ecdh.dma_g);
1613 }
1614
1615 ret = hpre_ecdh_dst_data_init(hpre_req, req->dst, req->dst_len);
1616 if (unlikely(ret)) {
1617 dev_err(dev, "failed to init dst data, ret = %d!\n", ret);
1618 goto clear_all;
1619 }
1620
1621 msg->dw0 = cpu_to_le32(le32_to_cpu(msg->dw0) | HPRE_ALG_ECC_MUL);
1622 ret = hpre_send(ctx, msg);
1623 if (likely(!ret))
1624 return -EINPROGRESS;
1625
1626 clear_all:
1627 hpre_rm_req_from_ctx(hpre_req);
1628 hpre_ecdh_hw_data_clr_all(ctx, hpre_req, req->dst, req->src);
1629 return ret;
1630 }
1631
1632 static unsigned int hpre_ecdh_max_size(struct crypto_kpp *tfm)
1633 {
1634 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1635
1636 /* max size is the pub_key_size, include x and y */
1637 return ctx->key_sz << 1;
1638 }
1639
1640 static int hpre_ecdh_nist_p192_init_tfm(struct crypto_kpp *tfm)
1641 {
1642 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1643
1644 ctx->curve_id = ECC_CURVE_NIST_P192;
1645
1646 kpp_set_reqsize(tfm, sizeof(struct hpre_asym_request) + hpre_align_pd());
1647
1648 return hpre_ctx_init(ctx, HPRE_V3_ECC_ALG_TYPE);
1649 }
1650
1651 static int hpre_ecdh_nist_p256_init_tfm(struct crypto_kpp *tfm)
1652 {
1653 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1654
1655 ctx->curve_id = ECC_CURVE_NIST_P256;
1656
1657 kpp_set_reqsize(tfm, sizeof(struct hpre_asym_request) + hpre_align_pd());
1658
1659 return hpre_ctx_init(ctx, HPRE_V3_ECC_ALG_TYPE);
1660 }
1661
1662 static int hpre_ecdh_nist_p384_init_tfm(struct crypto_kpp *tfm)
1663 {
1664 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1665
1666 ctx->curve_id = ECC_CURVE_NIST_P384;
1667
1668 kpp_set_reqsize(tfm, sizeof(struct hpre_asym_request) + hpre_align_pd());
1669
1670 return hpre_ctx_init(ctx, HPRE_V3_ECC_ALG_TYPE);
1671 }
1672
1673 static void hpre_ecdh_exit_tfm(struct crypto_kpp *tfm)
1674 {
1675 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1676
1677 hpre_ecc_clear_ctx(ctx, true, true);
1678 }
1679
1680 static void hpre_curve25519_fill_curve(struct hpre_ctx *ctx, const void *buf,
1681 unsigned int len)
1682 {
1683 u8 secret[CURVE25519_KEY_SIZE] = { 0 };
1684 unsigned int sz = ctx->key_sz;
1685 const struct ecc_curve *curve;
1686 unsigned int shift = sz << 1;
1687 void *p;
1688
1689 /*
1690 * The key from 'buf' is in little-endian, we should preprocess it as
1691 * the description in rfc7748: "k[0] &= 248, k[31] &= 127, k[31] |= 64",
1692 * then convert it to big endian. Only in this way, the result can be
1693 * the same as the software curve-25519 that exists in crypto.
1694 */
1695 memcpy(secret, buf, len);
1696 curve25519_clamp_secret(secret);
1697 hpre_key_to_big_end(secret, CURVE25519_KEY_SIZE);
1698
1699 p = ctx->curve25519.p + sz - len;
1700
1701 curve = ecc_get_curve25519();
1702
1703 /* fill curve parameters */
1704 fill_curve_param(p, curve->p, len, curve->g.ndigits);
1705 fill_curve_param(p + sz, curve->a, len, curve->g.ndigits);
1706 memcpy(p + shift, secret, len);
1707 fill_curve_param(p + shift + sz, curve->g.x, len, curve->g.ndigits);
1708 memzero_explicit(secret, CURVE25519_KEY_SIZE);
1709 }
1710
1711 static int hpre_curve25519_set_param(struct hpre_ctx *ctx, const void *buf,
1712 unsigned int len)
1713 {
1714 struct device *dev = ctx->dev;
1715 unsigned int sz = ctx->key_sz;
1716 unsigned int shift = sz << 1;
1717
1718 /* p->a->k->gx */
1719 if (!ctx->curve25519.p) {
1720 ctx->curve25519.p = dma_alloc_coherent(dev, sz << 2,
1721 &ctx->curve25519.dma_p,
1722 GFP_KERNEL);
1723 if (!ctx->curve25519.p)
1724 return -ENOMEM;
1725 }
1726
1727 ctx->curve25519.g = ctx->curve25519.p + shift + sz;
1728 ctx->curve25519.dma_g = ctx->curve25519.dma_p + shift + sz;
1729
1730 hpre_curve25519_fill_curve(ctx, buf, len);
1731
1732 return 0;
1733 }
1734
1735 static int hpre_curve25519_set_secret(struct crypto_kpp *tfm, const void *buf,
1736 unsigned int len)
1737 {
1738 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1739 struct device *dev = ctx->dev;
1740 int ret = -EINVAL;
1741
1742 if (len != CURVE25519_KEY_SIZE ||
1743 !crypto_memneq(buf, curve25519_null_point, CURVE25519_KEY_SIZE)) {
1744 dev_err(dev, "key is null or key len is not 32bytes!\n");
1745 return ret;
1746 }
1747
1748 /* Free old secret if any */
1749 hpre_ecc_clear_ctx(ctx, false, false);
1750
1751 ctx->key_sz = CURVE25519_KEY_SIZE;
1752 ret = hpre_curve25519_set_param(ctx, buf, CURVE25519_KEY_SIZE);
1753 if (ret) {
1754 dev_err(dev, "failed to set curve25519 param, ret = %d!\n", ret);
1755 hpre_ecc_clear_ctx(ctx, false, false);
1756 return ret;
1757 }
1758
1759 return 0;
1760 }
1761
1762 static void hpre_curve25519_hw_data_clr_all(struct hpre_ctx *ctx,
1763 struct hpre_asym_request *req,
1764 struct scatterlist *dst,
1765 struct scatterlist *src)
1766 {
1767 struct device *dev = ctx->dev;
1768 struct hpre_sqe *sqe = &req->req;
1769 dma_addr_t dma;
1770
1771 dma = le64_to_cpu(sqe->in);
1772 if (unlikely(dma_mapping_error(dev, dma)))
1773 return;
1774
1775 if (src && req->src)
1776 dma_free_coherent(dev, ctx->key_sz, req->src, dma);
1777
1778 dma = le64_to_cpu(sqe->out);
1779 if (unlikely(dma_mapping_error(dev, dma)))
1780 return;
1781
1782 if (req->dst)
1783 dma_free_coherent(dev, ctx->key_sz, req->dst, dma);
1784 if (dst)
1785 dma_unmap_single(dev, dma, ctx->key_sz, DMA_FROM_DEVICE);
1786 }
1787
1788 static void hpre_curve25519_cb(struct hpre_ctx *ctx, void *resp)
1789 {
1790 struct hpre_dfx *dfx = ctx->hpre->debug.dfx;
1791 struct hpre_asym_request *req = NULL;
1792 struct kpp_request *areq;
1793 u64 overtime_thrhld;
1794 int ret;
1795
1796 ret = hpre_alg_res_post_hf(ctx, resp, (void **)&req);
1797 areq = req->areq.curve25519;
1798 areq->dst_len = ctx->key_sz;
1799
1800 overtime_thrhld = atomic64_read(&dfx[HPRE_OVERTIME_THRHLD].value);
1801 if (overtime_thrhld && hpre_is_bd_timeout(req, overtime_thrhld))
1802 atomic64_inc(&dfx[HPRE_OVER_THRHLD_CNT].value);
1803
1804 hpre_key_to_big_end(sg_virt(areq->dst), CURVE25519_KEY_SIZE);
1805
1806 hpre_curve25519_hw_data_clr_all(ctx, req, areq->dst, areq->src);
1807 kpp_request_complete(areq, ret);
1808
1809 atomic64_inc(&dfx[HPRE_RECV_CNT].value);
1810 }
1811
1812 static int hpre_curve25519_msg_request_set(struct hpre_ctx *ctx,
1813 struct kpp_request *req)
1814 {
1815 struct hpre_asym_request *h_req;
1816 struct hpre_sqe *msg;
1817 int req_id;
1818 void *tmp;
1819
1820 if (unlikely(req->dst_len < ctx->key_sz)) {
1821 req->dst_len = ctx->key_sz;
1822 return -EINVAL;
1823 }
1824
1825 tmp = kpp_request_ctx(req);
1826 h_req = PTR_ALIGN(tmp, hpre_align_sz());
1827 h_req->cb = hpre_curve25519_cb;
1828 h_req->areq.curve25519 = req;
1829 msg = &h_req->req;
1830 memset(msg, 0, sizeof(*msg));
1831 msg->in = cpu_to_le64(DMA_MAPPING_ERROR);
1832 msg->out = cpu_to_le64(DMA_MAPPING_ERROR);
1833 msg->key = cpu_to_le64(ctx->curve25519.dma_p);
1834
1835 msg->dw0 |= cpu_to_le32(0x1U << HPRE_SQE_DONE_SHIFT);
1836 msg->task_len1 = (ctx->key_sz >> HPRE_BITS_2_BYTES_SHIFT) - 1;
1837 h_req->ctx = ctx;
1838
1839 req_id = hpre_add_req_to_ctx(h_req);
1840 if (req_id < 0)
1841 return -EBUSY;
1842
1843 msg->tag = cpu_to_le16((u16)req_id);
1844 return 0;
1845 }
1846
1847 static void hpre_curve25519_src_modulo_p(u8 *ptr)
1848 {
1849 int i;
1850
1851 for (i = 0; i < CURVE25519_KEY_SIZE - 1; i++)
1852 ptr[i] = 0;
1853
1854 /* The modulus is ptr's last byte minus '0xed'(last byte of p) */
1855 ptr[i] -= 0xed;
1856 }
1857
1858 static int hpre_curve25519_src_init(struct hpre_asym_request *hpre_req,
1859 struct scatterlist *data, unsigned int len)
1860 {
1861 struct hpre_sqe *msg = &hpre_req->req;
1862 struct hpre_ctx *ctx = hpre_req->ctx;
1863 struct device *dev = ctx->dev;
1864 u8 p[CURVE25519_KEY_SIZE] = { 0 };
1865 const struct ecc_curve *curve;
1866 dma_addr_t dma = 0;
1867 u8 *ptr;
1868
1869 if (len != CURVE25519_KEY_SIZE) {
1870 dev_err(dev, "sourc_data len is not 32bytes, len = %u!\n", len);
1871 return -EINVAL;
1872 }
1873
1874 ptr = dma_alloc_coherent(dev, ctx->key_sz, &dma, GFP_KERNEL);
1875 if (unlikely(!ptr))
1876 return -ENOMEM;
1877
1878 scatterwalk_map_and_copy(ptr, data, 0, len, 0);
1879
1880 if (!crypto_memneq(ptr, curve25519_null_point, CURVE25519_KEY_SIZE)) {
1881 dev_err(dev, "gx is null!\n");
1882 goto err;
1883 }
1884
1885 /*
1886 * Src_data(gx) is in little-endian order, MSB in the final byte should
1887 * be masked as described in RFC7748, then transform it to big-endian
1888 * form, then hisi_hpre can use the data.
1889 */
1890 ptr[31] &= 0x7f;
1891 hpre_key_to_big_end(ptr, CURVE25519_KEY_SIZE);
1892
1893 curve = ecc_get_curve25519();
1894
1895 fill_curve_param(p, curve->p, CURVE25519_KEY_SIZE, curve->g.ndigits);
1896
1897 /*
1898 * When src_data equals (2^255 - 19) ~ (2^255 - 1), it is out of p,
1899 * we get its modulus to p, and then use it.
1900 */
1901 if (memcmp(ptr, p, ctx->key_sz) == 0) {
1902 dev_err(dev, "gx is p!\n");
1903 goto err;
1904 } else if (memcmp(ptr, p, ctx->key_sz) > 0) {
1905 hpre_curve25519_src_modulo_p(ptr);
1906 }
1907
1908 hpre_req->src = ptr;
1909 msg->in = cpu_to_le64(dma);
1910 return 0;
1911
1912 err:
1913 dma_free_coherent(dev, ctx->key_sz, ptr, dma);
1914 return -EINVAL;
1915 }
1916
1917 static int hpre_curve25519_dst_init(struct hpre_asym_request *hpre_req,
1918 struct scatterlist *data, unsigned int len)
1919 {
1920 struct hpre_sqe *msg = &hpre_req->req;
1921 struct hpre_ctx *ctx = hpre_req->ctx;
1922 struct device *dev = ctx->dev;
1923 dma_addr_t dma;
1924
1925 if (!data || !sg_is_last(data) || len != ctx->key_sz) {
1926 dev_err(dev, "data or data length is illegal!\n");
1927 return -EINVAL;
1928 }
1929
1930 hpre_req->dst = NULL;
1931 dma = dma_map_single(dev, sg_virt(data), len, DMA_FROM_DEVICE);
1932 if (unlikely(dma_mapping_error(dev, dma))) {
1933 dev_err(dev, "dma map data err!\n");
1934 return -ENOMEM;
1935 }
1936
1937 msg->out = cpu_to_le64(dma);
1938 return 0;
1939 }
1940
1941 static int hpre_curve25519_compute_value(struct kpp_request *req)
1942 {
1943 struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
1944 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1945 struct device *dev = ctx->dev;
1946 void *tmp = kpp_request_ctx(req);
1947 struct hpre_asym_request *hpre_req = PTR_ALIGN(tmp, hpre_align_sz());
1948 struct hpre_sqe *msg = &hpre_req->req;
1949 int ret;
1950
1951 ret = hpre_curve25519_msg_request_set(ctx, req);
1952 if (unlikely(ret)) {
1953 dev_err(dev, "failed to set curve25519 request, ret = %d!\n", ret);
1954 return ret;
1955 }
1956
1957 if (req->src) {
1958 ret = hpre_curve25519_src_init(hpre_req, req->src, req->src_len);
1959 if (unlikely(ret)) {
1960 dev_err(dev, "failed to init src data, ret = %d!\n",
1961 ret);
1962 goto clear_all;
1963 }
1964 } else {
1965 msg->in = cpu_to_le64(ctx->curve25519.dma_g);
1966 }
1967
1968 ret = hpre_curve25519_dst_init(hpre_req, req->dst, req->dst_len);
1969 if (unlikely(ret)) {
1970 dev_err(dev, "failed to init dst data, ret = %d!\n", ret);
1971 goto clear_all;
1972 }
1973
1974 msg->dw0 = cpu_to_le32(le32_to_cpu(msg->dw0) | HPRE_ALG_CURVE25519_MUL);
1975 ret = hpre_send(ctx, msg);
1976 if (likely(!ret))
1977 return -EINPROGRESS;
1978
1979 clear_all:
1980 hpre_rm_req_from_ctx(hpre_req);
1981 hpre_curve25519_hw_data_clr_all(ctx, hpre_req, req->dst, req->src);
1982 return ret;
1983 }
1984
1985 static unsigned int hpre_curve25519_max_size(struct crypto_kpp *tfm)
1986 {
1987 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1988
1989 return ctx->key_sz;
1990 }
1991
1992 static int hpre_curve25519_init_tfm(struct crypto_kpp *tfm)
1993 {
1994 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
1995
1996 kpp_set_reqsize(tfm, sizeof(struct hpre_asym_request) + hpre_align_pd());
1997
1998 return hpre_ctx_init(ctx, HPRE_V3_ECC_ALG_TYPE);
1999 }
2000
2001 static void hpre_curve25519_exit_tfm(struct crypto_kpp *tfm)
2002 {
2003 struct hpre_ctx *ctx = kpp_tfm_ctx(tfm);
2004
2005 hpre_ecc_clear_ctx(ctx, true, false);
2006 }
2007
2008 static struct akcipher_alg rsa = {
2009 .encrypt = hpre_rsa_enc,
2010 .decrypt = hpre_rsa_dec,
2011 .set_pub_key = hpre_rsa_setpubkey,
2012 .set_priv_key = hpre_rsa_setprivkey,
2013 .max_size = hpre_rsa_max_size,
2014 .init = hpre_rsa_init_tfm,
2015 .exit = hpre_rsa_exit_tfm,
2016 .base = {
2017 .cra_ctxsize = sizeof(struct hpre_ctx),
2018 .cra_priority = HPRE_CRYPTO_ALG_PRI,
2019 .cra_name = "rsa",
2020 .cra_driver_name = "hpre-rsa",
2021 .cra_module = THIS_MODULE,
2022 },
2023 };
2024
2025 static struct kpp_alg dh = {
2026 .set_secret = hpre_dh_set_secret,
2027 .generate_public_key = hpre_dh_compute_value,
2028 .compute_shared_secret = hpre_dh_compute_value,
2029 .max_size = hpre_dh_max_size,
2030 .init = hpre_dh_init_tfm,
2031 .exit = hpre_dh_exit_tfm,
2032 .base = {
2033 .cra_ctxsize = sizeof(struct hpre_ctx),
2034 .cra_priority = HPRE_CRYPTO_ALG_PRI,
2035 .cra_name = "dh",
2036 .cra_driver_name = "hpre-dh",
2037 .cra_module = THIS_MODULE,
2038 },
2039 };
2040
2041 static struct kpp_alg ecdh_curves[] = {
2042 {
2043 .set_secret = hpre_ecdh_set_secret,
2044 .generate_public_key = hpre_ecdh_compute_value,
2045 .compute_shared_secret = hpre_ecdh_compute_value,
2046 .max_size = hpre_ecdh_max_size,
2047 .init = hpre_ecdh_nist_p192_init_tfm,
2048 .exit = hpre_ecdh_exit_tfm,
2049 .base = {
2050 .cra_ctxsize = sizeof(struct hpre_ctx),
2051 .cra_priority = HPRE_CRYPTO_ALG_PRI,
2052 .cra_name = "ecdh-nist-p192",
2053 .cra_driver_name = "hpre-ecdh-nist-p192",
2054 .cra_module = THIS_MODULE,
2055 },
2056 }, {
2057 .set_secret = hpre_ecdh_set_secret,
2058 .generate_public_key = hpre_ecdh_compute_value,
2059 .compute_shared_secret = hpre_ecdh_compute_value,
2060 .max_size = hpre_ecdh_max_size,
2061 .init = hpre_ecdh_nist_p256_init_tfm,
2062 .exit = hpre_ecdh_exit_tfm,
2063 .base = {
2064 .cra_ctxsize = sizeof(struct hpre_ctx),
2065 .cra_priority = HPRE_CRYPTO_ALG_PRI,
2066 .cra_name = "ecdh-nist-p256",
2067 .cra_driver_name = "hpre-ecdh-nist-p256",
2068 .cra_module = THIS_MODULE,
2069 },
2070 }, {
2071 .set_secret = hpre_ecdh_set_secret,
2072 .generate_public_key = hpre_ecdh_compute_value,
2073 .compute_shared_secret = hpre_ecdh_compute_value,
2074 .max_size = hpre_ecdh_max_size,
2075 .init = hpre_ecdh_nist_p384_init_tfm,
2076 .exit = hpre_ecdh_exit_tfm,
2077 .base = {
2078 .cra_ctxsize = sizeof(struct hpre_ctx),
2079 .cra_priority = HPRE_CRYPTO_ALG_PRI,
2080 .cra_name = "ecdh-nist-p384",
2081 .cra_driver_name = "hpre-ecdh-nist-p384",
2082 .cra_module = THIS_MODULE,
2083 },
2084 }
2085 };
2086
2087 static struct kpp_alg curve25519_alg = {
2088 .set_secret = hpre_curve25519_set_secret,
2089 .generate_public_key = hpre_curve25519_compute_value,
2090 .compute_shared_secret = hpre_curve25519_compute_value,
2091 .max_size = hpre_curve25519_max_size,
2092 .init = hpre_curve25519_init_tfm,
2093 .exit = hpre_curve25519_exit_tfm,
2094 .base = {
2095 .cra_ctxsize = sizeof(struct hpre_ctx),
2096 .cra_priority = HPRE_CRYPTO_ALG_PRI,
2097 .cra_name = "curve25519",
2098 .cra_driver_name = "hpre-curve25519",
2099 .cra_module = THIS_MODULE,
2100 },
2101 };
2102
2103 static int hpre_register_rsa(struct hisi_qm *qm)
2104 {
2105 int ret;
2106
2107 if (!hpre_check_alg_support(qm, HPRE_DRV_RSA_MASK_CAP))
2108 return 0;
2109
2110 rsa.base.cra_flags = 0;
2111 ret = crypto_register_akcipher(&rsa);
2112 if (ret)
2113 dev_err(&qm->pdev->dev, "failed to register rsa (%d)!\n", ret);
2114
2115 return ret;
2116 }
2117
2118 static void hpre_unregister_rsa(struct hisi_qm *qm)
2119 {
2120 if (!hpre_check_alg_support(qm, HPRE_DRV_RSA_MASK_CAP))
2121 return;
2122
2123 crypto_unregister_akcipher(&rsa);
2124 }
2125
2126 static int hpre_register_dh(struct hisi_qm *qm)
2127 {
2128 int ret;
2129
2130 if (!hpre_check_alg_support(qm, HPRE_DRV_DH_MASK_CAP))
2131 return 0;
2132
2133 ret = crypto_register_kpp(&dh);
2134 if (ret)
2135 dev_err(&qm->pdev->dev, "failed to register dh (%d)!\n", ret);
2136
2137 return ret;
2138 }
2139
2140 static void hpre_unregister_dh(struct hisi_qm *qm)
2141 {
2142 if (!hpre_check_alg_support(qm, HPRE_DRV_DH_MASK_CAP))
2143 return;
2144
2145 crypto_unregister_kpp(&dh);
2146 }
2147
2148 static int hpre_register_ecdh(struct hisi_qm *qm)
2149 {
2150 int ret, i;
2151
2152 if (!hpre_check_alg_support(qm, HPRE_DRV_ECDH_MASK_CAP))
2153 return 0;
2154
2155 for (i = 0; i < ARRAY_SIZE(ecdh_curves); i++) {
2156 ret = crypto_register_kpp(&ecdh_curves[i]);
2157 if (ret) {
2158 dev_err(&qm->pdev->dev, "failed to register %s (%d)!\n",
2159 ecdh_curves[i].base.cra_name, ret);
2160 goto unreg_kpp;
2161 }
2162 }
2163
2164 return 0;
2165
2166 unreg_kpp:
2167 for (--i; i >= 0; --i)
2168 crypto_unregister_kpp(&ecdh_curves[i]);
2169
2170 return ret;
2171 }
2172
2173 static void hpre_unregister_ecdh(struct hisi_qm *qm)
2174 {
2175 int i;
2176
2177 if (!hpre_check_alg_support(qm, HPRE_DRV_ECDH_MASK_CAP))
2178 return;
2179
2180 for (i = ARRAY_SIZE(ecdh_curves) - 1; i >= 0; --i)
2181 crypto_unregister_kpp(&ecdh_curves[i]);
2182 }
2183
2184 static int hpre_register_x25519(struct hisi_qm *qm)
2185 {
2186 int ret;
2187
2188 if (!hpre_check_alg_support(qm, HPRE_DRV_X25519_MASK_CAP))
2189 return 0;
2190
2191 ret = crypto_register_kpp(&curve25519_alg);
2192 if (ret)
2193 dev_err(&qm->pdev->dev, "failed to register x25519 (%d)!\n", ret);
2194
2195 return ret;
2196 }
2197
2198 static void hpre_unregister_x25519(struct hisi_qm *qm)
2199 {
2200 if (!hpre_check_alg_support(qm, HPRE_DRV_X25519_MASK_CAP))
2201 return;
2202
2203 crypto_unregister_kpp(&curve25519_alg);
2204 }
2205
2206 int hpre_algs_register(struct hisi_qm *qm)
2207 {
2208 int ret = 0;
2209
2210 mutex_lock(&hpre_algs_lock);
2211 if (hpre_available_devs) {
2212 hpre_available_devs++;
2213 goto unlock;
2214 }
2215
2216 ret = hpre_register_rsa(qm);
2217 if (ret)
2218 goto unlock;
2219
2220 ret = hpre_register_dh(qm);
2221 if (ret)
2222 goto unreg_rsa;
2223
2224 ret = hpre_register_ecdh(qm);
2225 if (ret)
2226 goto unreg_dh;
2227
2228 ret = hpre_register_x25519(qm);
2229 if (ret)
2230 goto unreg_ecdh;
2231
2232 hpre_available_devs++;
2233 mutex_unlock(&hpre_algs_lock);
2234
2235 return ret;
2236
2237 unreg_ecdh:
2238 hpre_unregister_ecdh(qm);
2239 unreg_dh:
2240 hpre_unregister_dh(qm);
2241 unreg_rsa:
2242 hpre_unregister_rsa(qm);
2243 unlock:
2244 mutex_unlock(&hpre_algs_lock);
2245 return ret;
2246 }
2247
2248 void hpre_algs_unregister(struct hisi_qm *qm)
2249 {
2250 mutex_lock(&hpre_algs_lock);
2251 if (--hpre_available_devs)
2252 goto unlock;
2253
2254 hpre_unregister_x25519(qm);
2255 hpre_unregister_ecdh(qm);
2256 hpre_unregister_dh(qm);
2257 hpre_unregister_rsa(qm);
2258
2259 unlock:
2260 mutex_unlock(&hpre_algs_lock);
2261 }
Kernel DRM miscellaneous fixes and cross-tree changes