]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/crypto/sahara.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'asoc/topic/rcar' into asoc-next
[mirror_ubuntu-bionic-kernel.git] / drivers / crypto / sahara.c
1 /*
2 * Cryptographic API.
3 *
4 * Support for SAHARA cryptographic accelerator.
5 *
6 * Copyright (c) 2014 Steffen Trumtrar <s.trumtrar@pengutronix.de>
7 * Copyright (c) 2013 Vista Silicon S.L.
8 * Author: Javier Martin <javier.martin@vista-silicon.com>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as published
12 * by the Free Software Foundation.
13 *
14 * Based on omap-aes.c and tegra-aes.c
15 */
16
17 #include <crypto/aes.h>
18 #include <crypto/internal/hash.h>
19 #include <crypto/internal/skcipher.h>
20 #include <crypto/scatterwalk.h>
21 #include <crypto/sha.h>
22
23 #include <linux/clk.h>
24 #include <linux/crypto.h>
25 #include <linux/interrupt.h>
26 #include <linux/io.h>
27 #include <linux/irq.h>
28 #include <linux/kernel.h>
29 #include <linux/kthread.h>
30 #include <linux/module.h>
31 #include <linux/mutex.h>
32 #include <linux/of.h>
33 #include <linux/of_device.h>
34 #include <linux/platform_device.h>
35
36 #define SHA_BUFFER_LEN PAGE_SIZE
37 #define SAHARA_MAX_SHA_BLOCK_SIZE SHA256_BLOCK_SIZE
38
39 #define SAHARA_NAME "sahara"
40 #define SAHARA_VERSION_3 3
41 #define SAHARA_VERSION_4 4
42 #define SAHARA_TIMEOUT_MS 1000
43 #define SAHARA_MAX_HW_DESC 2
44 #define SAHARA_MAX_HW_LINK 20
45
46 #define FLAGS_MODE_MASK 0x000f
47 #define FLAGS_ENCRYPT BIT(0)
48 #define FLAGS_CBC BIT(1)
49 #define FLAGS_NEW_KEY BIT(3)
50
51 #define SAHARA_HDR_BASE 0x00800000
52 #define SAHARA_HDR_SKHA_ALG_AES 0
53 #define SAHARA_HDR_SKHA_OP_ENC (1 << 2)
54 #define SAHARA_HDR_SKHA_MODE_ECB (0 << 3)
55 #define SAHARA_HDR_SKHA_MODE_CBC (1 << 3)
56 #define SAHARA_HDR_FORM_DATA (5 << 16)
57 #define SAHARA_HDR_FORM_KEY (8 << 16)
58 #define SAHARA_HDR_LLO (1 << 24)
59 #define SAHARA_HDR_CHA_SKHA (1 << 28)
60 #define SAHARA_HDR_CHA_MDHA (2 << 28)
61 #define SAHARA_HDR_PARITY_BIT (1 << 31)
62
63 #define SAHARA_HDR_MDHA_SET_MODE_MD_KEY 0x20880000
64 #define SAHARA_HDR_MDHA_SET_MODE_HASH 0x208D0000
65 #define SAHARA_HDR_MDHA_HASH 0xA0850000
66 #define SAHARA_HDR_MDHA_STORE_DIGEST 0x20820000
67 #define SAHARA_HDR_MDHA_ALG_SHA1 0
68 #define SAHARA_HDR_MDHA_ALG_MD5 1
69 #define SAHARA_HDR_MDHA_ALG_SHA256 2
70 #define SAHARA_HDR_MDHA_ALG_SHA224 3
71 #define SAHARA_HDR_MDHA_PDATA (1 << 2)
72 #define SAHARA_HDR_MDHA_HMAC (1 << 3)
73 #define SAHARA_HDR_MDHA_INIT (1 << 5)
74 #define SAHARA_HDR_MDHA_IPAD (1 << 6)
75 #define SAHARA_HDR_MDHA_OPAD (1 << 7)
76 #define SAHARA_HDR_MDHA_SWAP (1 << 8)
77 #define SAHARA_HDR_MDHA_MAC_FULL (1 << 9)
78 #define SAHARA_HDR_MDHA_SSL (1 << 10)
79
80 /* SAHARA can only process one request at a time */
81 #define SAHARA_QUEUE_LENGTH 1
82
83 #define SAHARA_REG_VERSION 0x00
84 #define SAHARA_REG_DAR 0x04
85 #define SAHARA_REG_CONTROL 0x08
86 #define SAHARA_CONTROL_SET_THROTTLE(x) (((x) & 0xff) << 24)
87 #define SAHARA_CONTROL_SET_MAXBURST(x) (((x) & 0xff) << 16)
88 #define SAHARA_CONTROL_RNG_AUTORSD (1 << 7)
89 #define SAHARA_CONTROL_ENABLE_INT (1 << 4)
90 #define SAHARA_REG_CMD 0x0C
91 #define SAHARA_CMD_RESET (1 << 0)
92 #define SAHARA_CMD_CLEAR_INT (1 << 8)
93 #define SAHARA_CMD_CLEAR_ERR (1 << 9)
94 #define SAHARA_CMD_SINGLE_STEP (1 << 10)
95 #define SAHARA_CMD_MODE_BATCH (1 << 16)
96 #define SAHARA_CMD_MODE_DEBUG (1 << 18)
97 #define SAHARA_REG_STATUS 0x10
98 #define SAHARA_STATUS_GET_STATE(x) ((x) & 0x7)
99 #define SAHARA_STATE_IDLE 0
100 #define SAHARA_STATE_BUSY 1
101 #define SAHARA_STATE_ERR 2
102 #define SAHARA_STATE_FAULT 3
103 #define SAHARA_STATE_COMPLETE 4
104 #define SAHARA_STATE_COMP_FLAG (1 << 2)
105 #define SAHARA_STATUS_DAR_FULL (1 << 3)
106 #define SAHARA_STATUS_ERROR (1 << 4)
107 #define SAHARA_STATUS_SECURE (1 << 5)
108 #define SAHARA_STATUS_FAIL (1 << 6)
109 #define SAHARA_STATUS_INIT (1 << 7)
110 #define SAHARA_STATUS_RNG_RESEED (1 << 8)
111 #define SAHARA_STATUS_ACTIVE_RNG (1 << 9)
112 #define SAHARA_STATUS_ACTIVE_MDHA (1 << 10)
113 #define SAHARA_STATUS_ACTIVE_SKHA (1 << 11)
114 #define SAHARA_STATUS_MODE_BATCH (1 << 16)
115 #define SAHARA_STATUS_MODE_DEDICATED (1 << 17)
116 #define SAHARA_STATUS_MODE_DEBUG (1 << 18)
117 #define SAHARA_STATUS_GET_ISTATE(x) (((x) >> 24) & 0xff)
118 #define SAHARA_REG_ERRSTATUS 0x14
119 #define SAHARA_ERRSTATUS_GET_SOURCE(x) ((x) & 0xf)
120 #define SAHARA_ERRSOURCE_CHA 14
121 #define SAHARA_ERRSOURCE_DMA 15
122 #define SAHARA_ERRSTATUS_DMA_DIR (1 << 8)
123 #define SAHARA_ERRSTATUS_GET_DMASZ(x)(((x) >> 9) & 0x3)
124 #define SAHARA_ERRSTATUS_GET_DMASRC(x) (((x) >> 13) & 0x7)
125 #define SAHARA_ERRSTATUS_GET_CHASRC(x) (((x) >> 16) & 0xfff)
126 #define SAHARA_ERRSTATUS_GET_CHAERR(x) (((x) >> 28) & 0x3)
127 #define SAHARA_REG_FADDR 0x18
128 #define SAHARA_REG_CDAR 0x1C
129 #define SAHARA_REG_IDAR 0x20
130
131 struct sahara_hw_desc {
132 u32 hdr;
133 u32 len1;
134 u32 p1;
135 u32 len2;
136 u32 p2;
137 u32 next;
138 };
139
140 struct sahara_hw_link {
141 u32 len;
142 u32 p;
143 u32 next;
144 };
145
146 struct sahara_ctx {
147 unsigned long flags;
148
149 /* AES-specific context */
150 int keylen;
151 u8 key[AES_KEYSIZE_128];
152 struct crypto_skcipher *fallback;
153 };
154
155 struct sahara_aes_reqctx {
156 unsigned long mode;
157 };
158
159 /*
160 * struct sahara_sha_reqctx - private data per request
161 * @buf: holds data for requests smaller than block_size
162 * @rembuf: used to prepare one block_size-aligned request
163 * @context: hw-specific context for request. Digest is extracted from this
164 * @mode: specifies what type of hw-descriptor needs to be built
165 * @digest_size: length of digest for this request
166 * @context_size: length of hw-context for this request.
167 * Always digest_size + 4
168 * @buf_cnt: number of bytes saved in buf
169 * @sg_in_idx: number of hw links
170 * @in_sg: scatterlist for input data
171 * @in_sg_chain: scatterlists for chained input data
172 * @total: total number of bytes for transfer
173 * @last: is this the last block
174 * @first: is this the first block
175 * @active: inside a transfer
176 */
177 struct sahara_sha_reqctx {
178 u8 buf[SAHARA_MAX_SHA_BLOCK_SIZE];
179 u8 rembuf[SAHARA_MAX_SHA_BLOCK_SIZE];
180 u8 context[SHA256_DIGEST_SIZE + 4];
181 unsigned int mode;
182 unsigned int digest_size;
183 unsigned int context_size;
184 unsigned int buf_cnt;
185 unsigned int sg_in_idx;
186 struct scatterlist *in_sg;
187 struct scatterlist in_sg_chain[2];
188 size_t total;
189 unsigned int last;
190 unsigned int first;
191 unsigned int active;
192 };
193
194 struct sahara_dev {
195 struct device *device;
196 unsigned int version;
197 void __iomem *regs_base;
198 struct clk *clk_ipg;
199 struct clk *clk_ahb;
200 struct mutex queue_mutex;
201 struct task_struct *kthread;
202 struct completion dma_completion;
203
204 struct sahara_ctx *ctx;
205 struct crypto_queue queue;
206 unsigned long flags;
207
208 struct sahara_hw_desc *hw_desc[SAHARA_MAX_HW_DESC];
209 dma_addr_t hw_phys_desc[SAHARA_MAX_HW_DESC];
210
211 u8 *key_base;
212 dma_addr_t key_phys_base;
213
214 u8 *iv_base;
215 dma_addr_t iv_phys_base;
216
217 u8 *context_base;
218 dma_addr_t context_phys_base;
219
220 struct sahara_hw_link *hw_link[SAHARA_MAX_HW_LINK];
221 dma_addr_t hw_phys_link[SAHARA_MAX_HW_LINK];
222
223 size_t total;
224 struct scatterlist *in_sg;
225 int nb_in_sg;
226 struct scatterlist *out_sg;
227 int nb_out_sg;
228
229 u32 error;
230 };
231
232 static struct sahara_dev *dev_ptr;
233
234 static inline void sahara_write(struct sahara_dev *dev, u32 data, u32 reg)
235 {
236 writel(data, dev->regs_base + reg);
237 }
238
239 static inline unsigned int sahara_read(struct sahara_dev *dev, u32 reg)
240 {
241 return readl(dev->regs_base + reg);
242 }
243
244 static u32 sahara_aes_key_hdr(struct sahara_dev *dev)
245 {
246 u32 hdr = SAHARA_HDR_BASE | SAHARA_HDR_SKHA_ALG_AES |
247 SAHARA_HDR_FORM_KEY | SAHARA_HDR_LLO |
248 SAHARA_HDR_CHA_SKHA | SAHARA_HDR_PARITY_BIT;
249
250 if (dev->flags & FLAGS_CBC) {
251 hdr |= SAHARA_HDR_SKHA_MODE_CBC;
252 hdr ^= SAHARA_HDR_PARITY_BIT;
253 }
254
255 if (dev->flags & FLAGS_ENCRYPT) {
256 hdr |= SAHARA_HDR_SKHA_OP_ENC;
257 hdr ^= SAHARA_HDR_PARITY_BIT;
258 }
259
260 return hdr;
261 }
262
263 static u32 sahara_aes_data_link_hdr(struct sahara_dev *dev)
264 {
265 return SAHARA_HDR_BASE | SAHARA_HDR_FORM_DATA |
266 SAHARA_HDR_CHA_SKHA | SAHARA_HDR_PARITY_BIT;
267 }
268
269 static const char *sahara_err_src[16] = {
270 "No error",
271 "Header error",
272 "Descriptor length error",
273 "Descriptor length or pointer error",
274 "Link length error",
275 "Link pointer error",
276 "Input buffer error",
277 "Output buffer error",
278 "Output buffer starvation",
279 "Internal state fault",
280 "General descriptor problem",
281 "Reserved",
282 "Descriptor address error",
283 "Link address error",
284 "CHA error",
285 "DMA error"
286 };
287
288 static const char *sahara_err_dmasize[4] = {
289 "Byte transfer",
290 "Half-word transfer",
291 "Word transfer",
292 "Reserved"
293 };
294
295 static const char *sahara_err_dmasrc[8] = {
296 "No error",
297 "AHB bus error",
298 "Internal IP bus error",
299 "Parity error",
300 "DMA crosses 256 byte boundary",
301 "DMA is busy",
302 "Reserved",
303 "DMA HW error"
304 };
305
306 static const char *sahara_cha_errsrc[12] = {
307 "Input buffer non-empty",
308 "Illegal address",
309 "Illegal mode",
310 "Illegal data size",
311 "Illegal key size",
312 "Write during processing",
313 "CTX read during processing",
314 "HW error",
315 "Input buffer disabled/underflow",
316 "Output buffer disabled/overflow",
317 "DES key parity error",
318 "Reserved"
319 };
320
321 static const char *sahara_cha_err[4] = { "No error", "SKHA", "MDHA", "RNG" };
322
323 static void sahara_decode_error(struct sahara_dev *dev, unsigned int error)
324 {
325 u8 source = SAHARA_ERRSTATUS_GET_SOURCE(error);
326 u16 chasrc = ffs(SAHARA_ERRSTATUS_GET_CHASRC(error));
327
328 dev_err(dev->device, "%s: Error Register = 0x%08x\n", __func__, error);
329
330 dev_err(dev->device, " - %s.\n", sahara_err_src[source]);
331
332 if (source == SAHARA_ERRSOURCE_DMA) {
333 if (error & SAHARA_ERRSTATUS_DMA_DIR)
334 dev_err(dev->device, " * DMA read.\n");
335 else
336 dev_err(dev->device, " * DMA write.\n");
337
338 dev_err(dev->device, " * %s.\n",
339 sahara_err_dmasize[SAHARA_ERRSTATUS_GET_DMASZ(error)]);
340 dev_err(dev->device, " * %s.\n",
341 sahara_err_dmasrc[SAHARA_ERRSTATUS_GET_DMASRC(error)]);
342 } else if (source == SAHARA_ERRSOURCE_CHA) {
343 dev_err(dev->device, " * %s.\n",
344 sahara_cha_errsrc[chasrc]);
345 dev_err(dev->device, " * %s.\n",
346 sahara_cha_err[SAHARA_ERRSTATUS_GET_CHAERR(error)]);
347 }
348 dev_err(dev->device, "\n");
349 }
350
351 static const char *sahara_state[4] = { "Idle", "Busy", "Error", "HW Fault" };
352
353 static void sahara_decode_status(struct sahara_dev *dev, unsigned int status)
354 {
355 u8 state;
356
357 if (!IS_ENABLED(DEBUG))
358 return;
359
360 state = SAHARA_STATUS_GET_STATE(status);
361
362 dev_dbg(dev->device, "%s: Status Register = 0x%08x\n",
363 __func__, status);
364
365 dev_dbg(dev->device, " - State = %d:\n", state);
366 if (state & SAHARA_STATE_COMP_FLAG)
367 dev_dbg(dev->device, " * Descriptor completed. IRQ pending.\n");
368
369 dev_dbg(dev->device, " * %s.\n",
370 sahara_state[state & ~SAHARA_STATE_COMP_FLAG]);
371
372 if (status & SAHARA_STATUS_DAR_FULL)
373 dev_dbg(dev->device, " - DAR Full.\n");
374 if (status & SAHARA_STATUS_ERROR)
375 dev_dbg(dev->device, " - Error.\n");
376 if (status & SAHARA_STATUS_SECURE)
377 dev_dbg(dev->device, " - Secure.\n");
378 if (status & SAHARA_STATUS_FAIL)
379 dev_dbg(dev->device, " - Fail.\n");
380 if (status & SAHARA_STATUS_RNG_RESEED)
381 dev_dbg(dev->device, " - RNG Reseed Request.\n");
382 if (status & SAHARA_STATUS_ACTIVE_RNG)
383 dev_dbg(dev->device, " - RNG Active.\n");
384 if (status & SAHARA_STATUS_ACTIVE_MDHA)
385 dev_dbg(dev->device, " - MDHA Active.\n");
386 if (status & SAHARA_STATUS_ACTIVE_SKHA)
387 dev_dbg(dev->device, " - SKHA Active.\n");
388
389 if (status & SAHARA_STATUS_MODE_BATCH)
390 dev_dbg(dev->device, " - Batch Mode.\n");
391 else if (status & SAHARA_STATUS_MODE_DEDICATED)
392 dev_dbg(dev->device, " - Dedicated Mode.\n");
393 else if (status & SAHARA_STATUS_MODE_DEBUG)
394 dev_dbg(dev->device, " - Debug Mode.\n");
395
396 dev_dbg(dev->device, " - Internal state = 0x%02x\n",
397 SAHARA_STATUS_GET_ISTATE(status));
398
399 dev_dbg(dev->device, "Current DAR: 0x%08x\n",
400 sahara_read(dev, SAHARA_REG_CDAR));
401 dev_dbg(dev->device, "Initial DAR: 0x%08x\n\n",
402 sahara_read(dev, SAHARA_REG_IDAR));
403 }
404
405 static void sahara_dump_descriptors(struct sahara_dev *dev)
406 {
407 int i;
408
409 if (!IS_ENABLED(DEBUG))
410 return;
411
412 for (i = 0; i < SAHARA_MAX_HW_DESC; i++) {
413 dev_dbg(dev->device, "Descriptor (%d) (%pad):\n",
414 i, &dev->hw_phys_desc[i]);
415 dev_dbg(dev->device, "\thdr = 0x%08x\n", dev->hw_desc[i]->hdr);
416 dev_dbg(dev->device, "\tlen1 = %u\n", dev->hw_desc[i]->len1);
417 dev_dbg(dev->device, "\tp1 = 0x%08x\n", dev->hw_desc[i]->p1);
418 dev_dbg(dev->device, "\tlen2 = %u\n", dev->hw_desc[i]->len2);
419 dev_dbg(dev->device, "\tp2 = 0x%08x\n", dev->hw_desc[i]->p2);
420 dev_dbg(dev->device, "\tnext = 0x%08x\n",
421 dev->hw_desc[i]->next);
422 }
423 dev_dbg(dev->device, "\n");
424 }
425
426 static void sahara_dump_links(struct sahara_dev *dev)
427 {
428 int i;
429
430 if (!IS_ENABLED(DEBUG))
431 return;
432
433 for (i = 0; i < SAHARA_MAX_HW_LINK; i++) {
434 dev_dbg(dev->device, "Link (%d) (%pad):\n",
435 i, &dev->hw_phys_link[i]);
436 dev_dbg(dev->device, "\tlen = %u\n", dev->hw_link[i]->len);
437 dev_dbg(dev->device, "\tp = 0x%08x\n", dev->hw_link[i]->p);
438 dev_dbg(dev->device, "\tnext = 0x%08x\n",
439 dev->hw_link[i]->next);
440 }
441 dev_dbg(dev->device, "\n");
442 }
443
444 static int sahara_hw_descriptor_create(struct sahara_dev *dev)
445 {
446 struct sahara_ctx *ctx = dev->ctx;
447 struct scatterlist *sg;
448 int ret;
449 int i, j;
450 int idx = 0;
451
452 /* Copy new key if necessary */
453 if (ctx->flags & FLAGS_NEW_KEY) {
454 memcpy(dev->key_base, ctx->key, ctx->keylen);
455 ctx->flags &= ~FLAGS_NEW_KEY;
456
457 if (dev->flags & FLAGS_CBC) {
458 dev->hw_desc[idx]->len1 = AES_BLOCK_SIZE;
459 dev->hw_desc[idx]->p1 = dev->iv_phys_base;
460 } else {
461 dev->hw_desc[idx]->len1 = 0;
462 dev->hw_desc[idx]->p1 = 0;
463 }
464 dev->hw_desc[idx]->len2 = ctx->keylen;
465 dev->hw_desc[idx]->p2 = dev->key_phys_base;
466 dev->hw_desc[idx]->next = dev->hw_phys_desc[1];
467
468 dev->hw_desc[idx]->hdr = sahara_aes_key_hdr(dev);
469
470 idx++;
471 }
472
473 dev->nb_in_sg = sg_nents_for_len(dev->in_sg, dev->total);
474 if (dev->nb_in_sg < 0) {
475 dev_err(dev->device, "Invalid numbers of src SG.\n");
476 return dev->nb_in_sg;
477 }
478 dev->nb_out_sg = sg_nents_for_len(dev->out_sg, dev->total);
479 if (dev->nb_out_sg < 0) {
480 dev_err(dev->device, "Invalid numbers of dst SG.\n");
481 return dev->nb_out_sg;
482 }
483 if ((dev->nb_in_sg + dev->nb_out_sg) > SAHARA_MAX_HW_LINK) {
484 dev_err(dev->device, "not enough hw links (%d)\n",
485 dev->nb_in_sg + dev->nb_out_sg);
486 return -EINVAL;
487 }
488
489 ret = dma_map_sg(dev->device, dev->in_sg, dev->nb_in_sg,
490 DMA_TO_DEVICE);
491 if (ret != dev->nb_in_sg) {
492 dev_err(dev->device, "couldn't map in sg\n");
493 goto unmap_in;
494 }
495 ret = dma_map_sg(dev->device, dev->out_sg, dev->nb_out_sg,
496 DMA_FROM_DEVICE);
497 if (ret != dev->nb_out_sg) {
498 dev_err(dev->device, "couldn't map out sg\n");
499 goto unmap_out;
500 }
501
502 /* Create input links */
503 dev->hw_desc[idx]->p1 = dev->hw_phys_link[0];
504 sg = dev->in_sg;
505 for (i = 0; i < dev->nb_in_sg; i++) {
506 dev->hw_link[i]->len = sg->length;
507 dev->hw_link[i]->p = sg->dma_address;
508 if (i == (dev->nb_in_sg - 1)) {
509 dev->hw_link[i]->next = 0;
510 } else {
511 dev->hw_link[i]->next = dev->hw_phys_link[i + 1];
512 sg = sg_next(sg);
513 }
514 }
515
516 /* Create output links */
517 dev->hw_desc[idx]->p2 = dev->hw_phys_link[i];
518 sg = dev->out_sg;
519 for (j = i; j < dev->nb_out_sg + i; j++) {
520 dev->hw_link[j]->len = sg->length;
521 dev->hw_link[j]->p = sg->dma_address;
522 if (j == (dev->nb_out_sg + i - 1)) {
523 dev->hw_link[j]->next = 0;
524 } else {
525 dev->hw_link[j]->next = dev->hw_phys_link[j + 1];
526 sg = sg_next(sg);
527 }
528 }
529
530 /* Fill remaining fields of hw_desc[1] */
531 dev->hw_desc[idx]->hdr = sahara_aes_data_link_hdr(dev);
532 dev->hw_desc[idx]->len1 = dev->total;
533 dev->hw_desc[idx]->len2 = dev->total;
534 dev->hw_desc[idx]->next = 0;
535
536 sahara_dump_descriptors(dev);
537 sahara_dump_links(dev);
538
539 sahara_write(dev, dev->hw_phys_desc[0], SAHARA_REG_DAR);
540
541 return 0;
542
543 unmap_out:
544 dma_unmap_sg(dev->device, dev->out_sg, dev->nb_out_sg,
545 DMA_FROM_DEVICE);
546 unmap_in:
547 dma_unmap_sg(dev->device, dev->in_sg, dev->nb_in_sg,
548 DMA_TO_DEVICE);
549
550 return -EINVAL;
551 }
552
553 static int sahara_aes_process(struct ablkcipher_request *req)
554 {
555 struct sahara_dev *dev = dev_ptr;
556 struct sahara_ctx *ctx;
557 struct sahara_aes_reqctx *rctx;
558 int ret;
559 unsigned long timeout;
560
561 /* Request is ready to be dispatched by the device */
562 dev_dbg(dev->device,
563 "dispatch request (nbytes=%d, src=%p, dst=%p)\n",
564 req->nbytes, req->src, req->dst);
565
566 /* assign new request to device */
567 dev->total = req->nbytes;
568 dev->in_sg = req->src;
569 dev->out_sg = req->dst;
570
571 rctx = ablkcipher_request_ctx(req);
572 ctx = crypto_ablkcipher_ctx(crypto_ablkcipher_reqtfm(req));
573 rctx->mode &= FLAGS_MODE_MASK;
574 dev->flags = (dev->flags & ~FLAGS_MODE_MASK) | rctx->mode;
575
576 if ((dev->flags & FLAGS_CBC) && req->info)
577 memcpy(dev->iv_base, req->info, AES_KEYSIZE_128);
578
579 /* assign new context to device */
580 dev->ctx = ctx;
581
582 reinit_completion(&dev->dma_completion);
583
584 ret = sahara_hw_descriptor_create(dev);
585 if (ret)
586 return -EINVAL;
587
588 timeout = wait_for_completion_timeout(&dev->dma_completion,
589 msecs_to_jiffies(SAHARA_TIMEOUT_MS));
590 if (!timeout) {
591 dev_err(dev->device, "AES timeout\n");
592 return -ETIMEDOUT;
593 }
594
595 dma_unmap_sg(dev->device, dev->out_sg, dev->nb_out_sg,
596 DMA_FROM_DEVICE);
597 dma_unmap_sg(dev->device, dev->in_sg, dev->nb_in_sg,
598 DMA_TO_DEVICE);
599
600 return 0;
601 }
602
603 static int sahara_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
604 unsigned int keylen)
605 {
606 struct sahara_ctx *ctx = crypto_ablkcipher_ctx(tfm);
607 int ret;
608
609 ctx->keylen = keylen;
610
611 /* SAHARA only supports 128bit keys */
612 if (keylen == AES_KEYSIZE_128) {
613 memcpy(ctx->key, key, keylen);
614 ctx->flags |= FLAGS_NEW_KEY;
615 return 0;
616 }
617
618 if (keylen != AES_KEYSIZE_192 && keylen != AES_KEYSIZE_256)
619 return -EINVAL;
620
621 /*
622 * The requested key size is not supported by HW, do a fallback.
623 */
624 crypto_skcipher_clear_flags(ctx->fallback, CRYPTO_TFM_REQ_MASK);
625 crypto_skcipher_set_flags(ctx->fallback, tfm->base.crt_flags &
626 CRYPTO_TFM_REQ_MASK);
627
628 ret = crypto_skcipher_setkey(ctx->fallback, key, keylen);
629
630 tfm->base.crt_flags &= ~CRYPTO_TFM_RES_MASK;
631 tfm->base.crt_flags |= crypto_skcipher_get_flags(ctx->fallback) &
632 CRYPTO_TFM_RES_MASK;
633 return ret;
634 }
635
636 static int sahara_aes_crypt(struct ablkcipher_request *req, unsigned long mode)
637 {
638 struct sahara_aes_reqctx *rctx = ablkcipher_request_ctx(req);
639 struct sahara_dev *dev = dev_ptr;
640 int err = 0;
641
642 dev_dbg(dev->device, "nbytes: %d, enc: %d, cbc: %d\n",
643 req->nbytes, !!(mode & FLAGS_ENCRYPT), !!(mode & FLAGS_CBC));
644
645 if (!IS_ALIGNED(req->nbytes, AES_BLOCK_SIZE)) {
646 dev_err(dev->device,
647 "request size is not exact amount of AES blocks\n");
648 return -EINVAL;
649 }
650
651 rctx->mode = mode;
652
653 mutex_lock(&dev->queue_mutex);
654 err = ablkcipher_enqueue_request(&dev->queue, req);
655 mutex_unlock(&dev->queue_mutex);
656
657 wake_up_process(dev->kthread);
658
659 return err;
660 }
661
662 static int sahara_aes_ecb_encrypt(struct ablkcipher_request *req)
663 {
664 struct sahara_ctx *ctx = crypto_ablkcipher_ctx(
665 crypto_ablkcipher_reqtfm(req));
666 int err;
667
668 if (unlikely(ctx->keylen != AES_KEYSIZE_128)) {
669 SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback);
670
671 skcipher_request_set_tfm(subreq, ctx->fallback);
672 skcipher_request_set_callback(subreq, req->base.flags,
673 NULL, NULL);
674 skcipher_request_set_crypt(subreq, req->src, req->dst,
675 req->nbytes, req->info);
676 err = crypto_skcipher_encrypt(subreq);
677 skcipher_request_zero(subreq);
678 return err;
679 }
680
681 return sahara_aes_crypt(req, FLAGS_ENCRYPT);
682 }
683
684 static int sahara_aes_ecb_decrypt(struct ablkcipher_request *req)
685 {
686 struct sahara_ctx *ctx = crypto_ablkcipher_ctx(
687 crypto_ablkcipher_reqtfm(req));
688 int err;
689
690 if (unlikely(ctx->keylen != AES_KEYSIZE_128)) {
691 SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback);
692
693 skcipher_request_set_tfm(subreq, ctx->fallback);
694 skcipher_request_set_callback(subreq, req->base.flags,
695 NULL, NULL);
696 skcipher_request_set_crypt(subreq, req->src, req->dst,
697 req->nbytes, req->info);
698 err = crypto_skcipher_decrypt(subreq);
699 skcipher_request_zero(subreq);
700 return err;
701 }
702
703 return sahara_aes_crypt(req, 0);
704 }
705
706 static int sahara_aes_cbc_encrypt(struct ablkcipher_request *req)
707 {
708 struct sahara_ctx *ctx = crypto_ablkcipher_ctx(
709 crypto_ablkcipher_reqtfm(req));
710 int err;
711
712 if (unlikely(ctx->keylen != AES_KEYSIZE_128)) {
713 SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback);
714
715 skcipher_request_set_tfm(subreq, ctx->fallback);
716 skcipher_request_set_callback(subreq, req->base.flags,
717 NULL, NULL);
718 skcipher_request_set_crypt(subreq, req->src, req->dst,
719 req->nbytes, req->info);
720 err = crypto_skcipher_encrypt(subreq);
721 skcipher_request_zero(subreq);
722 return err;
723 }
724
725 return sahara_aes_crypt(req, FLAGS_ENCRYPT | FLAGS_CBC);
726 }
727
728 static int sahara_aes_cbc_decrypt(struct ablkcipher_request *req)
729 {
730 struct sahara_ctx *ctx = crypto_ablkcipher_ctx(
731 crypto_ablkcipher_reqtfm(req));
732 int err;
733
734 if (unlikely(ctx->keylen != AES_KEYSIZE_128)) {
735 SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback);
736
737 skcipher_request_set_tfm(subreq, ctx->fallback);
738 skcipher_request_set_callback(subreq, req->base.flags,
739 NULL, NULL);
740 skcipher_request_set_crypt(subreq, req->src, req->dst,
741 req->nbytes, req->info);
742 err = crypto_skcipher_decrypt(subreq);
743 skcipher_request_zero(subreq);
744 return err;
745 }
746
747 return sahara_aes_crypt(req, FLAGS_CBC);
748 }
749
750 static int sahara_aes_cra_init(struct crypto_tfm *tfm)
751 {
752 const char *name = crypto_tfm_alg_name(tfm);
753 struct sahara_ctx *ctx = crypto_tfm_ctx(tfm);
754
755 ctx->fallback = crypto_alloc_skcipher(name, 0,
756 CRYPTO_ALG_ASYNC |
757 CRYPTO_ALG_NEED_FALLBACK);
758 if (IS_ERR(ctx->fallback)) {
759 pr_err("Error allocating fallback algo %s\n", name);
760 return PTR_ERR(ctx->fallback);
761 }
762
763 tfm->crt_ablkcipher.reqsize = sizeof(struct sahara_aes_reqctx);
764
765 return 0;
766 }
767
768 static void sahara_aes_cra_exit(struct crypto_tfm *tfm)
769 {
770 struct sahara_ctx *ctx = crypto_tfm_ctx(tfm);
771
772 crypto_free_skcipher(ctx->fallback);
773 }
774
775 static u32 sahara_sha_init_hdr(struct sahara_dev *dev,
776 struct sahara_sha_reqctx *rctx)
777 {
778 u32 hdr = 0;
779
780 hdr = rctx->mode;
781
782 if (rctx->first) {
783 hdr |= SAHARA_HDR_MDHA_SET_MODE_HASH;
784 hdr |= SAHARA_HDR_MDHA_INIT;
785 } else {
786 hdr |= SAHARA_HDR_MDHA_SET_MODE_MD_KEY;
787 }
788
789 if (rctx->last)
790 hdr |= SAHARA_HDR_MDHA_PDATA;
791
792 if (hweight_long(hdr) % 2 == 0)
793 hdr |= SAHARA_HDR_PARITY_BIT;
794
795 return hdr;
796 }
797
798 static int sahara_sha_hw_links_create(struct sahara_dev *dev,
799 struct sahara_sha_reqctx *rctx,
800 int start)
801 {
802 struct scatterlist *sg;
803 unsigned int i;
804 int ret;
805
806 dev->in_sg = rctx->in_sg;
807
808 dev->nb_in_sg = sg_nents_for_len(dev->in_sg, rctx->total);
809 if (dev->nb_in_sg < 0) {
810 dev_err(dev->device, "Invalid numbers of src SG.\n");
811 return dev->nb_in_sg;
812 }
813 if ((dev->nb_in_sg) > SAHARA_MAX_HW_LINK) {
814 dev_err(dev->device, "not enough hw links (%d)\n",
815 dev->nb_in_sg + dev->nb_out_sg);
816 return -EINVAL;
817 }
818
819 sg = dev->in_sg;
820 ret = dma_map_sg(dev->device, dev->in_sg, dev->nb_in_sg, DMA_TO_DEVICE);
821 if (!ret)
822 return -EFAULT;
823
824 for (i = start; i < dev->nb_in_sg + start; i++) {
825 dev->hw_link[i]->len = sg->length;
826 dev->hw_link[i]->p = sg->dma_address;
827 if (i == (dev->nb_in_sg + start - 1)) {
828 dev->hw_link[i]->next = 0;
829 } else {
830 dev->hw_link[i]->next = dev->hw_phys_link[i + 1];
831 sg = sg_next(sg);
832 }
833 }
834
835 return i;
836 }
837
838 static int sahara_sha_hw_data_descriptor_create(struct sahara_dev *dev,
839 struct sahara_sha_reqctx *rctx,
840 struct ahash_request *req,
841 int index)
842 {
843 unsigned result_len;
844 int i = index;
845
846 if (rctx->first)
847 /* Create initial descriptor: #8*/
848 dev->hw_desc[index]->hdr = sahara_sha_init_hdr(dev, rctx);
849 else
850 /* Create hash descriptor: #10. Must follow #6. */
851 dev->hw_desc[index]->hdr = SAHARA_HDR_MDHA_HASH;
852
853 dev->hw_desc[index]->len1 = rctx->total;
854 if (dev->hw_desc[index]->len1 == 0) {
855 /* if len1 is 0, p1 must be 0, too */
856 dev->hw_desc[index]->p1 = 0;
857 rctx->sg_in_idx = 0;
858 } else {
859 /* Create input links */
860 dev->hw_desc[index]->p1 = dev->hw_phys_link[index];
861 i = sahara_sha_hw_links_create(dev, rctx, index);
862
863 rctx->sg_in_idx = index;
864 if (i < 0)
865 return i;
866 }
867
868 dev->hw_desc[index]->p2 = dev->hw_phys_link[i];
869
870 /* Save the context for the next operation */
871 result_len = rctx->context_size;
872 dev->hw_link[i]->p = dev->context_phys_base;
873
874 dev->hw_link[i]->len = result_len;
875 dev->hw_desc[index]->len2 = result_len;
876
877 dev->hw_link[i]->next = 0;
878
879 return 0;
880 }
881
882 /*
883 * Load descriptor aka #6
884 *
885 * To load a previously saved context back to the MDHA unit
886 *
887 * p1: Saved Context
888 * p2: NULL
889 *
890 */
891 static int sahara_sha_hw_context_descriptor_create(struct sahara_dev *dev,
892 struct sahara_sha_reqctx *rctx,
893 struct ahash_request *req,
894 int index)
895 {
896 dev->hw_desc[index]->hdr = sahara_sha_init_hdr(dev, rctx);
897
898 dev->hw_desc[index]->len1 = rctx->context_size;
899 dev->hw_desc[index]->p1 = dev->hw_phys_link[index];
900 dev->hw_desc[index]->len2 = 0;
901 dev->hw_desc[index]->p2 = 0;
902
903 dev->hw_link[index]->len = rctx->context_size;
904 dev->hw_link[index]->p = dev->context_phys_base;
905 dev->hw_link[index]->next = 0;
906
907 return 0;
908 }
909
910 static int sahara_walk_and_recalc(struct scatterlist *sg, unsigned int nbytes)
911 {
912 if (!sg || !sg->length)
913 return nbytes;
914
915 while (nbytes && sg) {
916 if (nbytes <= sg->length) {
917 sg->length = nbytes;
918 sg_mark_end(sg);
919 break;
920 }
921 nbytes -= sg->length;
922 sg = sg_next(sg);
923 }
924
925 return nbytes;
926 }
927
928 static int sahara_sha_prepare_request(struct ahash_request *req)
929 {
930 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
931 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
932 unsigned int hash_later;
933 unsigned int block_size;
934 unsigned int len;
935
936 block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));
937
938 /* append bytes from previous operation */
939 len = rctx->buf_cnt + req->nbytes;
940
941 /* only the last transfer can be padded in hardware */
942 if (!rctx->last && (len < block_size)) {
943 /* to few data, save for next operation */
944 scatterwalk_map_and_copy(rctx->buf + rctx->buf_cnt, req->src,
945 0, req->nbytes, 0);
946 rctx->buf_cnt += req->nbytes;
947
948 return 0;
949 }
950
951 /* add data from previous operation first */
952 if (rctx->buf_cnt)
953 memcpy(rctx->rembuf, rctx->buf, rctx->buf_cnt);
954
955 /* data must always be a multiple of block_size */
956 hash_later = rctx->last ? 0 : len & (block_size - 1);
957 if (hash_later) {
958 unsigned int offset = req->nbytes - hash_later;
959 /* Save remaining bytes for later use */
960 scatterwalk_map_and_copy(rctx->buf, req->src, offset,
961 hash_later, 0);
962 }
963
964 /* nbytes should now be multiple of blocksize */
965 req->nbytes = req->nbytes - hash_later;
966
967 sahara_walk_and_recalc(req->src, req->nbytes);
968
969 /* have data from previous operation and current */
970 if (rctx->buf_cnt && req->nbytes) {
971 sg_init_table(rctx->in_sg_chain, 2);
972 sg_set_buf(rctx->in_sg_chain, rctx->rembuf, rctx->buf_cnt);
973
974 sg_chain(rctx->in_sg_chain, 2, req->src);
975
976 rctx->total = req->nbytes + rctx->buf_cnt;
977 rctx->in_sg = rctx->in_sg_chain;
978
979 req->src = rctx->in_sg_chain;
980 /* only data from previous operation */
981 } else if (rctx->buf_cnt) {
982 if (req->src)
983 rctx->in_sg = req->src;
984 else
985 rctx->in_sg = rctx->in_sg_chain;
986 /* buf was copied into rembuf above */
987 sg_init_one(rctx->in_sg, rctx->rembuf, rctx->buf_cnt);
988 rctx->total = rctx->buf_cnt;
989 /* no data from previous operation */
990 } else {
991 rctx->in_sg = req->src;
992 rctx->total = req->nbytes;
993 req->src = rctx->in_sg;
994 }
995
996 /* on next call, we only have the remaining data in the buffer */
997 rctx->buf_cnt = hash_later;
998
999 return -EINPROGRESS;
1000 }
1001
1002 static int sahara_sha_process(struct ahash_request *req)
1003 {
1004 struct sahara_dev *dev = dev_ptr;
1005 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
1006 int ret;
1007 unsigned long timeout;
1008
1009 ret = sahara_sha_prepare_request(req);
1010 if (!ret)
1011 return ret;
1012
1013 if (rctx->first) {
1014 sahara_sha_hw_data_descriptor_create(dev, rctx, req, 0);
1015 dev->hw_desc[0]->next = 0;
1016 rctx->first = 0;
1017 } else {
1018 memcpy(dev->context_base, rctx->context, rctx->context_size);
1019
1020 sahara_sha_hw_context_descriptor_create(dev, rctx, req, 0);
1021 dev->hw_desc[0]->next = dev->hw_phys_desc[1];
1022 sahara_sha_hw_data_descriptor_create(dev, rctx, req, 1);
1023 dev->hw_desc[1]->next = 0;
1024 }
1025
1026 sahara_dump_descriptors(dev);
1027 sahara_dump_links(dev);
1028
1029 reinit_completion(&dev->dma_completion);
1030
1031 sahara_write(dev, dev->hw_phys_desc[0], SAHARA_REG_DAR);
1032
1033 timeout = wait_for_completion_timeout(&dev->dma_completion,
1034 msecs_to_jiffies(SAHARA_TIMEOUT_MS));
1035 if (!timeout) {
1036 dev_err(dev->device, "SHA timeout\n");
1037 return -ETIMEDOUT;
1038 }
1039
1040 if (rctx->sg_in_idx)
1041 dma_unmap_sg(dev->device, dev->in_sg, dev->nb_in_sg,
1042 DMA_TO_DEVICE);
1043
1044 memcpy(rctx->context, dev->context_base, rctx->context_size);
1045
1046 if (req->result)
1047 memcpy(req->result, rctx->context, rctx->digest_size);
1048
1049 return 0;
1050 }
1051
1052 static int sahara_queue_manage(void *data)
1053 {
1054 struct sahara_dev *dev = (struct sahara_dev *)data;
1055 struct crypto_async_request *async_req;
1056 struct crypto_async_request *backlog;
1057 int ret = 0;
1058
1059 do {
1060 __set_current_state(TASK_INTERRUPTIBLE);
1061
1062 mutex_lock(&dev->queue_mutex);
1063 backlog = crypto_get_backlog(&dev->queue);
1064 async_req = crypto_dequeue_request(&dev->queue);
1065 mutex_unlock(&dev->queue_mutex);
1066
1067 if (backlog)
1068 backlog->complete(backlog, -EINPROGRESS);
1069
1070 if (async_req) {
1071 if (crypto_tfm_alg_type(async_req->tfm) ==
1072 CRYPTO_ALG_TYPE_AHASH) {
1073 struct ahash_request *req =
1074 ahash_request_cast(async_req);
1075
1076 ret = sahara_sha_process(req);
1077 } else {
1078 struct ablkcipher_request *req =
1079 ablkcipher_request_cast(async_req);
1080
1081 ret = sahara_aes_process(req);
1082 }
1083
1084 async_req->complete(async_req, ret);
1085
1086 continue;
1087 }
1088
1089 schedule();
1090 } while (!kthread_should_stop());
1091
1092 return 0;
1093 }
1094
1095 static int sahara_sha_enqueue(struct ahash_request *req, int last)
1096 {
1097 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
1098 struct sahara_dev *dev = dev_ptr;
1099 int ret;
1100
1101 if (!req->nbytes && !last)
1102 return 0;
1103
1104 rctx->last = last;
1105
1106 if (!rctx->active) {
1107 rctx->active = 1;
1108 rctx->first = 1;
1109 }
1110
1111 mutex_lock(&dev->queue_mutex);
1112 ret = crypto_enqueue_request(&dev->queue, &req->base);
1113 mutex_unlock(&dev->queue_mutex);
1114
1115 wake_up_process(dev->kthread);
1116
1117 return ret;
1118 }
1119
1120 static int sahara_sha_init(struct ahash_request *req)
1121 {
1122 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1123 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
1124
1125 memset(rctx, 0, sizeof(*rctx));
1126
1127 switch (crypto_ahash_digestsize(tfm)) {
1128 case SHA1_DIGEST_SIZE:
1129 rctx->mode |= SAHARA_HDR_MDHA_ALG_SHA1;
1130 rctx->digest_size = SHA1_DIGEST_SIZE;
1131 break;
1132 case SHA256_DIGEST_SIZE:
1133 rctx->mode |= SAHARA_HDR_MDHA_ALG_SHA256;
1134 rctx->digest_size = SHA256_DIGEST_SIZE;
1135 break;
1136 default:
1137 return -EINVAL;
1138 }
1139
1140 rctx->context_size = rctx->digest_size + 4;
1141 rctx->active = 0;
1142
1143 return 0;
1144 }
1145
1146 static int sahara_sha_update(struct ahash_request *req)
1147 {
1148 return sahara_sha_enqueue(req, 0);
1149 }
1150
1151 static int sahara_sha_final(struct ahash_request *req)
1152 {
1153 req->nbytes = 0;
1154 return sahara_sha_enqueue(req, 1);
1155 }
1156
1157 static int sahara_sha_finup(struct ahash_request *req)
1158 {
1159 return sahara_sha_enqueue(req, 1);
1160 }
1161
1162 static int sahara_sha_digest(struct ahash_request *req)
1163 {
1164 sahara_sha_init(req);
1165
1166 return sahara_sha_finup(req);
1167 }
1168
1169 static int sahara_sha_export(struct ahash_request *req, void *out)
1170 {
1171 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
1172
1173 memcpy(out, rctx, sizeof(struct sahara_sha_reqctx));
1174
1175 return 0;
1176 }
1177
1178 static int sahara_sha_import(struct ahash_request *req, const void *in)
1179 {
1180 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
1181
1182 memcpy(rctx, in, sizeof(struct sahara_sha_reqctx));
1183
1184 return 0;
1185 }
1186
1187 static int sahara_sha_cra_init(struct crypto_tfm *tfm)
1188 {
1189 crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
1190 sizeof(struct sahara_sha_reqctx) +
1191 SHA_BUFFER_LEN + SHA256_BLOCK_SIZE);
1192
1193 return 0;
1194 }
1195
1196 static struct crypto_alg aes_algs[] = {
1197 {
1198 .cra_name = "ecb(aes)",
1199 .cra_driver_name = "sahara-ecb-aes",
1200 .cra_priority = 300,
1201 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
1202 CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
1203 .cra_blocksize = AES_BLOCK_SIZE,
1204 .cra_ctxsize = sizeof(struct sahara_ctx),
1205 .cra_alignmask = 0x0,
1206 .cra_type = &crypto_ablkcipher_type,
1207 .cra_module = THIS_MODULE,
1208 .cra_init = sahara_aes_cra_init,
1209 .cra_exit = sahara_aes_cra_exit,
1210 .cra_u.ablkcipher = {
1211 .min_keysize = AES_MIN_KEY_SIZE ,
1212 .max_keysize = AES_MAX_KEY_SIZE,
1213 .setkey = sahara_aes_setkey,
1214 .encrypt = sahara_aes_ecb_encrypt,
1215 .decrypt = sahara_aes_ecb_decrypt,
1216 }
1217 }, {
1218 .cra_name = "cbc(aes)",
1219 .cra_driver_name = "sahara-cbc-aes",
1220 .cra_priority = 300,
1221 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
1222 CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
1223 .cra_blocksize = AES_BLOCK_SIZE,
1224 .cra_ctxsize = sizeof(struct sahara_ctx),
1225 .cra_alignmask = 0x0,
1226 .cra_type = &crypto_ablkcipher_type,
1227 .cra_module = THIS_MODULE,
1228 .cra_init = sahara_aes_cra_init,
1229 .cra_exit = sahara_aes_cra_exit,
1230 .cra_u.ablkcipher = {
1231 .min_keysize = AES_MIN_KEY_SIZE ,
1232 .max_keysize = AES_MAX_KEY_SIZE,
1233 .ivsize = AES_BLOCK_SIZE,
1234 .setkey = sahara_aes_setkey,
1235 .encrypt = sahara_aes_cbc_encrypt,
1236 .decrypt = sahara_aes_cbc_decrypt,
1237 }
1238 }
1239 };
1240
1241 static struct ahash_alg sha_v3_algs[] = {
1242 {
1243 .init = sahara_sha_init,
1244 .update = sahara_sha_update,
1245 .final = sahara_sha_final,
1246 .finup = sahara_sha_finup,
1247 .digest = sahara_sha_digest,
1248 .export = sahara_sha_export,
1249 .import = sahara_sha_import,
1250 .halg.digestsize = SHA1_DIGEST_SIZE,
1251 .halg.statesize = sizeof(struct sahara_sha_reqctx),
1252 .halg.base = {
1253 .cra_name = "sha1",
1254 .cra_driver_name = "sahara-sha1",
1255 .cra_priority = 300,
1256 .cra_flags = CRYPTO_ALG_TYPE_AHASH |
1257 CRYPTO_ALG_ASYNC |
1258 CRYPTO_ALG_NEED_FALLBACK,
1259 .cra_blocksize = SHA1_BLOCK_SIZE,
1260 .cra_ctxsize = sizeof(struct sahara_ctx),
1261 .cra_alignmask = 0,
1262 .cra_module = THIS_MODULE,
1263 .cra_init = sahara_sha_cra_init,
1264 }
1265 },
1266 };
1267
1268 static struct ahash_alg sha_v4_algs[] = {
1269 {
1270 .init = sahara_sha_init,
1271 .update = sahara_sha_update,
1272 .final = sahara_sha_final,
1273 .finup = sahara_sha_finup,
1274 .digest = sahara_sha_digest,
1275 .export = sahara_sha_export,
1276 .import = sahara_sha_import,
1277 .halg.digestsize = SHA256_DIGEST_SIZE,
1278 .halg.statesize = sizeof(struct sahara_sha_reqctx),
1279 .halg.base = {
1280 .cra_name = "sha256",
1281 .cra_driver_name = "sahara-sha256",
1282 .cra_priority = 300,
1283 .cra_flags = CRYPTO_ALG_TYPE_AHASH |
1284 CRYPTO_ALG_ASYNC |
1285 CRYPTO_ALG_NEED_FALLBACK,
1286 .cra_blocksize = SHA256_BLOCK_SIZE,
1287 .cra_ctxsize = sizeof(struct sahara_ctx),
1288 .cra_alignmask = 0,
1289 .cra_module = THIS_MODULE,
1290 .cra_init = sahara_sha_cra_init,
1291 }
1292 },
1293 };
1294
1295 static irqreturn_t sahara_irq_handler(int irq, void *data)
1296 {
1297 struct sahara_dev *dev = (struct sahara_dev *)data;
1298 unsigned int stat = sahara_read(dev, SAHARA_REG_STATUS);
1299 unsigned int err = sahara_read(dev, SAHARA_REG_ERRSTATUS);
1300
1301 sahara_write(dev, SAHARA_CMD_CLEAR_INT | SAHARA_CMD_CLEAR_ERR,
1302 SAHARA_REG_CMD);
1303
1304 sahara_decode_status(dev, stat);
1305
1306 if (SAHARA_STATUS_GET_STATE(stat) == SAHARA_STATE_BUSY) {
1307 return IRQ_NONE;
1308 } else if (SAHARA_STATUS_GET_STATE(stat) == SAHARA_STATE_COMPLETE) {
1309 dev->error = 0;
1310 } else {
1311 sahara_decode_error(dev, err);
1312 dev->error = -EINVAL;
1313 }
1314
1315 complete(&dev->dma_completion);
1316
1317 return IRQ_HANDLED;
1318 }
1319
1320
1321 static int sahara_register_algs(struct sahara_dev *dev)
1322 {
1323 int err;
1324 unsigned int i, j, k, l;
1325
1326 for (i = 0; i < ARRAY_SIZE(aes_algs); i++) {
1327 INIT_LIST_HEAD(&aes_algs[i].cra_list);
1328 err = crypto_register_alg(&aes_algs[i]);
1329 if (err)
1330 goto err_aes_algs;
1331 }
1332
1333 for (k = 0; k < ARRAY_SIZE(sha_v3_algs); k++) {
1334 err = crypto_register_ahash(&sha_v3_algs[k]);
1335 if (err)
1336 goto err_sha_v3_algs;
1337 }
1338
1339 if (dev->version > SAHARA_VERSION_3)
1340 for (l = 0; l < ARRAY_SIZE(sha_v4_algs); l++) {
1341 err = crypto_register_ahash(&sha_v4_algs[l]);
1342 if (err)
1343 goto err_sha_v4_algs;
1344 }
1345
1346 return 0;
1347
1348 err_sha_v4_algs:
1349 for (j = 0; j < l; j++)
1350 crypto_unregister_ahash(&sha_v4_algs[j]);
1351
1352 err_sha_v3_algs:
1353 for (j = 0; j < k; j++)
1354 crypto_unregister_ahash(&sha_v4_algs[j]);
1355
1356 err_aes_algs:
1357 for (j = 0; j < i; j++)
1358 crypto_unregister_alg(&aes_algs[j]);
1359
1360 return err;
1361 }
1362
1363 static void sahara_unregister_algs(struct sahara_dev *dev)
1364 {
1365 unsigned int i;
1366
1367 for (i = 0; i < ARRAY_SIZE(aes_algs); i++)
1368 crypto_unregister_alg(&aes_algs[i]);
1369
1370 for (i = 0; i < ARRAY_SIZE(sha_v4_algs); i++)
1371 crypto_unregister_ahash(&sha_v3_algs[i]);
1372
1373 if (dev->version > SAHARA_VERSION_3)
1374 for (i = 0; i < ARRAY_SIZE(sha_v4_algs); i++)
1375 crypto_unregister_ahash(&sha_v4_algs[i]);
1376 }
1377
1378 static const struct platform_device_id sahara_platform_ids[] = {
1379 { .name = "sahara-imx27" },
1380 { /* sentinel */ }
1381 };
1382 MODULE_DEVICE_TABLE(platform, sahara_platform_ids);
1383
1384 static const struct of_device_id sahara_dt_ids[] = {
1385 { .compatible = "fsl,imx53-sahara" },
1386 { .compatible = "fsl,imx27-sahara" },
1387 { /* sentinel */ }
1388 };
1389 MODULE_DEVICE_TABLE(of, sahara_dt_ids);
1390
1391 static int sahara_probe(struct platform_device *pdev)
1392 {
1393 struct sahara_dev *dev;
1394 struct resource *res;
1395 u32 version;
1396 int irq;
1397 int err;
1398 int i;
1399
1400 dev = devm_kzalloc(&pdev->dev, sizeof(struct sahara_dev), GFP_KERNEL);
1401 if (dev == NULL) {
1402 dev_err(&pdev->dev, "unable to alloc data struct.\n");
1403 return -ENOMEM;
1404 }
1405
1406 dev->device = &pdev->dev;
1407 platform_set_drvdata(pdev, dev);
1408
1409 /* Get the base address */
1410 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1411 dev->regs_base = devm_ioremap_resource(&pdev->dev, res);
1412 if (IS_ERR(dev->regs_base))
1413 return PTR_ERR(dev->regs_base);
1414
1415 /* Get the IRQ */
1416 irq = platform_get_irq(pdev, 0);
1417 if (irq < 0) {
1418 dev_err(&pdev->dev, "failed to get irq resource\n");
1419 return irq;
1420 }
1421
1422 err = devm_request_irq(&pdev->dev, irq, sahara_irq_handler,
1423 0, dev_name(&pdev->dev), dev);
1424 if (err) {
1425 dev_err(&pdev->dev, "failed to request irq\n");
1426 return err;
1427 }
1428
1429 /* clocks */
1430 dev->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
1431 if (IS_ERR(dev->clk_ipg)) {
1432 dev_err(&pdev->dev, "Could not get ipg clock\n");
1433 return PTR_ERR(dev->clk_ipg);
1434 }
1435
1436 dev->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
1437 if (IS_ERR(dev->clk_ahb)) {
1438 dev_err(&pdev->dev, "Could not get ahb clock\n");
1439 return PTR_ERR(dev->clk_ahb);
1440 }
1441
1442 /* Allocate HW descriptors */
1443 dev->hw_desc[0] = dmam_alloc_coherent(&pdev->dev,
1444 SAHARA_MAX_HW_DESC * sizeof(struct sahara_hw_desc),
1445 &dev->hw_phys_desc[0], GFP_KERNEL);
1446 if (!dev->hw_desc[0]) {
1447 dev_err(&pdev->dev, "Could not allocate hw descriptors\n");
1448 return -ENOMEM;
1449 }
1450 dev->hw_desc[1] = dev->hw_desc[0] + 1;
1451 dev->hw_phys_desc[1] = dev->hw_phys_desc[0] +
1452 sizeof(struct sahara_hw_desc);
1453
1454 /* Allocate space for iv and key */
1455 dev->key_base = dmam_alloc_coherent(&pdev->dev, 2 * AES_KEYSIZE_128,
1456 &dev->key_phys_base, GFP_KERNEL);
1457 if (!dev->key_base) {
1458 dev_err(&pdev->dev, "Could not allocate memory for key\n");
1459 return -ENOMEM;
1460 }
1461 dev->iv_base = dev->key_base + AES_KEYSIZE_128;
1462 dev->iv_phys_base = dev->key_phys_base + AES_KEYSIZE_128;
1463
1464 /* Allocate space for context: largest digest + message length field */
1465 dev->context_base = dmam_alloc_coherent(&pdev->dev,
1466 SHA256_DIGEST_SIZE + 4,
1467 &dev->context_phys_base, GFP_KERNEL);
1468 if (!dev->context_base) {
1469 dev_err(&pdev->dev, "Could not allocate memory for MDHA context\n");
1470 return -ENOMEM;
1471 }
1472
1473 /* Allocate space for HW links */
1474 dev->hw_link[0] = dmam_alloc_coherent(&pdev->dev,
1475 SAHARA_MAX_HW_LINK * sizeof(struct sahara_hw_link),
1476 &dev->hw_phys_link[0], GFP_KERNEL);
1477 if (!dev->hw_link[0]) {
1478 dev_err(&pdev->dev, "Could not allocate hw links\n");
1479 return -ENOMEM;
1480 }
1481 for (i = 1; i < SAHARA_MAX_HW_LINK; i++) {
1482 dev->hw_phys_link[i] = dev->hw_phys_link[i - 1] +
1483 sizeof(struct sahara_hw_link);
1484 dev->hw_link[i] = dev->hw_link[i - 1] + 1;
1485 }
1486
1487 crypto_init_queue(&dev->queue, SAHARA_QUEUE_LENGTH);
1488
1489 mutex_init(&dev->queue_mutex);
1490
1491 dev_ptr = dev;
1492
1493 dev->kthread = kthread_run(sahara_queue_manage, dev, "sahara_crypto");
1494 if (IS_ERR(dev->kthread)) {
1495 return PTR_ERR(dev->kthread);
1496 }
1497
1498 init_completion(&dev->dma_completion);
1499
1500 err = clk_prepare_enable(dev->clk_ipg);
1501 if (err)
1502 return err;
1503 err = clk_prepare_enable(dev->clk_ahb);
1504 if (err)
1505 goto clk_ipg_disable;
1506
1507 version = sahara_read(dev, SAHARA_REG_VERSION);
1508 if (of_device_is_compatible(pdev->dev.of_node, "fsl,imx27-sahara")) {
1509 if (version != SAHARA_VERSION_3)
1510 err = -ENODEV;
1511 } else if (of_device_is_compatible(pdev->dev.of_node,
1512 "fsl,imx53-sahara")) {
1513 if (((version >> 8) & 0xff) != SAHARA_VERSION_4)
1514 err = -ENODEV;
1515 version = (version >> 8) & 0xff;
1516 }
1517 if (err == -ENODEV) {
1518 dev_err(&pdev->dev, "SAHARA version %d not supported\n",
1519 version);
1520 goto err_algs;
1521 }
1522
1523 dev->version = version;
1524
1525 sahara_write(dev, SAHARA_CMD_RESET | SAHARA_CMD_MODE_BATCH,
1526 SAHARA_REG_CMD);
1527 sahara_write(dev, SAHARA_CONTROL_SET_THROTTLE(0) |
1528 SAHARA_CONTROL_SET_MAXBURST(8) |
1529 SAHARA_CONTROL_RNG_AUTORSD |
1530 SAHARA_CONTROL_ENABLE_INT,
1531 SAHARA_REG_CONTROL);
1532
1533 err = sahara_register_algs(dev);
1534 if (err)
1535 goto err_algs;
1536
1537 dev_info(&pdev->dev, "SAHARA version %d initialized\n", version);
1538
1539 return 0;
1540
1541 err_algs:
1542 kthread_stop(dev->kthread);
1543 dev_ptr = NULL;
1544 clk_disable_unprepare(dev->clk_ahb);
1545 clk_ipg_disable:
1546 clk_disable_unprepare(dev->clk_ipg);
1547
1548 return err;
1549 }
1550
1551 static int sahara_remove(struct platform_device *pdev)
1552 {
1553 struct sahara_dev *dev = platform_get_drvdata(pdev);
1554
1555 kthread_stop(dev->kthread);
1556
1557 sahara_unregister_algs(dev);
1558
1559 clk_disable_unprepare(dev->clk_ipg);
1560 clk_disable_unprepare(dev->clk_ahb);
1561
1562 dev_ptr = NULL;
1563
1564 return 0;
1565 }
1566
1567 static struct platform_driver sahara_driver = {
1568 .probe = sahara_probe,
1569 .remove = sahara_remove,
1570 .driver = {
1571 .name = SAHARA_NAME,
1572 .of_match_table = sahara_dt_ids,
1573 },
1574 .id_table = sahara_platform_ids,
1575 };
1576
1577 module_platform_driver(sahara_driver);
1578
1579 MODULE_LICENSE("GPL");
1580 MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>");
1581 MODULE_AUTHOR("Steffen Trumtrar <s.trumtrar@pengutronix.de>");
1582 MODULE_DESCRIPTION("SAHARA2 HW crypto accelerator");
ubuntu-bionic-kernel mirror