1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * StarFive Public Key Algo acceleration driver
4 *
5 * Copyright (c) 2022 StarFive Technology
6 */
7
8 #include <linux/crypto.h>
9 #include <linux/delay.h>
10 #include <linux/device.h>
11 #include <linux/dma-direct.h>
12 #include <linux/interrupt.h>
13 #include <linux/iopoll.h>
14 #include <linux/io.h>
15 #include <linux/mod_devicetable.h>
16 #include <crypto/akcipher.h>
17 #include <crypto/algapi.h>
18 #include <crypto/internal/akcipher.h>
19 #include <crypto/internal/rsa.h>
20 #include <crypto/scatterwalk.h>
21
22 #include "jh7110-cryp.h"
23
24 #define STARFIVE_PKA_REGS_OFFSET 0x400
25 #define STARFIVE_PKA_CACR_OFFSET (STARFIVE_PKA_REGS_OFFSET + 0x0)
26 #define STARFIVE_PKA_CASR_OFFSET (STARFIVE_PKA_REGS_OFFSET + 0x4)
27 #define STARFIVE_PKA_CAAR_OFFSET (STARFIVE_PKA_REGS_OFFSET + 0x8)
28 #define STARFIVE_PKA_CAER_OFFSET (STARFIVE_PKA_REGS_OFFSET + 0x108)
29 #define STARFIVE_PKA_CANR_OFFSET (STARFIVE_PKA_REGS_OFFSET + 0x208)
30
31 // R^2 mod N and N0'
32 #define CRYPTO_CMD_PRE 0x0
33 // A * R mod N ==> A
34 #define CRYPTO_CMD_ARN 0x5
35 // A * E * R mod N ==> A
36 #define CRYPTO_CMD_AERN 0x6
37 // A * A * R mod N ==> A
38 #define CRYPTO_CMD_AARN 0x7
39
40 #define STARFIVE_RSA_RESET 0x2
41
starfive_pka_wait_done(struct starfive_cryp_ctx * ctx)42 static inline int starfive_pka_wait_done(struct starfive_cryp_ctx *ctx)
43 {
44 struct starfive_cryp_dev *cryp = ctx->cryp;
45
46 return wait_for_completion_timeout(&cryp->pka_done,
47 usecs_to_jiffies(100000));
48 }
49
starfive_pka_irq_mask_clear(struct starfive_cryp_ctx * ctx)50 static inline void starfive_pka_irq_mask_clear(struct starfive_cryp_ctx *ctx)
51 {
52 struct starfive_cryp_dev *cryp = ctx->cryp;
53 u32 stat;
54
55 stat = readl(cryp->base + STARFIVE_IE_MASK_OFFSET);
56 stat &= ~STARFIVE_IE_MASK_PKA_DONE;
57 writel(stat, cryp->base + STARFIVE_IE_MASK_OFFSET);
58
59 reinit_completion(&cryp->pka_done);
60 }
61
starfive_rsa_free_key(struct starfive_rsa_key * key)62 static void starfive_rsa_free_key(struct starfive_rsa_key *key)
63 {
64 if (key->d)
65 kfree_sensitive(key->d);
66 if (key->e)
67 kfree_sensitive(key->e);
68 if (key->n)
69 kfree_sensitive(key->n);
70 memset(key, 0, sizeof(*key));
71 }
72
starfive_rsa_get_nbit(u8 * pa,u32 snum,int key_sz)73 static unsigned int starfive_rsa_get_nbit(u8 *pa, u32 snum, int key_sz)
74 {
75 u32 i;
76 u8 value;
77
78 i = snum >> 3;
79
80 value = pa[key_sz - i - 1];
81 value >>= snum & 0x7;
82 value &= 0x1;
83
84 return value;
85 }
86
starfive_rsa_montgomery_form(struct starfive_cryp_ctx * ctx,u32 * out,u32 * in,u8 mont,u32 * mod,int bit_len)87 static int starfive_rsa_montgomery_form(struct starfive_cryp_ctx *ctx,
88 u32 *out, u32 *in, u8 mont,
89 u32 *mod, int bit_len)
90 {
91 struct starfive_cryp_dev *cryp = ctx->cryp;
92 struct starfive_cryp_request_ctx *rctx = ctx->rctx;
93 int count = (ALIGN(rctx->total, 4) / 4) - 1;
94 int loop;
95 u32 temp;
96 u8 opsize;
97
98 opsize = (bit_len - 1) >> 5;
99 rctx->csr.pka.v = 0;
100
101 writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
102
103 for (loop = 0; loop <= opsize; loop++)
104 writel(mod[opsize - loop], cryp->base + STARFIVE_PKA_CANR_OFFSET + loop * 4);
105
106 if (mont) {
107 rctx->csr.pka.v = 0;
108 rctx->csr.pka.cln_done = 1;
109 rctx->csr.pka.opsize = opsize;
110 rctx->csr.pka.exposize = opsize;
111 rctx->csr.pka.cmd = CRYPTO_CMD_PRE;
112 rctx->csr.pka.start = 1;
113 rctx->csr.pka.not_r2 = 1;
114 rctx->csr.pka.ie = 1;
115
116 starfive_pka_irq_mask_clear(ctx);
117 writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
118
119 if (!starfive_pka_wait_done(ctx))
120 return -ETIMEDOUT;
121
122 for (loop = 0; loop <= opsize; loop++)
123 writel(in[opsize - loop], cryp->base + STARFIVE_PKA_CAAR_OFFSET + loop * 4);
124
125 writel(0x1000000, cryp->base + STARFIVE_PKA_CAER_OFFSET);
126
127 for (loop = 1; loop <= opsize; loop++)
128 writel(0, cryp->base + STARFIVE_PKA_CAER_OFFSET + loop * 4);
129
130 rctx->csr.pka.v = 0;
131 rctx->csr.pka.cln_done = 1;
132 rctx->csr.pka.opsize = opsize;
133 rctx->csr.pka.exposize = opsize;
134 rctx->csr.pka.cmd = CRYPTO_CMD_AERN;
135 rctx->csr.pka.start = 1;
136 rctx->csr.pka.ie = 1;
137
138 starfive_pka_irq_mask_clear(ctx);
139 writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
140
141 if (!starfive_pka_wait_done(ctx))
142 return -ETIMEDOUT;
143 } else {
144 rctx->csr.pka.v = 0;
145 rctx->csr.pka.cln_done = 1;
146 rctx->csr.pka.opsize = opsize;
147 rctx->csr.pka.exposize = opsize;
148 rctx->csr.pka.cmd = CRYPTO_CMD_PRE;
149 rctx->csr.pka.start = 1;
150 rctx->csr.pka.pre_expf = 1;
151 rctx->csr.pka.ie = 1;
152
153 starfive_pka_irq_mask_clear(ctx);
154 writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
155
156 if (!starfive_pka_wait_done(ctx))
157 return -ETIMEDOUT;
158
159 for (loop = 0; loop <= count; loop++)
160 writel(in[count - loop], cryp->base + STARFIVE_PKA_CAER_OFFSET + loop * 4);
161
162 /*pad with 0 up to opsize*/
163 for (loop = count + 1; loop <= opsize; loop++)
164 writel(0, cryp->base + STARFIVE_PKA_CAER_OFFSET + loop * 4);
165
166 rctx->csr.pka.v = 0;
167 rctx->csr.pka.cln_done = 1;
168 rctx->csr.pka.opsize = opsize;
169 rctx->csr.pka.exposize = opsize;
170 rctx->csr.pka.cmd = CRYPTO_CMD_ARN;
171 rctx->csr.pka.start = 1;
172 rctx->csr.pka.ie = 1;
173
174 starfive_pka_irq_mask_clear(ctx);
175 writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
176
177 if (!starfive_pka_wait_done(ctx))
178 return -ETIMEDOUT;
179 }
180
181 for (loop = 0; loop <= opsize; loop++) {
182 temp = readl(cryp->base + STARFIVE_PKA_CAAR_OFFSET + 0x4 * loop);
183 out[opsize - loop] = temp;
184 }
185
186 return 0;
187 }
188
starfive_rsa_cpu_start(struct starfive_cryp_ctx * ctx,u32 * result,u8 * de,u32 * n,int key_sz)189 static int starfive_rsa_cpu_start(struct starfive_cryp_ctx *ctx, u32 *result,
190 u8 *de, u32 *n, int key_sz)
191 {
192 struct starfive_cryp_dev *cryp = ctx->cryp;
193 struct starfive_cryp_request_ctx *rctx = ctx->rctx;
194 struct starfive_rsa_key *key = &ctx->rsa_key;
195 u32 temp;
196 int ret = 0;
197 int opsize, mlen, loop;
198 unsigned int *mta;
199
200 opsize = (key_sz - 1) >> 2;
201
202 mta = kmalloc(key_sz, GFP_KERNEL);
203 if (!mta)
204 return -ENOMEM;
205
206 ret = starfive_rsa_montgomery_form(ctx, mta, (u32 *)rctx->rsa_data,
207 0, n, key_sz << 3);
208 if (ret) {
209 dev_err_probe(cryp->dev, ret, "Conversion to Montgomery failed");
210 goto rsa_err;
211 }
212
213 for (loop = 0; loop <= opsize; loop++)
214 writel(mta[opsize - loop],
215 cryp->base + STARFIVE_PKA_CAER_OFFSET + loop * 4);
216
217 for (loop = key->bitlen - 1; loop > 0; loop--) {
218 mlen = starfive_rsa_get_nbit(de, loop - 1, key_sz);
219
220 rctx->csr.pka.v = 0;
221 rctx->csr.pka.cln_done = 1;
222 rctx->csr.pka.opsize = opsize;
223 rctx->csr.pka.exposize = opsize;
224 rctx->csr.pka.cmd = CRYPTO_CMD_AARN;
225 rctx->csr.pka.start = 1;
226 rctx->csr.pka.ie = 1;
227
228 starfive_pka_irq_mask_clear(ctx);
229 writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
230
231 ret = -ETIMEDOUT;
232 if (!starfive_pka_wait_done(ctx))
233 goto rsa_err;
234
235 if (mlen) {
236 rctx->csr.pka.v = 0;
237 rctx->csr.pka.cln_done = 1;
238 rctx->csr.pka.opsize = opsize;
239 rctx->csr.pka.exposize = opsize;
240 rctx->csr.pka.cmd = CRYPTO_CMD_AERN;
241 rctx->csr.pka.start = 1;
242 rctx->csr.pka.ie = 1;
243
244 starfive_pka_irq_mask_clear(ctx);
245 writel(rctx->csr.pka.v, cryp->base + STARFIVE_PKA_CACR_OFFSET);
246
247 if (!starfive_pka_wait_done(ctx))
248 goto rsa_err;
249 }
250 }
251
252 for (loop = 0; loop <= opsize; loop++) {
253 temp = readl(cryp->base + STARFIVE_PKA_CAAR_OFFSET + 0x4 * loop);
254 result[opsize - loop] = temp;
255 }
256
257 ret = starfive_rsa_montgomery_form(ctx, result, result, 1, n, key_sz << 3);
258 if (ret)
259 dev_err_probe(cryp->dev, ret, "Conversion from Montgomery failed");
260 rsa_err:
261 kfree(mta);
262 return ret;
263 }
264
starfive_rsa_start(struct starfive_cryp_ctx * ctx,u8 * result,u8 * de,u8 * n,int key_sz)265 static int starfive_rsa_start(struct starfive_cryp_ctx *ctx, u8 *result,
266 u8 *de, u8 *n, int key_sz)
267 {
268 return starfive_rsa_cpu_start(ctx, (u32 *)result, de, (u32 *)n, key_sz);
269 }
270
starfive_rsa_enc_core(struct starfive_cryp_ctx * ctx,int enc)271 static int starfive_rsa_enc_core(struct starfive_cryp_ctx *ctx, int enc)
272 {
273 struct starfive_cryp_dev *cryp = ctx->cryp;
274 struct starfive_cryp_request_ctx *rctx = ctx->rctx;
275 struct starfive_rsa_key *key = &ctx->rsa_key;
276 int ret = 0, shift = 0;
277
278 writel(STARFIVE_RSA_RESET, cryp->base + STARFIVE_PKA_CACR_OFFSET);
279
280 if (!IS_ALIGNED(rctx->total, sizeof(u32))) {
281 shift = sizeof(u32) - (rctx->total & 0x3);
282 memset(rctx->rsa_data, 0, shift);
283 }
284
285 rctx->total = sg_copy_to_buffer(rctx->in_sg, sg_nents(rctx->in_sg),
286 rctx->rsa_data + shift, rctx->total);
287
288 if (enc) {
289 key->bitlen = key->e_bitlen;
290 ret = starfive_rsa_start(ctx, rctx->rsa_data, key->e,
291 key->n, key->key_sz);
292 } else {
293 key->bitlen = key->d_bitlen;
294 ret = starfive_rsa_start(ctx, rctx->rsa_data, key->d,
295 key->n, key->key_sz);
296 }
297
298 if (ret)
299 goto err_rsa_crypt;
300
301 sg_copy_buffer(rctx->out_sg, sg_nents(rctx->out_sg),
302 rctx->rsa_data, key->key_sz, 0, 0);
303
304 err_rsa_crypt:
305 writel(STARFIVE_RSA_RESET, cryp->base + STARFIVE_PKA_CACR_OFFSET);
306 kfree(rctx->rsa_data);
307 return ret;
308 }
309
starfive_rsa_enc(struct akcipher_request * req)310 static int starfive_rsa_enc(struct akcipher_request *req)
311 {
312 struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
313 struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
314 struct starfive_cryp_dev *cryp = ctx->cryp;
315 struct starfive_rsa_key *key = &ctx->rsa_key;
316 struct starfive_cryp_request_ctx *rctx = akcipher_request_ctx(req);
317 int ret;
318
319 if (!key->key_sz) {
320 akcipher_request_set_tfm(req, ctx->akcipher_fbk);
321 ret = crypto_akcipher_encrypt(req);
322 akcipher_request_set_tfm(req, tfm);
323 return ret;
324 }
325
326 if (unlikely(!key->n || !key->e))
327 return -EINVAL;
328
329 if (req->dst_len < key->key_sz)
330 return dev_err_probe(cryp->dev, -EOVERFLOW,
331 "Output buffer length less than parameter n\n");
332
333 rctx->in_sg = req->src;
334 rctx->out_sg = req->dst;
335 rctx->total = req->src_len;
336 ctx->rctx = rctx;
337
338 return starfive_rsa_enc_core(ctx, 1);
339 }
340
starfive_rsa_dec(struct akcipher_request * req)341 static int starfive_rsa_dec(struct akcipher_request *req)
342 {
343 struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
344 struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
345 struct starfive_cryp_dev *cryp = ctx->cryp;
346 struct starfive_rsa_key *key = &ctx->rsa_key;
347 struct starfive_cryp_request_ctx *rctx = akcipher_request_ctx(req);
348 int ret;
349
350 if (!key->key_sz) {
351 akcipher_request_set_tfm(req, ctx->akcipher_fbk);
352 ret = crypto_akcipher_decrypt(req);
353 akcipher_request_set_tfm(req, tfm);
354 return ret;
355 }
356
357 if (unlikely(!key->n || !key->d))
358 return -EINVAL;
359
360 if (req->dst_len < key->key_sz)
361 return dev_err_probe(cryp->dev, -EOVERFLOW,
362 "Output buffer length less than parameter n\n");
363
364 rctx->in_sg = req->src;
365 rctx->out_sg = req->dst;
366 ctx->rctx = rctx;
367 rctx->total = req->src_len;
368
369 return starfive_rsa_enc_core(ctx, 0);
370 }
371
starfive_rsa_set_n(struct starfive_rsa_key * rsa_key,const char * value,size_t vlen)372 static int starfive_rsa_set_n(struct starfive_rsa_key *rsa_key,
373 const char *value, size_t vlen)
374 {
375 const char *ptr = value;
376 unsigned int bitslen;
377 int ret;
378
379 while (!*ptr && vlen) {
380 ptr++;
381 vlen--;
382 }
383 rsa_key->key_sz = vlen;
384 bitslen = rsa_key->key_sz << 3;
385
386 /* check valid key size */
387 if (bitslen & 0x1f)
388 return -EINVAL;
389
390 ret = -ENOMEM;
391 rsa_key->n = kmemdup(ptr, rsa_key->key_sz, GFP_KERNEL);
392 if (!rsa_key->n)
393 goto err;
394
395 return 0;
396 err:
397 rsa_key->key_sz = 0;
398 rsa_key->n = NULL;
399 starfive_rsa_free_key(rsa_key);
400 return ret;
401 }
402
starfive_rsa_set_e(struct starfive_rsa_key * rsa_key,const char * value,size_t vlen)403 static int starfive_rsa_set_e(struct starfive_rsa_key *rsa_key,
404 const char *value, size_t vlen)
405 {
406 const char *ptr = value;
407 unsigned char pt;
408 int loop;
409
410 while (!*ptr && vlen) {
411 ptr++;
412 vlen--;
413 }
414 pt = *ptr;
415
416 if (!rsa_key->key_sz || !vlen || vlen > rsa_key->key_sz) {
417 rsa_key->e = NULL;
418 return -EINVAL;
419 }
420
421 rsa_key->e = kzalloc(rsa_key->key_sz, GFP_KERNEL);
422 if (!rsa_key->e)
423 return -ENOMEM;
424
425 for (loop = 8; loop > 0; loop--) {
426 if (pt >> (loop - 1))
427 break;
428 }
429
430 rsa_key->e_bitlen = (vlen - 1) * 8 + loop;
431
432 memcpy(rsa_key->e + (rsa_key->key_sz - vlen), ptr, vlen);
433
434 return 0;
435 }
436
starfive_rsa_set_d(struct starfive_rsa_key * rsa_key,const char * value,size_t vlen)437 static int starfive_rsa_set_d(struct starfive_rsa_key *rsa_key,
438 const char *value, size_t vlen)
439 {
440 const char *ptr = value;
441 unsigned char pt;
442 int loop;
443 int ret;
444
445 while (!*ptr && vlen) {
446 ptr++;
447 vlen--;
448 }
449 pt = *ptr;
450
451 ret = -EINVAL;
452 if (!rsa_key->key_sz || !vlen || vlen > rsa_key->key_sz)
453 goto err;
454
455 ret = -ENOMEM;
456 rsa_key->d = kzalloc(rsa_key->key_sz, GFP_KERNEL);
457 if (!rsa_key->d)
458 goto err;
459
460 for (loop = 8; loop > 0; loop--) {
461 if (pt >> (loop - 1))
462 break;
463 }
464
465 rsa_key->d_bitlen = (vlen - 1) * 8 + loop;
466
467 memcpy(rsa_key->d + (rsa_key->key_sz - vlen), ptr, vlen);
468
469 return 0;
470 err:
471 rsa_key->d = NULL;
472 return ret;
473 }
474
starfive_rsa_setkey(struct crypto_akcipher * tfm,const void * key,unsigned int keylen,bool private)475 static int starfive_rsa_setkey(struct crypto_akcipher *tfm, const void *key,
476 unsigned int keylen, bool private)
477 {
478 struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
479 struct rsa_key raw_key = {NULL};
480 struct starfive_rsa_key *rsa_key = &ctx->rsa_key;
481 int ret;
482
483 if (private)
484 ret = rsa_parse_priv_key(&raw_key, key, keylen);
485 else
486 ret = rsa_parse_pub_key(&raw_key, key, keylen);
487 if (ret < 0)
488 goto err;
489
490 starfive_rsa_free_key(rsa_key);
491
492 /* Use fallback for mod > 256 + 1 byte prefix */
493 if (raw_key.n_sz > STARFIVE_RSA_MAX_KEYSZ + 1)
494 return 0;
495
496 ret = starfive_rsa_set_n(rsa_key, raw_key.n, raw_key.n_sz);
497 if (ret)
498 return ret;
499
500 ret = starfive_rsa_set_e(rsa_key, raw_key.e, raw_key.e_sz);
501 if (ret)
502 goto err;
503
504 if (private) {
505 ret = starfive_rsa_set_d(rsa_key, raw_key.d, raw_key.d_sz);
506 if (ret)
507 goto err;
508 }
509
510 if (!rsa_key->n || !rsa_key->e) {
511 ret = -EINVAL;
512 goto err;
513 }
514
515 if (private && !rsa_key->d) {
516 ret = -EINVAL;
517 goto err;
518 }
519
520 return 0;
521 err:
522 starfive_rsa_free_key(rsa_key);
523 return ret;
524 }
525
starfive_rsa_set_pub_key(struct crypto_akcipher * tfm,const void * key,unsigned int keylen)526 static int starfive_rsa_set_pub_key(struct crypto_akcipher *tfm, const void *key,
527 unsigned int keylen)
528 {
529 struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
530 int ret;
531
532 ret = crypto_akcipher_set_pub_key(ctx->akcipher_fbk, key, keylen);
533 if (ret)
534 return ret;
535
536 return starfive_rsa_setkey(tfm, key, keylen, false);
537 }
538
starfive_rsa_set_priv_key(struct crypto_akcipher * tfm,const void * key,unsigned int keylen)539 static int starfive_rsa_set_priv_key(struct crypto_akcipher *tfm, const void *key,
540 unsigned int keylen)
541 {
542 struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
543 int ret;
544
545 ret = crypto_akcipher_set_priv_key(ctx->akcipher_fbk, key, keylen);
546 if (ret)
547 return ret;
548
549 return starfive_rsa_setkey(tfm, key, keylen, true);
550 }
551
starfive_rsa_max_size(struct crypto_akcipher * tfm)552 static unsigned int starfive_rsa_max_size(struct crypto_akcipher *tfm)
553 {
554 struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
555
556 if (ctx->rsa_key.key_sz)
557 return ctx->rsa_key.key_sz;
558
559 return crypto_akcipher_maxsize(ctx->akcipher_fbk);
560 }
561
starfive_rsa_init_tfm(struct crypto_akcipher * tfm)562 static int starfive_rsa_init_tfm(struct crypto_akcipher *tfm)
563 {
564 struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
565
566 ctx->akcipher_fbk = crypto_alloc_akcipher("rsa-generic", 0, 0);
567 if (IS_ERR(ctx->akcipher_fbk))
568 return PTR_ERR(ctx->akcipher_fbk);
569
570 ctx->cryp = starfive_cryp_find_dev(ctx);
571 if (!ctx->cryp) {
572 crypto_free_akcipher(ctx->akcipher_fbk);
573 return -ENODEV;
574 }
575
576 akcipher_set_reqsize(tfm, sizeof(struct starfive_cryp_request_ctx) +
577 sizeof(struct crypto_akcipher) + 32);
578
579 return 0;
580 }
581
starfive_rsa_exit_tfm(struct crypto_akcipher * tfm)582 static void starfive_rsa_exit_tfm(struct crypto_akcipher *tfm)
583 {
584 struct starfive_cryp_ctx *ctx = akcipher_tfm_ctx(tfm);
585 struct starfive_rsa_key *key = (struct starfive_rsa_key *)&ctx->rsa_key;
586
587 crypto_free_akcipher(ctx->akcipher_fbk);
588 starfive_rsa_free_key(key);
589 }
590
591 static struct akcipher_alg starfive_rsa = {
592 .encrypt = starfive_rsa_enc,
593 .decrypt = starfive_rsa_dec,
594 .sign = starfive_rsa_dec,
595 .verify = starfive_rsa_enc,
596 .set_pub_key = starfive_rsa_set_pub_key,
597 .set_priv_key = starfive_rsa_set_priv_key,
598 .max_size = starfive_rsa_max_size,
599 .init = starfive_rsa_init_tfm,
600 .exit = starfive_rsa_exit_tfm,
601 .base = {
602 .cra_name = "rsa",
603 .cra_driver_name = "starfive-rsa",
604 .cra_flags = CRYPTO_ALG_TYPE_AKCIPHER |
605 CRYPTO_ALG_NEED_FALLBACK,
606 .cra_priority = 3000,
607 .cra_module = THIS_MODULE,
608 .cra_ctxsize = sizeof(struct starfive_cryp_ctx),
609 },
610 };
611
starfive_rsa_register_algs(void)612 int starfive_rsa_register_algs(void)
613 {
614 return crypto_register_akcipher(&starfive_rsa);
615 }
616
starfive_rsa_unregister_algs(void)617 void starfive_rsa_unregister_algs(void)
618 {
619 crypto_unregister_akcipher(&starfive_rsa);
620 }
621