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