?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 5.1.15
[linux/fpc-iii.git] / drivers / crypto / mediatek / mtk-sha.c
blob5f4f845adbb8ec1ea08e8d5467815bc434d5dfa9
1 /*
2 * Cryptographic API.
3 *
4 * Driver for EIP97 SHA1/SHA2(HMAC) acceleration.
5 *
6 * Copyright (c) 2016 Ryder Lee <ryder.lee@mediatek.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 *
12 * Some ideas are from atmel-sha.c and omap-sham.c drivers.
13 */
14
15 #include <crypto/hmac.h>
16 #include <crypto/sha.h>
17 #include "mtk-platform.h"
18
19 #define SHA_ALIGN_MSK (sizeof(u32) - 1)
20 #define SHA_QUEUE_SIZE 512
21 #define SHA_BUF_SIZE ((u32)PAGE_SIZE)
22
23 #define SHA_OP_UPDATE 1
24 #define SHA_OP_FINAL 2
25
26 #define SHA_DATA_LEN_MSK cpu_to_le32(GENMASK(16, 0))
27 #define SHA_MAX_DIGEST_BUF_SIZE 32
28
29 /* SHA command token */
30 #define SHA_CT_SIZE 5
31 #define SHA_CT_CTRL_HDR cpu_to_le32(0x02220000)
32 #define SHA_CMD0 cpu_to_le32(0x03020000)
33 #define SHA_CMD1 cpu_to_le32(0x21060000)
34 #define SHA_CMD2 cpu_to_le32(0xe0e63802)
35
36 /* SHA transform information */
37 #define SHA_TFM_HASH cpu_to_le32(0x2 << 0)
38 #define SHA_TFM_SIZE(x) cpu_to_le32((x) << 8)
39 #define SHA_TFM_START cpu_to_le32(0x1 << 4)
40 #define SHA_TFM_CONTINUE cpu_to_le32(0x1 << 5)
41 #define SHA_TFM_HASH_STORE cpu_to_le32(0x1 << 19)
42 #define SHA_TFM_SHA1 cpu_to_le32(0x2 << 23)
43 #define SHA_TFM_SHA256 cpu_to_le32(0x3 << 23)
44 #define SHA_TFM_SHA224 cpu_to_le32(0x4 << 23)
45 #define SHA_TFM_SHA512 cpu_to_le32(0x5 << 23)
46 #define SHA_TFM_SHA384 cpu_to_le32(0x6 << 23)
47 #define SHA_TFM_DIGEST(x) cpu_to_le32(((x) & GENMASK(3, 0)) << 24)
48
49 /* SHA flags */
50 #define SHA_FLAGS_BUSY BIT(0)
51 #define SHA_FLAGS_FINAL BIT(1)
52 #define SHA_FLAGS_FINUP BIT(2)
53 #define SHA_FLAGS_SG BIT(3)
54 #define SHA_FLAGS_ALGO_MSK GENMASK(8, 4)
55 #define SHA_FLAGS_SHA1 BIT(4)
56 #define SHA_FLAGS_SHA224 BIT(5)
57 #define SHA_FLAGS_SHA256 BIT(6)
58 #define SHA_FLAGS_SHA384 BIT(7)
59 #define SHA_FLAGS_SHA512 BIT(8)
60 #define SHA_FLAGS_HMAC BIT(9)
61 #define SHA_FLAGS_PAD BIT(10)
62
63 /**
64 * mtk_sha_info - hardware information of AES
65 * @cmd: command token, hardware instruction
66 * @tfm: transform state of cipher algorithm.
67 * @state: contains keys and initial vectors.
68 *
69 */
70 struct mtk_sha_info {
71 __le32 ctrl[2];
72 __le32 cmd[3];
73 __le32 tfm[2];
74 __le32 digest[SHA_MAX_DIGEST_BUF_SIZE];
75 };
76
77 struct mtk_sha_reqctx {
78 struct mtk_sha_info info;
79 unsigned long flags;
80 unsigned long op;
81
82 u64 digcnt;
83 size_t bufcnt;
84 dma_addr_t dma_addr;
85
86 __le32 ct_hdr;
87 u32 ct_size;
88 dma_addr_t ct_dma;
89 dma_addr_t tfm_dma;
90
91 /* Walk state */
92 struct scatterlist *sg;
93 u32 offset; /* Offset in current sg */
94 u32 total; /* Total request */
95 size_t ds;
96 size_t bs;
97
98 u8 *buffer;
99 };
100
101 struct mtk_sha_hmac_ctx {
102 struct crypto_shash *shash;
103 u8 ipad[SHA512_BLOCK_SIZE] __aligned(sizeof(u32));
104 u8 opad[SHA512_BLOCK_SIZE] __aligned(sizeof(u32));
105 };
106
107 struct mtk_sha_ctx {
108 struct mtk_cryp *cryp;
109 unsigned long flags;
110 u8 id;
111 u8 buf[SHA_BUF_SIZE] __aligned(sizeof(u32));
112
113 struct mtk_sha_hmac_ctx base[0];
114 };
115
116 struct mtk_sha_drv {
117 struct list_head dev_list;
118 /* Device list lock */
119 spinlock_t lock;
120 };
121
122 static struct mtk_sha_drv mtk_sha = {
123 .dev_list = LIST_HEAD_INIT(mtk_sha.dev_list),
124 .lock = __SPIN_LOCK_UNLOCKED(mtk_sha.lock),
125 };
126
127 static int mtk_sha_handle_queue(struct mtk_cryp *cryp, u8 id,
128 struct ahash_request *req);
129
130 static inline u32 mtk_sha_read(struct mtk_cryp *cryp, u32 offset)
131 {
132 return readl_relaxed(cryp->base + offset);
133 }
134
135 static inline void mtk_sha_write(struct mtk_cryp *cryp,
136 u32 offset, u32 value)
137 {
138 writel_relaxed(value, cryp->base + offset);
139 }
140
141 static inline void mtk_sha_ring_shift(struct mtk_ring *ring,
142 struct mtk_desc **cmd_curr,
143 struct mtk_desc **res_curr,
144 int *count)
145 {
146 *cmd_curr = ring->cmd_next++;
147 *res_curr = ring->res_next++;
148 (*count)++;
149
150 if (ring->cmd_next == ring->cmd_base + MTK_DESC_NUM) {
151 ring->cmd_next = ring->cmd_base;
152 ring->res_next = ring->res_base;
153 }
154 }
155
156 static struct mtk_cryp *mtk_sha_find_dev(struct mtk_sha_ctx *tctx)
157 {
158 struct mtk_cryp *cryp = NULL;
159 struct mtk_cryp *tmp;
160
161 spin_lock_bh(&mtk_sha.lock);
162 if (!tctx->cryp) {
163 list_for_each_entry(tmp, &mtk_sha.dev_list, sha_list) {
164 cryp = tmp;
165 break;
166 }
167 tctx->cryp = cryp;
168 } else {
169 cryp = tctx->cryp;
170 }
171
172 /*
173 * Assign record id to tfm in round-robin fashion, and this
174 * will help tfm to bind to corresponding descriptor rings.
175 */
176 tctx->id = cryp->rec;
177 cryp->rec = !cryp->rec;
178
179 spin_unlock_bh(&mtk_sha.lock);
180
181 return cryp;
182 }
183
184 static int mtk_sha_append_sg(struct mtk_sha_reqctx *ctx)
185 {
186 size_t count;
187
188 while ((ctx->bufcnt < SHA_BUF_SIZE) && ctx->total) {
189 count = min(ctx->sg->length - ctx->offset, ctx->total);
190 count = min(count, SHA_BUF_SIZE - ctx->bufcnt);
191
192 if (count <= 0) {
193 /*
194 * Check if count <= 0 because the buffer is full or
195 * because the sg length is 0. In the latest case,
196 * check if there is another sg in the list, a 0 length
197 * sg doesn't necessarily mean the end of the sg list.
198 */
199 if ((ctx->sg->length == 0) && !sg_is_last(ctx->sg)) {
200 ctx->sg = sg_next(ctx->sg);
201 continue;
202 } else {
203 break;
204 }
205 }
206
207 scatterwalk_map_and_copy(ctx->buffer + ctx->bufcnt, ctx->sg,
208 ctx->offset, count, 0);
209
210 ctx->bufcnt += count;
211 ctx->offset += count;
212 ctx->total -= count;
213
214 if (ctx->offset == ctx->sg->length) {
215 ctx->sg = sg_next(ctx->sg);
216 if (ctx->sg)
217 ctx->offset = 0;
218 else
219 ctx->total = 0;
220 }
221 }
222
223 return 0;
224 }
225
226 /*
227 * The purpose of this padding is to ensure that the padded message is a
228 * multiple of 512 bits (SHA1/SHA224/SHA256) or 1024 bits (SHA384/SHA512).
229 * The bit "1" is appended at the end of the message followed by
230 * "padlen-1" zero bits. Then a 64 bits block (SHA1/SHA224/SHA256) or
231 * 128 bits block (SHA384/SHA512) equals to the message length in bits
232 * is appended.
233 *
234 * For SHA1/SHA224/SHA256, padlen is calculated as followed:
235 * - if message length < 56 bytes then padlen = 56 - message length
236 * - else padlen = 64 + 56 - message length
237 *
238 * For SHA384/SHA512, padlen is calculated as followed:
239 * - if message length < 112 bytes then padlen = 112 - message length
240 * - else padlen = 128 + 112 - message length
241 */
242 static void mtk_sha_fill_padding(struct mtk_sha_reqctx *ctx, u32 len)
243 {
244 u32 index, padlen;
245 u64 bits[2];
246 u64 size = ctx->digcnt;
247
248 size += ctx->bufcnt;
249 size += len;
250
251 bits[1] = cpu_to_be64(size << 3);
252 bits[0] = cpu_to_be64(size >> 61);
253
254 switch (ctx->flags & SHA_FLAGS_ALGO_MSK) {
255 case SHA_FLAGS_SHA384:
256 case SHA_FLAGS_SHA512:
257 index = ctx->bufcnt & 0x7f;
258 padlen = (index < 112) ? (112 - index) : ((128 + 112) - index);
259 *(ctx->buffer + ctx->bufcnt) = 0x80;
260 memset(ctx->buffer + ctx->bufcnt + 1, 0, padlen - 1);
261 memcpy(ctx->buffer + ctx->bufcnt + padlen, bits, 16);
262 ctx->bufcnt += padlen + 16;
263 ctx->flags |= SHA_FLAGS_PAD;
264 break;
265
266 default:
267 index = ctx->bufcnt & 0x3f;
268 padlen = (index < 56) ? (56 - index) : ((64 + 56) - index);
269 *(ctx->buffer + ctx->bufcnt) = 0x80;
270 memset(ctx->buffer + ctx->bufcnt + 1, 0, padlen - 1);
271 memcpy(ctx->buffer + ctx->bufcnt + padlen, &bits[1], 8);
272 ctx->bufcnt += padlen + 8;
273 ctx->flags |= SHA_FLAGS_PAD;
274 break;
275 }
276 }
277
278 /* Initialize basic transform information of SHA */
279 static void mtk_sha_info_init(struct mtk_sha_reqctx *ctx)
280 {
281 struct mtk_sha_info *info = &ctx->info;
282
283 ctx->ct_hdr = SHA_CT_CTRL_HDR;
284 ctx->ct_size = SHA_CT_SIZE;
285
286 info->tfm[0] = SHA_TFM_HASH | SHA_TFM_SIZE(SIZE_IN_WORDS(ctx->ds));
287
288 switch (ctx->flags & SHA_FLAGS_ALGO_MSK) {
289 case SHA_FLAGS_SHA1:
290 info->tfm[0] |= SHA_TFM_SHA1;
291 break;
292 case SHA_FLAGS_SHA224:
293 info->tfm[0] |= SHA_TFM_SHA224;
294 break;
295 case SHA_FLAGS_SHA256:
296 info->tfm[0] |= SHA_TFM_SHA256;
297 break;
298 case SHA_FLAGS_SHA384:
299 info->tfm[0] |= SHA_TFM_SHA384;
300 break;
301 case SHA_FLAGS_SHA512:
302 info->tfm[0] |= SHA_TFM_SHA512;
303 break;
304
305 default:
306 /* Should not happen... */
307 return;
308 }
309
310 info->tfm[1] = SHA_TFM_HASH_STORE;
311 info->ctrl[0] = info->tfm[0] | SHA_TFM_CONTINUE | SHA_TFM_START;
312 info->ctrl[1] = info->tfm[1];
313
314 info->cmd[0] = SHA_CMD0;
315 info->cmd[1] = SHA_CMD1;
316 info->cmd[2] = SHA_CMD2 | SHA_TFM_DIGEST(SIZE_IN_WORDS(ctx->ds));
317 }
318
319 /*
320 * Update input data length field of transform information and
321 * map it to DMA region.
322 */
323 static int mtk_sha_info_update(struct mtk_cryp *cryp,
324 struct mtk_sha_rec *sha,
325 size_t len1, size_t len2)
326 {
327 struct mtk_sha_reqctx *ctx = ahash_request_ctx(sha->req);
328 struct mtk_sha_info *info = &ctx->info;
329
330 ctx->ct_hdr &= ~SHA_DATA_LEN_MSK;
331 ctx->ct_hdr |= cpu_to_le32(len1 + len2);
332 info->cmd[0] &= ~SHA_DATA_LEN_MSK;
333 info->cmd[0] |= cpu_to_le32(len1 + len2);
334
335 /* Setting SHA_TFM_START only for the first iteration */
336 if (ctx->digcnt)
337 info->ctrl[0] &= ~SHA_TFM_START;
338
339 ctx->digcnt += len1;
340
341 ctx->ct_dma = dma_map_single(cryp->dev, info, sizeof(*info),
342 DMA_BIDIRECTIONAL);
343 if (unlikely(dma_mapping_error(cryp->dev, ctx->ct_dma))) {
344 dev_err(cryp->dev, "dma %zu bytes error\n", sizeof(*info));
345 return -EINVAL;
346 }
347
348 ctx->tfm_dma = ctx->ct_dma + sizeof(info->ctrl) + sizeof(info->cmd);
349
350 return 0;
351 }
352
353 /*
354 * Because of hardware limitation, we must pre-calculate the inner
355 * and outer digest that need to be processed firstly by engine, then
356 * apply the result digest to the input message. These complex hashing
357 * procedures limits HMAC performance, so we use fallback SW encoding.
358 */
359 static int mtk_sha_finish_hmac(struct ahash_request *req)
360 {
361 struct mtk_sha_ctx *tctx = crypto_tfm_ctx(req->base.tfm);
362 struct mtk_sha_hmac_ctx *bctx = tctx->base;
363 struct mtk_sha_reqctx *ctx = ahash_request_ctx(req);
364
365 SHASH_DESC_ON_STACK(shash, bctx->shash);
366
367 shash->tfm = bctx->shash;
368 shash->flags = 0; /* not CRYPTO_TFM_REQ_MAY_SLEEP */
369
370 return crypto_shash_init(shash) ?:
371 crypto_shash_update(shash, bctx->opad, ctx->bs) ?:
372 crypto_shash_finup(shash, req->result, ctx->ds, req->result);
373 }
374
375 /* Initialize request context */
376 static int mtk_sha_init(struct ahash_request *req)
377 {
378 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
379 struct mtk_sha_ctx *tctx = crypto_ahash_ctx(tfm);
380 struct mtk_sha_reqctx *ctx = ahash_request_ctx(req);
381
382 ctx->flags = 0;
383 ctx->ds = crypto_ahash_digestsize(tfm);
384
385 switch (ctx->ds) {
386 case SHA1_DIGEST_SIZE:
387 ctx->flags |= SHA_FLAGS_SHA1;
388 ctx->bs = SHA1_BLOCK_SIZE;
389 break;
390 case SHA224_DIGEST_SIZE:
391 ctx->flags |= SHA_FLAGS_SHA224;
392 ctx->bs = SHA224_BLOCK_SIZE;
393 break;
394 case SHA256_DIGEST_SIZE:
395 ctx->flags |= SHA_FLAGS_SHA256;
396 ctx->bs = SHA256_BLOCK_SIZE;
397 break;
398 case SHA384_DIGEST_SIZE:
399 ctx->flags |= SHA_FLAGS_SHA384;
400 ctx->bs = SHA384_BLOCK_SIZE;
401 break;
402 case SHA512_DIGEST_SIZE:
403 ctx->flags |= SHA_FLAGS_SHA512;
404 ctx->bs = SHA512_BLOCK_SIZE;
405 break;
406 default:
407 return -EINVAL;
408 }
409
410 ctx->bufcnt = 0;
411 ctx->digcnt = 0;
412 ctx->buffer = tctx->buf;
413
414 if (tctx->flags & SHA_FLAGS_HMAC) {
415 struct mtk_sha_hmac_ctx *bctx = tctx->base;
416
417 memcpy(ctx->buffer, bctx->ipad, ctx->bs);
418 ctx->bufcnt = ctx->bs;
419 ctx->flags |= SHA_FLAGS_HMAC;
420 }
421
422 return 0;
423 }
424
425 static int mtk_sha_xmit(struct mtk_cryp *cryp, struct mtk_sha_rec *sha,
426 dma_addr_t addr1, size_t len1,
427 dma_addr_t addr2, size_t len2)
428 {
429 struct mtk_sha_reqctx *ctx = ahash_request_ctx(sha->req);
430 struct mtk_ring *ring = cryp->ring[sha->id];
431 struct mtk_desc *cmd, *res;
432 int err, count = 0;
433
434 err = mtk_sha_info_update(cryp, sha, len1, len2);
435 if (err)
436 return err;
437
438 /* Fill in the command/result descriptors */
439 mtk_sha_ring_shift(ring, &cmd, &res, &count);
440
441 res->hdr = MTK_DESC_FIRST | MTK_DESC_BUF_LEN(len1);
442 cmd->hdr = MTK_DESC_FIRST | MTK_DESC_BUF_LEN(len1) |
443 MTK_DESC_CT_LEN(ctx->ct_size);
444 cmd->buf = cpu_to_le32(addr1);
445 cmd->ct = cpu_to_le32(ctx->ct_dma);
446 cmd->ct_hdr = ctx->ct_hdr;
447 cmd->tfm = cpu_to_le32(ctx->tfm_dma);
448
449 if (len2) {
450 mtk_sha_ring_shift(ring, &cmd, &res, &count);
451
452 res->hdr = MTK_DESC_BUF_LEN(len2);
453 cmd->hdr = MTK_DESC_BUF_LEN(len2);
454 cmd->buf = cpu_to_le32(addr2);
455 }
456
457 cmd->hdr |= MTK_DESC_LAST;
458 res->hdr |= MTK_DESC_LAST;
459
460 /*
461 * Make sure that all changes to the DMA ring are done before we
462 * start engine.
463 */
464 wmb();
465 /* Start DMA transfer */
466 mtk_sha_write(cryp, RDR_PREP_COUNT(sha->id), MTK_DESC_CNT(count));
467 mtk_sha_write(cryp, CDR_PREP_COUNT(sha->id), MTK_DESC_CNT(count));
468
469 return -EINPROGRESS;
470 }
471
472 static int mtk_sha_dma_map(struct mtk_cryp *cryp,
473 struct mtk_sha_rec *sha,
474 struct mtk_sha_reqctx *ctx,
475 size_t count)
476 {
477 ctx->dma_addr = dma_map_single(cryp->dev, ctx->buffer,
478 SHA_BUF_SIZE, DMA_TO_DEVICE);
479 if (unlikely(dma_mapping_error(cryp->dev, ctx->dma_addr))) {
480 dev_err(cryp->dev, "dma map error\n");
481 return -EINVAL;
482 }
483
484 ctx->flags &= ~SHA_FLAGS_SG;
485
486 return mtk_sha_xmit(cryp, sha, ctx->dma_addr, count, 0, 0);
487 }
488
489 static int mtk_sha_update_slow(struct mtk_cryp *cryp,
490 struct mtk_sha_rec *sha)
491 {
492 struct mtk_sha_reqctx *ctx = ahash_request_ctx(sha->req);
493 size_t count;
494 u32 final;
495
496 mtk_sha_append_sg(ctx);
497
498 final = (ctx->flags & SHA_FLAGS_FINUP) && !ctx->total;
499
500 dev_dbg(cryp->dev, "slow: bufcnt: %zu\n", ctx->bufcnt);
501
502 if (final) {
503 sha->flags |= SHA_FLAGS_FINAL;
504 mtk_sha_fill_padding(ctx, 0);
505 }
506
507 if (final || (ctx->bufcnt == SHA_BUF_SIZE && ctx->total)) {
508 count = ctx->bufcnt;
509 ctx->bufcnt = 0;
510
511 return mtk_sha_dma_map(cryp, sha, ctx, count);
512 }
513 return 0;
514 }
515
516 static int mtk_sha_update_start(struct mtk_cryp *cryp,
517 struct mtk_sha_rec *sha)
518 {
519 struct mtk_sha_reqctx *ctx = ahash_request_ctx(sha->req);
520 u32 len, final, tail;
521 struct scatterlist *sg;
522
523 if (!ctx->total)
524 return 0;
525
526 if (ctx->bufcnt || ctx->offset)
527 return mtk_sha_update_slow(cryp, sha);
528
529 sg = ctx->sg;
530
531 if (!IS_ALIGNED(sg->offset, sizeof(u32)))
532 return mtk_sha_update_slow(cryp, sha);
533
534 if (!sg_is_last(sg) && !IS_ALIGNED(sg->length, ctx->bs))
535 /* size is not ctx->bs aligned */
536 return mtk_sha_update_slow(cryp, sha);
537
538 len = min(ctx->total, sg->length);
539
540 if (sg_is_last(sg)) {
541 if (!(ctx->flags & SHA_FLAGS_FINUP)) {
542 /* not last sg must be ctx->bs aligned */
543 tail = len & (ctx->bs - 1);
544 len -= tail;
545 }
546 }
547
548 ctx->total -= len;
549 ctx->offset = len; /* offset where to start slow */
550
551 final = (ctx->flags & SHA_FLAGS_FINUP) && !ctx->total;
552
553 /* Add padding */
554 if (final) {
555 size_t count;
556
557 tail = len & (ctx->bs - 1);
558 len -= tail;
559 ctx->total += tail;
560 ctx->offset = len; /* offset where to start slow */
561
562 sg = ctx->sg;
563 mtk_sha_append_sg(ctx);
564 mtk_sha_fill_padding(ctx, len);
565
566 ctx->dma_addr = dma_map_single(cryp->dev, ctx->buffer,
567 SHA_BUF_SIZE, DMA_TO_DEVICE);
568 if (unlikely(dma_mapping_error(cryp->dev, ctx->dma_addr))) {
569 dev_err(cryp->dev, "dma map bytes error\n");
570 return -EINVAL;
571 }
572
573 sha->flags |= SHA_FLAGS_FINAL;
574 count = ctx->bufcnt;
575 ctx->bufcnt = 0;
576
577 if (len == 0) {
578 ctx->flags &= ~SHA_FLAGS_SG;
579 return mtk_sha_xmit(cryp, sha, ctx->dma_addr,
580 count, 0, 0);
581
582 } else {
583 ctx->sg = sg;
584 if (!dma_map_sg(cryp->dev, ctx->sg, 1, DMA_TO_DEVICE)) {
585 dev_err(cryp->dev, "dma_map_sg error\n");
586 return -EINVAL;
587 }
588
589 ctx->flags |= SHA_FLAGS_SG;
590 return mtk_sha_xmit(cryp, sha, sg_dma_address(ctx->sg),
591 len, ctx->dma_addr, count);
592 }
593 }
594
595 if (!dma_map_sg(cryp->dev, ctx->sg, 1, DMA_TO_DEVICE)) {
596 dev_err(cryp->dev, "dma_map_sg error\n");
597 return -EINVAL;
598 }
599
600 ctx->flags |= SHA_FLAGS_SG;
601
602 return mtk_sha_xmit(cryp, sha, sg_dma_address(ctx->sg),
603 len, 0, 0);
604 }
605
606 static int mtk_sha_final_req(struct mtk_cryp *cryp,
607 struct mtk_sha_rec *sha)
608 {
609 struct mtk_sha_reqctx *ctx = ahash_request_ctx(sha->req);
610 size_t count;
611
612 mtk_sha_fill_padding(ctx, 0);
613
614 sha->flags |= SHA_FLAGS_FINAL;
615 count = ctx->bufcnt;
616 ctx->bufcnt = 0;
617
618 return mtk_sha_dma_map(cryp, sha, ctx, count);
619 }
620
621 /* Copy ready hash (+ finalize hmac) */
622 static int mtk_sha_finish(struct ahash_request *req)
623 {
624 struct mtk_sha_reqctx *ctx = ahash_request_ctx(req);
625 __le32 *digest = ctx->info.digest;
626 u32 *result = (u32 *)req->result;
627 int i;
628
629 /* Get the hash from the digest buffer */
630 for (i = 0; i < SIZE_IN_WORDS(ctx->ds); i++)
631 result[i] = le32_to_cpu(digest[i]);
632
633 if (ctx->flags & SHA_FLAGS_HMAC)
634 return mtk_sha_finish_hmac(req);
635
636 return 0;
637 }
638
639 static void mtk_sha_finish_req(struct mtk_cryp *cryp,
640 struct mtk_sha_rec *sha,
641 int err)
642 {
643 if (likely(!err && (SHA_FLAGS_FINAL & sha->flags)))
644 err = mtk_sha_finish(sha->req);
645
646 sha->flags &= ~(SHA_FLAGS_BUSY | SHA_FLAGS_FINAL);
647
648 sha->req->base.complete(&sha->req->base, err);
649
650 /* Handle new request */
651 tasklet_schedule(&sha->queue_task);
652 }
653
654 static int mtk_sha_handle_queue(struct mtk_cryp *cryp, u8 id,
655 struct ahash_request *req)
656 {
657 struct mtk_sha_rec *sha = cryp->sha[id];
658 struct crypto_async_request *async_req, *backlog;
659 struct mtk_sha_reqctx *ctx;
660 unsigned long flags;
661 int err = 0, ret = 0;
662
663 spin_lock_irqsave(&sha->lock, flags);
664 if (req)
665 ret = ahash_enqueue_request(&sha->queue, req);
666
667 if (SHA_FLAGS_BUSY & sha->flags) {
668 spin_unlock_irqrestore(&sha->lock, flags);
669 return ret;
670 }
671
672 backlog = crypto_get_backlog(&sha->queue);
673 async_req = crypto_dequeue_request(&sha->queue);
674 if (async_req)
675 sha->flags |= SHA_FLAGS_BUSY;
676 spin_unlock_irqrestore(&sha->lock, flags);
677
678 if (!async_req)
679 return ret;
680
681 if (backlog)
682 backlog->complete(backlog, -EINPROGRESS);
683
684 req = ahash_request_cast(async_req);
685 ctx = ahash_request_ctx(req);
686
687 sha->req = req;
688
689 mtk_sha_info_init(ctx);
690
691 if (ctx->op == SHA_OP_UPDATE) {
692 err = mtk_sha_update_start(cryp, sha);
693 if (err != -EINPROGRESS && (ctx->flags & SHA_FLAGS_FINUP))
694 /* No final() after finup() */
695 err = mtk_sha_final_req(cryp, sha);
696 } else if (ctx->op == SHA_OP_FINAL) {
697 err = mtk_sha_final_req(cryp, sha);
698 }
699
700 if (unlikely(err != -EINPROGRESS))
701 /* Task will not finish it, so do it here */
702 mtk_sha_finish_req(cryp, sha, err);
703
704 return ret;
705 }
706
707 static int mtk_sha_enqueue(struct ahash_request *req, u32 op)
708 {
709 struct mtk_sha_reqctx *ctx = ahash_request_ctx(req);
710 struct mtk_sha_ctx *tctx = crypto_tfm_ctx(req->base.tfm);
711
712 ctx->op = op;
713
714 return mtk_sha_handle_queue(tctx->cryp, tctx->id, req);
715 }
716
717 static void mtk_sha_unmap(struct mtk_cryp *cryp, struct mtk_sha_rec *sha)
718 {
719 struct mtk_sha_reqctx *ctx = ahash_request_ctx(sha->req);
720
721 dma_unmap_single(cryp->dev, ctx->ct_dma, sizeof(ctx->info),
722 DMA_BIDIRECTIONAL);
723
724 if (ctx->flags & SHA_FLAGS_SG) {
725 dma_unmap_sg(cryp->dev, ctx->sg, 1, DMA_TO_DEVICE);
726 if (ctx->sg->length == ctx->offset) {
727 ctx->sg = sg_next(ctx->sg);
728 if (ctx->sg)
729 ctx->offset = 0;
730 }
731 if (ctx->flags & SHA_FLAGS_PAD) {
732 dma_unmap_single(cryp->dev, ctx->dma_addr,
733 SHA_BUF_SIZE, DMA_TO_DEVICE);
734 }
735 } else
736 dma_unmap_single(cryp->dev, ctx->dma_addr,
737 SHA_BUF_SIZE, DMA_TO_DEVICE);
738 }
739
740 static void mtk_sha_complete(struct mtk_cryp *cryp,
741 struct mtk_sha_rec *sha)
742 {
743 int err = 0;
744
745 err = mtk_sha_update_start(cryp, sha);
746 if (err != -EINPROGRESS)
747 mtk_sha_finish_req(cryp, sha, err);
748 }
749
750 static int mtk_sha_update(struct ahash_request *req)
751 {
752 struct mtk_sha_reqctx *ctx = ahash_request_ctx(req);
753
754 ctx->total = req->nbytes;
755 ctx->sg = req->src;
756 ctx->offset = 0;
757
758 if ((ctx->bufcnt + ctx->total < SHA_BUF_SIZE) &&
759 !(ctx->flags & SHA_FLAGS_FINUP))
760 return mtk_sha_append_sg(ctx);
761
762 return mtk_sha_enqueue(req, SHA_OP_UPDATE);
763 }
764
765 static int mtk_sha_final(struct ahash_request *req)
766 {
767 struct mtk_sha_reqctx *ctx = ahash_request_ctx(req);
768
769 ctx->flags |= SHA_FLAGS_FINUP;
770
771 if (ctx->flags & SHA_FLAGS_PAD)
772 return mtk_sha_finish(req);
773
774 return mtk_sha_enqueue(req, SHA_OP_FINAL);
775 }
776
777 static int mtk_sha_finup(struct ahash_request *req)
778 {
779 struct mtk_sha_reqctx *ctx = ahash_request_ctx(req);
780 int err1, err2;
781
782 ctx->flags |= SHA_FLAGS_FINUP;
783
784 err1 = mtk_sha_update(req);
785 if (err1 == -EINPROGRESS || err1 == -EBUSY)
786 return err1;
787 /*
788 * final() has to be always called to cleanup resources
789 * even if update() failed
790 */
791 err2 = mtk_sha_final(req);
792
793 return err1 ?: err2;
794 }
795
796 static int mtk_sha_digest(struct ahash_request *req)
797 {
798 return mtk_sha_init(req) ?: mtk_sha_finup(req);
799 }
800
801 static int mtk_sha_setkey(struct crypto_ahash *tfm, const u8 *key,
802 u32 keylen)
803 {
804 struct mtk_sha_ctx *tctx = crypto_ahash_ctx(tfm);
805 struct mtk_sha_hmac_ctx *bctx = tctx->base;
806 size_t bs = crypto_shash_blocksize(bctx->shash);
807 size_t ds = crypto_shash_digestsize(bctx->shash);
808 int err, i;
809
810 SHASH_DESC_ON_STACK(shash, bctx->shash);
811
812 shash->tfm = bctx->shash;
813 shash->flags = crypto_shash_get_flags(bctx->shash) &
814 CRYPTO_TFM_REQ_MAY_SLEEP;
815
816 if (keylen > bs) {
817 err = crypto_shash_digest(shash, key, keylen, bctx->ipad);
818 if (err)
819 return err;
820 keylen = ds;
821 } else {
822 memcpy(bctx->ipad, key, keylen);
823 }
824
825 memset(bctx->ipad + keylen, 0, bs - keylen);
826 memcpy(bctx->opad, bctx->ipad, bs);
827
828 for (i = 0; i < bs; i++) {
829 bctx->ipad[i] ^= HMAC_IPAD_VALUE;
830 bctx->opad[i] ^= HMAC_OPAD_VALUE;
831 }
832
833 return 0;
834 }
835
836 static int mtk_sha_export(struct ahash_request *req, void *out)
837 {
838 const struct mtk_sha_reqctx *ctx = ahash_request_ctx(req);
839
840 memcpy(out, ctx, sizeof(*ctx));
841 return 0;
842 }
843
844 static int mtk_sha_import(struct ahash_request *req, const void *in)
845 {
846 struct mtk_sha_reqctx *ctx = ahash_request_ctx(req);
847
848 memcpy(ctx, in, sizeof(*ctx));
849 return 0;
850 }
851
852 static int mtk_sha_cra_init_alg(struct crypto_tfm *tfm,
853 const char *alg_base)
854 {
855 struct mtk_sha_ctx *tctx = crypto_tfm_ctx(tfm);
856 struct mtk_cryp *cryp = NULL;
857
858 cryp = mtk_sha_find_dev(tctx);
859 if (!cryp)
860 return -ENODEV;
861
862 crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
863 sizeof(struct mtk_sha_reqctx));
864
865 if (alg_base) {
866 struct mtk_sha_hmac_ctx *bctx = tctx->base;
867
868 tctx->flags |= SHA_FLAGS_HMAC;
869 bctx->shash = crypto_alloc_shash(alg_base, 0,
870 CRYPTO_ALG_NEED_FALLBACK);
871 if (IS_ERR(bctx->shash)) {
872 pr_err("base driver %s could not be loaded.\n",
873 alg_base);
874
875 return PTR_ERR(bctx->shash);
876 }
877 }
878 return 0;
879 }
880
881 static int mtk_sha_cra_init(struct crypto_tfm *tfm)
882 {
883 return mtk_sha_cra_init_alg(tfm, NULL);
884 }
885
886 static int mtk_sha_cra_sha1_init(struct crypto_tfm *tfm)
887 {
888 return mtk_sha_cra_init_alg(tfm, "sha1");
889 }
890
891 static int mtk_sha_cra_sha224_init(struct crypto_tfm *tfm)
892 {
893 return mtk_sha_cra_init_alg(tfm, "sha224");
894 }
895
896 static int mtk_sha_cra_sha256_init(struct crypto_tfm *tfm)
897 {
898 return mtk_sha_cra_init_alg(tfm, "sha256");
899 }
900
901 static int mtk_sha_cra_sha384_init(struct crypto_tfm *tfm)
902 {
903 return mtk_sha_cra_init_alg(tfm, "sha384");
904 }
905
906 static int mtk_sha_cra_sha512_init(struct crypto_tfm *tfm)
907 {
908 return mtk_sha_cra_init_alg(tfm, "sha512");
909 }
910
911 static void mtk_sha_cra_exit(struct crypto_tfm *tfm)
912 {
913 struct mtk_sha_ctx *tctx = crypto_tfm_ctx(tfm);
914
915 if (tctx->flags & SHA_FLAGS_HMAC) {
916 struct mtk_sha_hmac_ctx *bctx = tctx->base;
917
918 crypto_free_shash(bctx->shash);
919 }
920 }
921
922 static struct ahash_alg algs_sha1_sha224_sha256[] = {
923 {
924 .init = mtk_sha_init,
925 .update = mtk_sha_update,
926 .final = mtk_sha_final,
927 .finup = mtk_sha_finup,
928 .digest = mtk_sha_digest,
929 .export = mtk_sha_export,
930 .import = mtk_sha_import,
931 .halg.digestsize = SHA1_DIGEST_SIZE,
932 .halg.statesize = sizeof(struct mtk_sha_reqctx),
933 .halg.base = {
934 .cra_name = "sha1",
935 .cra_driver_name = "mtk-sha1",
936 .cra_priority = 400,
937 .cra_flags = CRYPTO_ALG_ASYNC,
938 .cra_blocksize = SHA1_BLOCK_SIZE,
939 .cra_ctxsize = sizeof(struct mtk_sha_ctx),
940 .cra_alignmask = SHA_ALIGN_MSK,
941 .cra_module = THIS_MODULE,
942 .cra_init = mtk_sha_cra_init,
943 .cra_exit = mtk_sha_cra_exit,
944 }
945 },
946 {
947 .init = mtk_sha_init,
948 .update = mtk_sha_update,
949 .final = mtk_sha_final,
950 .finup = mtk_sha_finup,
951 .digest = mtk_sha_digest,
952 .export = mtk_sha_export,
953 .import = mtk_sha_import,
954 .halg.digestsize = SHA224_DIGEST_SIZE,
955 .halg.statesize = sizeof(struct mtk_sha_reqctx),
956 .halg.base = {
957 .cra_name = "sha224",
958 .cra_driver_name = "mtk-sha224",
959 .cra_priority = 400,
960 .cra_flags = CRYPTO_ALG_ASYNC,
961 .cra_blocksize = SHA224_BLOCK_SIZE,
962 .cra_ctxsize = sizeof(struct mtk_sha_ctx),
963 .cra_alignmask = SHA_ALIGN_MSK,
964 .cra_module = THIS_MODULE,
965 .cra_init = mtk_sha_cra_init,
966 .cra_exit = mtk_sha_cra_exit,
967 }
968 },
969 {
970 .init = mtk_sha_init,
971 .update = mtk_sha_update,
972 .final = mtk_sha_final,
973 .finup = mtk_sha_finup,
974 .digest = mtk_sha_digest,
975 .export = mtk_sha_export,
976 .import = mtk_sha_import,
977 .halg.digestsize = SHA256_DIGEST_SIZE,
978 .halg.statesize = sizeof(struct mtk_sha_reqctx),
979 .halg.base = {
980 .cra_name = "sha256",
981 .cra_driver_name = "mtk-sha256",
982 .cra_priority = 400,
983 .cra_flags = CRYPTO_ALG_ASYNC,
984 .cra_blocksize = SHA256_BLOCK_SIZE,
985 .cra_ctxsize = sizeof(struct mtk_sha_ctx),
986 .cra_alignmask = SHA_ALIGN_MSK,
987 .cra_module = THIS_MODULE,
988 .cra_init = mtk_sha_cra_init,
989 .cra_exit = mtk_sha_cra_exit,
990 }
991 },
992 {
993 .init = mtk_sha_init,
994 .update = mtk_sha_update,
995 .final = mtk_sha_final,
996 .finup = mtk_sha_finup,
997 .digest = mtk_sha_digest,
998 .export = mtk_sha_export,
999 .import = mtk_sha_import,
1000 .setkey = mtk_sha_setkey,
1001 .halg.digestsize = SHA1_DIGEST_SIZE,
1002 .halg.statesize = sizeof(struct mtk_sha_reqctx),
1003 .halg.base = {
1004 .cra_name = "hmac(sha1)",
1005 .cra_driver_name = "mtk-hmac-sha1",
1006 .cra_priority = 400,
1007 .cra_flags = CRYPTO_ALG_ASYNC |
1008 CRYPTO_ALG_NEED_FALLBACK,
1009 .cra_blocksize = SHA1_BLOCK_SIZE,
1010 .cra_ctxsize = sizeof(struct mtk_sha_ctx) +
1011 sizeof(struct mtk_sha_hmac_ctx),
1012 .cra_alignmask = SHA_ALIGN_MSK,
1013 .cra_module = THIS_MODULE,
1014 .cra_init = mtk_sha_cra_sha1_init,
1015 .cra_exit = mtk_sha_cra_exit,
1016 }
1017 },
1018 {
1019 .init = mtk_sha_init,
1020 .update = mtk_sha_update,
1021 .final = mtk_sha_final,
1022 .finup = mtk_sha_finup,
1023 .digest = mtk_sha_digest,
1024 .export = mtk_sha_export,
1025 .import = mtk_sha_import,
1026 .setkey = mtk_sha_setkey,
1027 .halg.digestsize = SHA224_DIGEST_SIZE,
1028 .halg.statesize = sizeof(struct mtk_sha_reqctx),
1029 .halg.base = {
1030 .cra_name = "hmac(sha224)",
1031 .cra_driver_name = "mtk-hmac-sha224",
1032 .cra_priority = 400,
1033 .cra_flags = CRYPTO_ALG_ASYNC |
1034 CRYPTO_ALG_NEED_FALLBACK,
1035 .cra_blocksize = SHA224_BLOCK_SIZE,
1036 .cra_ctxsize = sizeof(struct mtk_sha_ctx) +
1037 sizeof(struct mtk_sha_hmac_ctx),
1038 .cra_alignmask = SHA_ALIGN_MSK,
1039 .cra_module = THIS_MODULE,
1040 .cra_init = mtk_sha_cra_sha224_init,
1041 .cra_exit = mtk_sha_cra_exit,
1042 }
1043 },
1044 {
1045 .init = mtk_sha_init,
1046 .update = mtk_sha_update,
1047 .final = mtk_sha_final,
1048 .finup = mtk_sha_finup,
1049 .digest = mtk_sha_digest,
1050 .export = mtk_sha_export,
1051 .import = mtk_sha_import,
1052 .setkey = mtk_sha_setkey,
1053 .halg.digestsize = SHA256_DIGEST_SIZE,
1054 .halg.statesize = sizeof(struct mtk_sha_reqctx),
1055 .halg.base = {
1056 .cra_name = "hmac(sha256)",
1057 .cra_driver_name = "mtk-hmac-sha256",
1058 .cra_priority = 400,
1059 .cra_flags = CRYPTO_ALG_ASYNC |
1060 CRYPTO_ALG_NEED_FALLBACK,
1061 .cra_blocksize = SHA256_BLOCK_SIZE,
1062 .cra_ctxsize = sizeof(struct mtk_sha_ctx) +
1063 sizeof(struct mtk_sha_hmac_ctx),
1064 .cra_alignmask = SHA_ALIGN_MSK,
1065 .cra_module = THIS_MODULE,
1066 .cra_init = mtk_sha_cra_sha256_init,
1067 .cra_exit = mtk_sha_cra_exit,
1068 }
1069 },
1070 };
1071
1072 static struct ahash_alg algs_sha384_sha512[] = {
1073 {
1074 .init = mtk_sha_init,
1075 .update = mtk_sha_update,
1076 .final = mtk_sha_final,
1077 .finup = mtk_sha_finup,
1078 .digest = mtk_sha_digest,
1079 .export = mtk_sha_export,
1080 .import = mtk_sha_import,
1081 .halg.digestsize = SHA384_DIGEST_SIZE,
1082 .halg.statesize = sizeof(struct mtk_sha_reqctx),
1083 .halg.base = {
1084 .cra_name = "sha384",
1085 .cra_driver_name = "mtk-sha384",
1086 .cra_priority = 400,
1087 .cra_flags = CRYPTO_ALG_ASYNC,
1088 .cra_blocksize = SHA384_BLOCK_SIZE,
1089 .cra_ctxsize = sizeof(struct mtk_sha_ctx),
1090 .cra_alignmask = SHA_ALIGN_MSK,
1091 .cra_module = THIS_MODULE,
1092 .cra_init = mtk_sha_cra_init,
1093 .cra_exit = mtk_sha_cra_exit,
1094 }
1095 },
1096 {
1097 .init = mtk_sha_init,
1098 .update = mtk_sha_update,
1099 .final = mtk_sha_final,
1100 .finup = mtk_sha_finup,
1101 .digest = mtk_sha_digest,
1102 .export = mtk_sha_export,
1103 .import = mtk_sha_import,
1104 .halg.digestsize = SHA512_DIGEST_SIZE,
1105 .halg.statesize = sizeof(struct mtk_sha_reqctx),
1106 .halg.base = {
1107 .cra_name = "sha512",
1108 .cra_driver_name = "mtk-sha512",
1109 .cra_priority = 400,
1110 .cra_flags = CRYPTO_ALG_ASYNC,
1111 .cra_blocksize = SHA512_BLOCK_SIZE,
1112 .cra_ctxsize = sizeof(struct mtk_sha_ctx),
1113 .cra_alignmask = SHA_ALIGN_MSK,
1114 .cra_module = THIS_MODULE,
1115 .cra_init = mtk_sha_cra_init,
1116 .cra_exit = mtk_sha_cra_exit,
1117 }
1118 },
1119 {
1120 .init = mtk_sha_init,
1121 .update = mtk_sha_update,
1122 .final = mtk_sha_final,
1123 .finup = mtk_sha_finup,
1124 .digest = mtk_sha_digest,
1125 .export = mtk_sha_export,
1126 .import = mtk_sha_import,
1127 .setkey = mtk_sha_setkey,
1128 .halg.digestsize = SHA384_DIGEST_SIZE,
1129 .halg.statesize = sizeof(struct mtk_sha_reqctx),
1130 .halg.base = {
1131 .cra_name = "hmac(sha384)",
1132 .cra_driver_name = "mtk-hmac-sha384",
1133 .cra_priority = 400,
1134 .cra_flags = CRYPTO_ALG_ASYNC |
1135 CRYPTO_ALG_NEED_FALLBACK,
1136 .cra_blocksize = SHA384_BLOCK_SIZE,
1137 .cra_ctxsize = sizeof(struct mtk_sha_ctx) +
1138 sizeof(struct mtk_sha_hmac_ctx),
1139 .cra_alignmask = SHA_ALIGN_MSK,
1140 .cra_module = THIS_MODULE,
1141 .cra_init = mtk_sha_cra_sha384_init,
1142 .cra_exit = mtk_sha_cra_exit,
1143 }
1144 },
1145 {
1146 .init = mtk_sha_init,
1147 .update = mtk_sha_update,
1148 .final = mtk_sha_final,
1149 .finup = mtk_sha_finup,
1150 .digest = mtk_sha_digest,
1151 .export = mtk_sha_export,
1152 .import = mtk_sha_import,
1153 .setkey = mtk_sha_setkey,
1154 .halg.digestsize = SHA512_DIGEST_SIZE,
1155 .halg.statesize = sizeof(struct mtk_sha_reqctx),
1156 .halg.base = {
1157 .cra_name = "hmac(sha512)",
1158 .cra_driver_name = "mtk-hmac-sha512",
1159 .cra_priority = 400,
1160 .cra_flags = CRYPTO_ALG_ASYNC |
1161 CRYPTO_ALG_NEED_FALLBACK,
1162 .cra_blocksize = SHA512_BLOCK_SIZE,
1163 .cra_ctxsize = sizeof(struct mtk_sha_ctx) +
1164 sizeof(struct mtk_sha_hmac_ctx),
1165 .cra_alignmask = SHA_ALIGN_MSK,
1166 .cra_module = THIS_MODULE,
1167 .cra_init = mtk_sha_cra_sha512_init,
1168 .cra_exit = mtk_sha_cra_exit,
1169 }
1170 },
1171 };
1172
1173 static void mtk_sha_queue_task(unsigned long data)
1174 {
1175 struct mtk_sha_rec *sha = (struct mtk_sha_rec *)data;
1176
1177 mtk_sha_handle_queue(sha->cryp, sha->id - MTK_RING2, NULL);
1178 }
1179
1180 static void mtk_sha_done_task(unsigned long data)
1181 {
1182 struct mtk_sha_rec *sha = (struct mtk_sha_rec *)data;
1183 struct mtk_cryp *cryp = sha->cryp;
1184
1185 mtk_sha_unmap(cryp, sha);
1186 mtk_sha_complete(cryp, sha);
1187 }
1188
1189 static irqreturn_t mtk_sha_irq(int irq, void *dev_id)
1190 {
1191 struct mtk_sha_rec *sha = (struct mtk_sha_rec *)dev_id;
1192 struct mtk_cryp *cryp = sha->cryp;
1193 u32 val = mtk_sha_read(cryp, RDR_STAT(sha->id));
1194
1195 mtk_sha_write(cryp, RDR_STAT(sha->id), val);
1196
1197 if (likely((SHA_FLAGS_BUSY & sha->flags))) {
1198 mtk_sha_write(cryp, RDR_PROC_COUNT(sha->id), MTK_CNT_RST);
1199 mtk_sha_write(cryp, RDR_THRESH(sha->id),
1200 MTK_RDR_PROC_THRESH | MTK_RDR_PROC_MODE);
1201
1202 tasklet_schedule(&sha->done_task);
1203 } else {
1204 dev_warn(cryp->dev, "SHA interrupt when no active requests.\n");
1205 }
1206 return IRQ_HANDLED;
1207 }
1208
1209 /*
1210 * The purpose of two SHA records is used to get extra performance.
1211 * It is similar to mtk_aes_record_init().
1212 */
1213 static int mtk_sha_record_init(struct mtk_cryp *cryp)
1214 {
1215 struct mtk_sha_rec **sha = cryp->sha;
1216 int i, err = -ENOMEM;
1217
1218 for (i = 0; i < MTK_REC_NUM; i++) {
1219 sha[i] = kzalloc(sizeof(**sha), GFP_KERNEL);
1220 if (!sha[i])
1221 goto err_cleanup;
1222
1223 sha[i]->cryp = cryp;
1224
1225 spin_lock_init(&sha[i]->lock);
1226 crypto_init_queue(&sha[i]->queue, SHA_QUEUE_SIZE);
1227
1228 tasklet_init(&sha[i]->queue_task, mtk_sha_queue_task,
1229 (unsigned long)sha[i]);
1230 tasklet_init(&sha[i]->done_task, mtk_sha_done_task,
1231 (unsigned long)sha[i]);
1232 }
1233
1234 /* Link to ring2 and ring3 respectively */
1235 sha[0]->id = MTK_RING2;
1236 sha[1]->id = MTK_RING3;
1237
1238 cryp->rec = 1;
1239
1240 return 0;
1241
1242 err_cleanup:
1243 for (; i--; )
1244 kfree(sha[i]);
1245 return err;
1246 }
1247
1248 static void mtk_sha_record_free(struct mtk_cryp *cryp)
1249 {
1250 int i;
1251
1252 for (i = 0; i < MTK_REC_NUM; i++) {
1253 tasklet_kill(&cryp->sha[i]->done_task);
1254 tasklet_kill(&cryp->sha[i]->queue_task);
1255
1256 kfree(cryp->sha[i]);
1257 }
1258 }
1259
1260 static void mtk_sha_unregister_algs(void)
1261 {
1262 int i;
1263
1264 for (i = 0; i < ARRAY_SIZE(algs_sha1_sha224_sha256); i++)
1265 crypto_unregister_ahash(&algs_sha1_sha224_sha256[i]);
1266
1267 for (i = 0; i < ARRAY_SIZE(algs_sha384_sha512); i++)
1268 crypto_unregister_ahash(&algs_sha384_sha512[i]);
1269 }
1270
1271 static int mtk_sha_register_algs(void)
1272 {
1273 int err, i;
1274
1275 for (i = 0; i < ARRAY_SIZE(algs_sha1_sha224_sha256); i++) {
1276 err = crypto_register_ahash(&algs_sha1_sha224_sha256[i]);
1277 if (err)
1278 goto err_sha_224_256_algs;
1279 }
1280
1281 for (i = 0; i < ARRAY_SIZE(algs_sha384_sha512); i++) {
1282 err = crypto_register_ahash(&algs_sha384_sha512[i]);
1283 if (err)
1284 goto err_sha_384_512_algs;
1285 }
1286
1287 return 0;
1288
1289 err_sha_384_512_algs:
1290 for (; i--; )
1291 crypto_unregister_ahash(&algs_sha384_sha512[i]);
1292 i = ARRAY_SIZE(algs_sha1_sha224_sha256);
1293 err_sha_224_256_algs:
1294 for (; i--; )
1295 crypto_unregister_ahash(&algs_sha1_sha224_sha256[i]);
1296
1297 return err;
1298 }
1299
1300 int mtk_hash_alg_register(struct mtk_cryp *cryp)
1301 {
1302 int err;
1303
1304 INIT_LIST_HEAD(&cryp->sha_list);
1305
1306 /* Initialize two hash records */
1307 err = mtk_sha_record_init(cryp);
1308 if (err)
1309 goto err_record;
1310
1311 err = devm_request_irq(cryp->dev, cryp->irq[MTK_RING2], mtk_sha_irq,
1312 0, "mtk-sha", cryp->sha[0]);
1313 if (err) {
1314 dev_err(cryp->dev, "unable to request sha irq0.\n");
1315 goto err_res;
1316 }
1317
1318 err = devm_request_irq(cryp->dev, cryp->irq[MTK_RING3], mtk_sha_irq,
1319 0, "mtk-sha", cryp->sha[1]);
1320 if (err) {
1321 dev_err(cryp->dev, "unable to request sha irq1.\n");
1322 goto err_res;
1323 }
1324
1325 /* Enable ring2 and ring3 interrupt for hash */
1326 mtk_sha_write(cryp, AIC_ENABLE_SET(MTK_RING2), MTK_IRQ_RDR2);
1327 mtk_sha_write(cryp, AIC_ENABLE_SET(MTK_RING3), MTK_IRQ_RDR3);
1328
1329 spin_lock(&mtk_sha.lock);
1330 list_add_tail(&cryp->sha_list, &mtk_sha.dev_list);
1331 spin_unlock(&mtk_sha.lock);
1332
1333 err = mtk_sha_register_algs();
1334 if (err)
1335 goto err_algs;
1336
1337 return 0;
1338
1339 err_algs:
1340 spin_lock(&mtk_sha.lock);
1341 list_del(&cryp->sha_list);
1342 spin_unlock(&mtk_sha.lock);
1343 err_res:
1344 mtk_sha_record_free(cryp);
1345 err_record:
1346
1347 dev_err(cryp->dev, "mtk-sha initialization failed.\n");
1348 return err;
1349 }
1350
1351 void mtk_hash_alg_release(struct mtk_cryp *cryp)
1352 {
1353 spin_lock(&mtk_sha.lock);
1354 list_del(&cryp->sha_list);
1355 spin_unlock(&mtk_sha.lock);
1356
1357 mtk_sha_unregister_algs();
1358 mtk_sha_record_free(cryp);
1359 }
Linux with added FPC-III support