projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
drop the bootscript, new u-boots won't need it
[openwrt/openwrt.git] / target / linux / omap / patches-3.12 / 600-crypto-omap-des-Add-omap-des-driver-for-OMAP4-AM43xx.patch
1 From patchwork Thu Aug 29 23:27:51 2013
2 Content-Type: text/plain; charset="utf-8"
3 MIME-Version: 1.0
4 Content-Transfer-Encoding: 7bit
5 Subject: [1/3] crypto: omap-des: Add omap-des driver for OMAP4/AM43xx
6 From: Joel Fernandes <joelf@ti.com>
7 X-Patchwork-Id: 2851675
8 Message-Id: <1377818873-21174-2-git-send-email-joelf@ti.com>
9 To: Herbert Xu <herbert@gondor.hengli.com.au>, "David S. Miller"
10 <davem@davemloft.net>, Mark Greer <mgreer@animalcreek.com>, Tony Lindgren
11 <tony@atomide.com>, Lokesh Vutla <lokeshvutla@ti.com>
12 Cc: Joel Fernandes <joelf@ti.com>,
13 Linux OMAP List <linux-omap@vger.kernel.org>,
14 Linux Kernel Mailing List <linux-kernel@vger.kernel.org>,
15 Linux ARM Kernel List <linux-arm-kernel@lists.infradead.org>,
16 Linux Crypto Mailing List <linux-crypto@vger.kernel.org>
17 Date: Thu, 29 Aug 2013 18:27:51 -0500
18
19 Add omap-des driver with platform data for OMAP4. Support added for DES
20 ECB and CBC modes.
21
22 Where possible, code is reused from omap-aes driver with changes made for
23 adjusting key size, block size, removing non-existent encryption modes
24 and adding support for OMAP4 platform data and offsets.
25
26 Tests have been conducted with the CRYPTO test manager, and functionality
27 is verified at different page length alignments.
28
29 Signed-off-by: Joel Fernandes <joelf@ti.com>
30
31 ---
32 drivers/crypto/omap-des.c | 1192 +++++++++++++++++++++++++++++++++++++++++++++
33 1 file changed, 1192 insertions(+)
34 create mode 100644 drivers/crypto/omap-des.c
35
36 --- /dev/null
37 +++ b/drivers/crypto/omap-des.c
38 @@ -0,0 +1,1192 @@
39 +/*
40 + * Cryptographic API.
41 + *
42 + * Support for OMAP DES and Triple DES HW acceleration.
43 + *
44 + * Copyright (c) 2012 Texas Instruments Incorporated
45 + * Author: Joel Fernandes <joelf@ti.com>
46 + *
47 + * This program is free software; you can redistribute it and/or modify
48 + * it under the terms of the GNU General Public License version 2 as published
49 + * by the Free Software Foundation.
50 + *
51 + */
52 +
53 +#define pr_fmt(fmt) "%s: " fmt, __func__
54 +
55 +#ifdef DEBUG
56 +#define prn(num) printk(#num "=%d\n", num)
57 +#define prx(num) printk(#num "=%x\n", num)
58 +#else
59 +#define prn(num) do { } while (0)
60 +#define prx(num) do { } while (0)
61 +#endif
62 +
63 +#include <linux/err.h>
64 +#include <linux/module.h>
65 +#include <linux/init.h>
66 +#include <linux/errno.h>
67 +#include <linux/kernel.h>
68 +#include <linux/platform_device.h>
69 +#include <linux/scatterlist.h>
70 +#include <linux/dma-mapping.h>
71 +#include <linux/dmaengine.h>
72 +#include <linux/omap-dma.h>
73 +#include <linux/pm_runtime.h>
74 +#include <linux/of.h>
75 +#include <linux/of_device.h>
76 +#include <linux/of_address.h>
77 +#include <linux/io.h>
78 +#include <linux/crypto.h>
79 +#include <linux/interrupt.h>
80 +#include <crypto/scatterwalk.h>
81 +#include <crypto/des.h>
82 +
83 +#define DST_MAXBURST 2
84 +
85 +#define DES_BLOCK_WORDS (DES_BLOCK_SIZE >> 2)
86 +
87 +#define _calc_walked(inout) (dd->inout##_walk.offset - dd->inout##_sg->offset)
88 +
89 +#define DES_REG_KEY(dd, x) ((dd)->pdata->key_ofs - \
90 + ((x ^ 0x01) * 0x04))
91 +
92 +#define DES_REG_IV(dd, x) ((dd)->pdata->iv_ofs + ((x) * 0x04))
93 +
94 +#define DES_REG_CTRL(dd) ((dd)->pdata->ctrl_ofs)
95 +#define DES_REG_CTRL_CBC (1 << 4)
96 +#define DES_REG_CTRL_TDES (1 << 3)
97 +#define DES_REG_CTRL_DIRECTION (1 << 2)
98 +#define DES_REG_CTRL_INPUT_READY (1 << 1)
99 +#define DES_REG_CTRL_OUTPUT_READY (1 << 0)
100 +
101 +#define DES_REG_DATA_N(dd, x) ((dd)->pdata->data_ofs + ((x) * 0x04))
102 +
103 +#define DES_REG_REV(dd) ((dd)->pdata->rev_ofs)
104 +
105 +#define DES_REG_MASK(dd) ((dd)->pdata->mask_ofs)
106 +
107 +#define DES_REG_LENGTH_N(x) (0x24 + ((x) * 0x04))
108 +
109 +#define DES_REG_IRQ_STATUS(dd) ((dd)->pdata->irq_status_ofs)
110 +#define DES_REG_IRQ_ENABLE(dd) ((dd)->pdata->irq_enable_ofs)
111 +#define DES_REG_IRQ_DATA_IN BIT(1)
112 +#define DES_REG_IRQ_DATA_OUT BIT(2)
113 +
114 +#define FLAGS_MODE_MASK 0x000f
115 +#define FLAGS_ENCRYPT BIT(0)
116 +#define FLAGS_CBC BIT(1)
117 +#define FLAGS_INIT BIT(4)
118 +#define FLAGS_BUSY BIT(6)
119 +
120 +struct omap_des_ctx {
121 + struct omap_des_dev *dd;
122 +
123 + int keylen;
124 + u32 key[DES_KEY_SIZE / sizeof(u32)];
125 + unsigned long flags;
126 +};
127 +
128 +struct omap_des_reqctx {
129 + unsigned long mode;
130 +};
131 +
132 +#define OMAP_DES_QUEUE_LENGTH 1
133 +#define OMAP_DES_CACHE_SIZE 0
134 +
135 +struct omap_des_algs_info {
136 + struct crypto_alg *algs_list;
137 + unsigned int size;
138 + unsigned int registered;
139 +};
140 +
141 +struct omap_des_pdata {
142 + struct omap_des_algs_info *algs_info;
143 + unsigned int algs_info_size;
144 +
145 + void (*trigger)(struct omap_des_dev *dd, int length);
146 +
147 + u32 key_ofs;
148 + u32 iv_ofs;
149 + u32 ctrl_ofs;
150 + u32 data_ofs;
151 + u32 rev_ofs;
152 + u32 mask_ofs;
153 + u32 irq_enable_ofs;
154 + u32 irq_status_ofs;
155 +
156 + u32 dma_enable_in;
157 + u32 dma_enable_out;
158 + u32 dma_start;
159 +
160 + u32 major_mask;
161 + u32 major_shift;
162 + u32 minor_mask;
163 + u32 minor_shift;
164 +};
165 +
166 +struct omap_des_dev {
167 + struct list_head list;
168 + unsigned long phys_base;
169 + void __iomem *io_base;
170 + struct omap_des_ctx *ctx;
171 + struct device *dev;
172 + unsigned long flags;
173 + int err;
174 +
175 + /* spinlock used for queues */
176 + spinlock_t lock;
177 + struct crypto_queue queue;
178 +
179 + struct tasklet_struct done_task;
180 + struct tasklet_struct queue_task;
181 +
182 + struct ablkcipher_request *req;
183 + /*
184 + * total is used by PIO mode for book keeping so introduce
185 + * variable total_save as need it to calc page_order
186 + */
187 + size_t total;
188 + size_t total_save;
189 +
190 + struct scatterlist *in_sg;
191 + struct scatterlist *out_sg;
192 +
193 + /* Buffers for copying for unaligned cases */
194 + struct scatterlist in_sgl;
195 + struct scatterlist out_sgl;
196 + struct scatterlist *orig_out;
197 + int sgs_copied;
198 +
199 + struct scatter_walk in_walk;
200 + struct scatter_walk out_walk;
201 + int dma_in;
202 + struct dma_chan *dma_lch_in;
203 + int dma_out;
204 + struct dma_chan *dma_lch_out;
205 + int in_sg_len;
206 + int out_sg_len;
207 + int pio_only;
208 + const struct omap_des_pdata *pdata;
209 +};
210 +
211 +/* keep registered devices data here */
212 +static LIST_HEAD(dev_list);
213 +static DEFINE_SPINLOCK(list_lock);
214 +
215 +#ifdef DEBUG
216 +#define omap_des_read(dd, offset) \
217 + ({ \
218 + int _read_ret; \
219 + _read_ret = __raw_readl(dd->io_base + offset); \
220 + pr_err("omap_des_read(" #offset "=%#x)= %#x\n", \
221 + offset, _read_ret); \
222 + _read_ret; \
223 + })
224 +#else
225 +static inline u32 omap_des_read(struct omap_des_dev *dd, u32 offset)
226 +{
227 + return __raw_readl(dd->io_base + offset);
228 +}
229 +#endif
230 +
231 +#ifdef DEBUG
232 +#define omap_des_write(dd, offset, value) \
233 + do { \
234 + pr_err("omap_des_write(" #offset "=%#x) value=%#x\n", \
235 + offset, value); \
236 + __raw_writel(value, dd->io_base + offset); \
237 + } while (0)
238 +#else
239 +static inline void omap_des_write(struct omap_des_dev *dd, u32 offset,
240 + u32 value)
241 +{
242 + __raw_writel(value, dd->io_base + offset);
243 +}
244 +#endif
245 +
246 +static inline void omap_des_write_mask(struct omap_des_dev *dd, u32 offset,
247 + u32 value, u32 mask)
248 +{
249 + u32 val;
250 +
251 + val = omap_des_read(dd, offset);
252 + val &= ~mask;
253 + val |= value;
254 + omap_des_write(dd, offset, val);
255 +}
256 +
257 +static void omap_des_write_n(struct omap_des_dev *dd, u32 offset,
258 + u32 *value, int count)
259 +{
260 + for (; count--; value++, offset += 4)
261 + omap_des_write(dd, offset, *value);
262 +}
263 +
264 +static int omap_des_hw_init(struct omap_des_dev *dd)
265 +{
266 + /*
267 + * clocks are enabled when request starts and disabled when finished.
268 + * It may be long delays between requests.
269 + * Device might go to off mode to save power.
270 + */
271 + pm_runtime_get_sync(dd->dev);
272 +
273 + if (!(dd->flags & FLAGS_INIT)) {
274 + dd->flags |= FLAGS_INIT;
275 + dd->err = 0;
276 + }
277 +
278 + return 0;
279 +}
280 +
281 +static int omap_des_write_ctrl(struct omap_des_dev *dd)
282 +{
283 + unsigned int key32;
284 + int i, err;
285 + u32 val = 0, mask = 0;
286 +
287 + err = omap_des_hw_init(dd);
288 + if (err)
289 + return err;
290 +
291 + key32 = dd->ctx->keylen / sizeof(u32);
292 +
293 + /* it seems a key should always be set even if it has not changed */
294 + for (i = 0; i < key32; i++) {
295 + omap_des_write(dd, DES_REG_KEY(dd, i),
296 + __le32_to_cpu(dd->ctx->key[i]));
297 + }
298 +
299 + if ((dd->flags & FLAGS_CBC) && dd->req->info)
300 + omap_des_write_n(dd, DES_REG_IV(dd, 0), dd->req->info, 2);
301 +
302 + if (dd->flags & FLAGS_CBC)
303 + val |= DES_REG_CTRL_CBC;
304 + if (dd->flags & FLAGS_ENCRYPT)
305 + val |= DES_REG_CTRL_DIRECTION;
306 +
307 + mask |= DES_REG_CTRL_CBC | DES_REG_CTRL_DIRECTION;
308 +
309 + omap_des_write_mask(dd, DES_REG_CTRL(dd), val, mask);
310 +
311 + return 0;
312 +}
313 +
314 +static void omap_des_dma_trigger_omap4(struct omap_des_dev *dd, int length)
315 +{
316 + u32 mask, val;
317 +
318 + omap_des_write(dd, DES_REG_LENGTH_N(0), length);
319 +
320 + val = dd->pdata->dma_start;
321 +
322 + if (dd->dma_lch_out != NULL)
323 + val |= dd->pdata->dma_enable_out;
324 + if (dd->dma_lch_in != NULL)
325 + val |= dd->pdata->dma_enable_in;
326 +
327 + mask = dd->pdata->dma_enable_out | dd->pdata->dma_enable_in |
328 + dd->pdata->dma_start;
329 +
330 + omap_des_write_mask(dd, DES_REG_MASK(dd), val, mask);
331 +}
332 +
333 +static void omap_des_dma_stop(struct omap_des_dev *dd)
334 +{
335 + u32 mask;
336 +
337 + mask = dd->pdata->dma_enable_out | dd->pdata->dma_enable_in |
338 + dd->pdata->dma_start;
339 +
340 + omap_des_write_mask(dd, DES_REG_MASK(dd), 0, mask);
341 +}
342 +
343 +static struct omap_des_dev *omap_des_find_dev(struct omap_des_ctx *ctx)
344 +{
345 + struct omap_des_dev *dd = NULL, *tmp;
346 +
347 + spin_lock_bh(&list_lock);
348 + if (!ctx->dd) {
349 + list_for_each_entry(tmp, &dev_list, list) {
350 + /* FIXME: take fist available des core */
351 + dd = tmp;
352 + break;
353 + }
354 + ctx->dd = dd;
355 + } else {
356 + /* already found before */
357 + dd = ctx->dd;
358 + }
359 + spin_unlock_bh(&list_lock);
360 +
361 + return dd;
362 +}
363 +
364 +static void omap_des_dma_out_callback(void *data)
365 +{
366 + struct omap_des_dev *dd = data;
367 +
368 + /* dma_lch_out - completed */
369 + tasklet_schedule(&dd->done_task);
370 +}
371 +
372 +static int omap_des_dma_init(struct omap_des_dev *dd)
373 +{
374 + int err = -ENOMEM;
375 + dma_cap_mask_t mask;
376 +
377 + dd->dma_lch_out = NULL;
378 + dd->dma_lch_in = NULL;
379 +
380 + dma_cap_zero(mask);
381 + dma_cap_set(DMA_SLAVE, mask);
382 +
383 + dd->dma_lch_in = dma_request_slave_channel_compat(mask,
384 + omap_dma_filter_fn,
385 + &dd->dma_in,
386 + dd->dev, "rx");
387 + if (!dd->dma_lch_in) {
388 + dev_err(dd->dev, "Unable to request in DMA channel\n");
389 + goto err_dma_in;
390 + }
391 +
392 + dd->dma_lch_out = dma_request_slave_channel_compat(mask,
393 + omap_dma_filter_fn,
394 + &dd->dma_out,
395 + dd->dev, "tx");
396 + if (!dd->dma_lch_out) {
397 + dev_err(dd->dev, "Unable to request out DMA channel\n");
398 + goto err_dma_out;
399 + }
400 +
401 + return 0;
402 +
403 +err_dma_out:
404 + dma_release_channel(dd->dma_lch_in);
405 +err_dma_in:
406 + if (err)
407 + pr_err("error: %d\n", err);
408 + return err;
409 +}
410 +
411 +static void omap_des_dma_cleanup(struct omap_des_dev *dd)
412 +{
413 + dma_release_channel(dd->dma_lch_out);
414 + dma_release_channel(dd->dma_lch_in);
415 +}
416 +
417 +static void sg_copy_buf(void *buf, struct scatterlist *sg,
418 + unsigned int start, unsigned int nbytes, int out)
419 +{
420 + struct scatter_walk walk;
421 +
422 + if (!nbytes)
423 + return;
424 +
425 + scatterwalk_start(&walk, sg);
426 + scatterwalk_advance(&walk, start);
427 + scatterwalk_copychunks(buf, &walk, nbytes, out);
428 + scatterwalk_done(&walk, out, 0);
429 +}
430 +
431 +static int omap_des_crypt_dma(struct crypto_tfm *tfm,
432 + struct scatterlist *in_sg, struct scatterlist *out_sg,
433 + int in_sg_len, int out_sg_len)
434 +{
435 + struct omap_des_ctx *ctx = crypto_tfm_ctx(tfm);
436 + struct omap_des_dev *dd = ctx->dd;
437 + struct dma_async_tx_descriptor *tx_in, *tx_out;
438 + struct dma_slave_config cfg;
439 + int ret;
440 +
441 + if (dd->pio_only) {
442 + scatterwalk_start(&dd->in_walk, dd->in_sg);
443 + scatterwalk_start(&dd->out_walk, dd->out_sg);
444 +
445 + /* Enable DATAIN interrupt and let it take
446 + care of the rest */
447 + omap_des_write(dd, DES_REG_IRQ_ENABLE(dd), 0x2);
448 + return 0;
449 + }
450 +
451 + dma_sync_sg_for_device(dd->dev, dd->in_sg, in_sg_len, DMA_TO_DEVICE);
452 +
453 + memset(&cfg, 0, sizeof(cfg));
454 +
455 + cfg.src_addr = dd->phys_base + DES_REG_DATA_N(dd, 0);
456 + cfg.dst_addr = dd->phys_base + DES_REG_DATA_N(dd, 0);
457 + cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
458 + cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
459 + cfg.src_maxburst = DST_MAXBURST;
460 + cfg.dst_maxburst = DST_MAXBURST;
461 +
462 + /* IN */
463 + ret = dmaengine_slave_config(dd->dma_lch_in, &cfg);
464 + if (ret) {
465 + dev_err(dd->dev, "can't configure IN dmaengine slave: %d\n",
466 + ret);
467 + return ret;
468 + }
469 +
470 + tx_in = dmaengine_prep_slave_sg(dd->dma_lch_in, in_sg, in_sg_len,
471 + DMA_MEM_TO_DEV,
472 + DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
473 + if (!tx_in) {
474 + dev_err(dd->dev, "IN prep_slave_sg() failed\n");
475 + return -EINVAL;
476 + }
477 +
478 + /* No callback necessary */
479 + tx_in->callback_param = dd;
480 +
481 + /* OUT */
482 + ret = dmaengine_slave_config(dd->dma_lch_out, &cfg);
483 + if (ret) {
484 + dev_err(dd->dev, "can't configure OUT dmaengine slave: %d\n",
485 + ret);
486 + return ret;
487 + }
488 +
489 + tx_out = dmaengine_prep_slave_sg(dd->dma_lch_out, out_sg, out_sg_len,
490 + DMA_DEV_TO_MEM,
491 + DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
492 + if (!tx_out) {
493 + dev_err(dd->dev, "OUT prep_slave_sg() failed\n");
494 + return -EINVAL;
495 + }
496 +
497 + tx_out->callback = omap_des_dma_out_callback;
498 + tx_out->callback_param = dd;
499 +
500 + dmaengine_submit(tx_in);
501 + dmaengine_submit(tx_out);
502 +
503 + dma_async_issue_pending(dd->dma_lch_in);
504 + dma_async_issue_pending(dd->dma_lch_out);
505 +
506 + /* start DMA */
507 + dd->pdata->trigger(dd, dd->total);
508 +
509 + return 0;
510 +}
511 +
512 +static int omap_des_crypt_dma_start(struct omap_des_dev *dd)
513 +{
514 + struct crypto_tfm *tfm = crypto_ablkcipher_tfm(
515 + crypto_ablkcipher_reqtfm(dd->req));
516 + int err;
517 +
518 + pr_debug("total: %d\n", dd->total);
519 +
520 + if (!dd->pio_only) {
521 + err = dma_map_sg(dd->dev, dd->in_sg, dd->in_sg_len,
522 + DMA_TO_DEVICE);
523 + if (!err) {
524 + dev_err(dd->dev, "dma_map_sg() error\n");
525 + return -EINVAL;
526 + }
527 +
528 + err = dma_map_sg(dd->dev, dd->out_sg, dd->out_sg_len,
529 + DMA_FROM_DEVICE);
530 + if (!err) {
531 + dev_err(dd->dev, "dma_map_sg() error\n");
532 + return -EINVAL;
533 + }
534 + }
535 +
536 + err = omap_des_crypt_dma(tfm, dd->in_sg, dd->out_sg, dd->in_sg_len,
537 + dd->out_sg_len);
538 + if (err && !dd->pio_only) {
539 + dma_unmap_sg(dd->dev, dd->in_sg, dd->in_sg_len, DMA_TO_DEVICE);
540 + dma_unmap_sg(dd->dev, dd->out_sg, dd->out_sg_len,
541 + DMA_FROM_DEVICE);
542 + }
543 +
544 + return err;
545 +}
546 +
547 +static void omap_des_finish_req(struct omap_des_dev *dd, int err)
548 +{
549 + struct ablkcipher_request *req = dd->req;
550 +
551 + pr_debug("err: %d\n", err);
552 +
553 + pm_runtime_put(dd->dev);
554 + dd->flags &= ~FLAGS_BUSY;
555 +
556 + req->base.complete(&req->base, err);
557 +}
558 +
559 +static int omap_des_crypt_dma_stop(struct omap_des_dev *dd)
560 +{
561 + int err = 0;
562 +
563 + pr_debug("total: %d\n", dd->total);
564 +
565 + omap_des_dma_stop(dd);
566 +
567 + dmaengine_terminate_all(dd->dma_lch_in);
568 + dmaengine_terminate_all(dd->dma_lch_out);
569 +
570 + dma_unmap_sg(dd->dev, dd->in_sg, dd->in_sg_len, DMA_TO_DEVICE);
571 + dma_unmap_sg(dd->dev, dd->out_sg, dd->out_sg_len, DMA_FROM_DEVICE);
572 +
573 + return err;
574 +}
575 +
576 +int omap_des_copy_needed(struct scatterlist *sg)
577 +{
578 + while (sg) {
579 + if (!IS_ALIGNED(sg->offset, 4))
580 + return -1;
581 + if (!IS_ALIGNED(sg->length, DES_BLOCK_SIZE))
582 + return -1;
583 + sg = sg_next(sg);
584 + }
585 + return 0;
586 +}
587 +
588 +int omap_des_copy_sgs(struct omap_des_dev *dd)
589 +{
590 + void *buf_in, *buf_out;
591 + int pages;
592 +
593 + pages = dd->total >> PAGE_SHIFT;
594 +
595 + if (dd->total & (PAGE_SIZE-1))
596 + pages++;
597 +
598 + BUG_ON(!pages);
599 +
600 + buf_in = (void *)__get_free_pages(GFP_ATOMIC, pages);
601 + buf_out = (void *)__get_free_pages(GFP_ATOMIC, pages);
602 +
603 + if (!buf_in || !buf_out) {
604 + pr_err("Couldn't allocated pages for unaligned cases.\n");
605 + return -1;
606 + }
607 +
608 + dd->orig_out = dd->out_sg;
609 +
610 + sg_copy_buf(buf_in, dd->in_sg, 0, dd->total, 0);
611 +
612 + sg_init_table(&dd->in_sgl, 1);
613 + sg_set_buf(&dd->in_sgl, buf_in, dd->total);
614 + dd->in_sg = &dd->in_sgl;
615 +
616 + sg_init_table(&dd->out_sgl, 1);
617 + sg_set_buf(&dd->out_sgl, buf_out, dd->total);
618 + dd->out_sg = &dd->out_sgl;
619 +
620 + return 0;
621 +}
622 +
623 +static int omap_des_handle_queue(struct omap_des_dev *dd,
624 + struct ablkcipher_request *req)
625 +{
626 + struct crypto_async_request *async_req, *backlog;
627 + struct omap_des_ctx *ctx;
628 + struct omap_des_reqctx *rctx;
629 + unsigned long flags;
630 + int err, ret = 0;
631 +
632 + spin_lock_irqsave(&dd->lock, flags);
633 + if (req)
634 + ret = ablkcipher_enqueue_request(&dd->queue, req);
635 + if (dd->flags & FLAGS_BUSY) {
636 + spin_unlock_irqrestore(&dd->lock, flags);
637 + return ret;
638 + }
639 + backlog = crypto_get_backlog(&dd->queue);
640 + async_req = crypto_dequeue_request(&dd->queue);
641 + if (async_req)
642 + dd->flags |= FLAGS_BUSY;
643 + spin_unlock_irqrestore(&dd->lock, flags);
644 +
645 + if (!async_req)
646 + return ret;
647 +
648 + if (backlog)
649 + backlog->complete(backlog, -EINPROGRESS);
650 +
651 + req = ablkcipher_request_cast(async_req);
652 +
653 + /* assign new request to device */
654 + dd->req = req;
655 + dd->total = req->nbytes;
656 + dd->total_save = req->nbytes;
657 + dd->in_sg = req->src;
658 + dd->out_sg = req->dst;
659 +
660 + if (omap_des_copy_needed(dd->in_sg) ||
661 + omap_des_copy_needed(dd->out_sg)) {
662 + if (omap_des_copy_sgs(dd))
663 + pr_err("Failed to copy SGs for unaligned cases\n");
664 + dd->sgs_copied = 1;
665 + } else {
666 + dd->sgs_copied = 0;
667 + }
668 +
669 + dd->in_sg_len = scatterwalk_bytes_sglen(dd->in_sg, dd->total);
670 + dd->out_sg_len = scatterwalk_bytes_sglen(dd->out_sg, dd->total);
671 + BUG_ON(dd->in_sg_len < 0 || dd->out_sg_len < 0);
672 +
673 + rctx = ablkcipher_request_ctx(req);
674 + ctx = crypto_ablkcipher_ctx(crypto_ablkcipher_reqtfm(req));
675 + rctx->mode &= FLAGS_MODE_MASK;
676 + dd->flags = (dd->flags & ~FLAGS_MODE_MASK) | rctx->mode;
677 +
678 + dd->ctx = ctx;
679 + ctx->dd = dd;
680 +
681 + err = omap_des_write_ctrl(dd);
682 + if (!err)
683 + err = omap_des_crypt_dma_start(dd);
684 + if (err) {
685 + /* des_task will not finish it, so do it here */
686 + omap_des_finish_req(dd, err);
687 + tasklet_schedule(&dd->queue_task);
688 + }
689 +
690 + return ret; /* return ret, which is enqueue return value */
691 +}
692 +
693 +static void omap_des_done_task(unsigned long data)
694 +{
695 + struct omap_des_dev *dd = (struct omap_des_dev *)data;
696 + void *buf_in, *buf_out;
697 + int pages;
698 +
699 + pr_debug("enter done_task\n");
700 +
701 + if (!dd->pio_only) {
702 + dma_sync_sg_for_device(dd->dev, dd->out_sg, dd->out_sg_len,
703 + DMA_FROM_DEVICE);
704 + dma_unmap_sg(dd->dev, dd->in_sg, dd->in_sg_len, DMA_TO_DEVICE);
705 + dma_unmap_sg(dd->dev, dd->out_sg, dd->out_sg_len,
706 + DMA_FROM_DEVICE);
707 + omap_des_crypt_dma_stop(dd);
708 + }
709 +
710 + if (dd->sgs_copied) {
711 + buf_in = sg_virt(&dd->in_sgl);
712 + buf_out = sg_virt(&dd->out_sgl);
713 +
714 + sg_copy_buf(buf_out, dd->orig_out, 0, dd->total_save, 1);
715 +
716 + pages = get_order(dd->total_save);
717 + free_pages((unsigned long)buf_in, pages);
718 + free_pages((unsigned long)buf_out, pages);
719 + }
720 +
721 + omap_des_finish_req(dd, 0);
722 + omap_des_handle_queue(dd, NULL);
723 +
724 + pr_debug("exit\n");
725 +}
726 +
727 +static void omap_des_queue_task(unsigned long data)
728 +{
729 + struct omap_des_dev *dd = (struct omap_des_dev *)data;
730 +
731 + omap_des_handle_queue(dd, NULL);
732 +}
733 +
734 +static int omap_des_crypt(struct ablkcipher_request *req, unsigned long mode)
735 +{
736 + struct omap_des_ctx *ctx = crypto_ablkcipher_ctx(
737 + crypto_ablkcipher_reqtfm(req));
738 + struct omap_des_reqctx *rctx = ablkcipher_request_ctx(req);
739 + struct omap_des_dev *dd;
740 +
741 + pr_debug("nbytes: %d, enc: %d, cbc: %d\n", req->nbytes,
742 + !!(mode & FLAGS_ENCRYPT),
743 + !!(mode & FLAGS_CBC));
744 +
745 + if (!IS_ALIGNED(req->nbytes, DES_BLOCK_SIZE)) {
746 + pr_err("request size is not exact amount of DES blocks\n");
747 + return -EINVAL;
748 + }
749 +
750 + dd = omap_des_find_dev(ctx);
751 + if (!dd)
752 + return -ENODEV;
753 +
754 + rctx->mode = mode;
755 +
756 + return omap_des_handle_queue(dd, req);
757 +}
758 +
759 +/* ********************** ALG API ************************************ */
760 +
761 +static int omap_des_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
762 + unsigned int keylen)
763 +{
764 + struct omap_des_ctx *ctx = crypto_ablkcipher_ctx(tfm);
765 +
766 + if (keylen != DES_KEY_SIZE)
767 + return -EINVAL;
768 +
769 + pr_debug("enter, keylen: %d\n", keylen);
770 +
771 + memcpy(ctx->key, key, keylen);
772 + ctx->keylen = keylen;
773 +
774 + return 0;
775 +}
776 +
777 +static int omap_des_ecb_encrypt(struct ablkcipher_request *req)
778 +{
779 + return omap_des_crypt(req, FLAGS_ENCRYPT);
780 +}
781 +
782 +static int omap_des_ecb_decrypt(struct ablkcipher_request *req)
783 +{
784 + return omap_des_crypt(req, 0);
785 +}
786 +
787 +static int omap_des_cbc_encrypt(struct ablkcipher_request *req)
788 +{
789 + return omap_des_crypt(req, FLAGS_ENCRYPT | FLAGS_CBC);
790 +}
791 +
792 +static int omap_des_cbc_decrypt(struct ablkcipher_request *req)
793 +{
794 + return omap_des_crypt(req, FLAGS_CBC);
795 +}
796 +
797 +static int omap_des_cra_init(struct crypto_tfm *tfm)
798 +{
799 + pr_debug("enter\n");
800 +
801 + tfm->crt_ablkcipher.reqsize = sizeof(struct omap_des_reqctx);
802 +
803 + return 0;
804 +}
805 +
806 +static void omap_des_cra_exit(struct crypto_tfm *tfm)
807 +{
808 + pr_debug("enter\n");
809 +}
810 +
811 +/* ********************** ALGS ************************************ */
812 +
813 +static struct crypto_alg algs_ecb_cbc[] = {
814 +{
815 + .cra_name = "ecb(des)",
816 + .cra_driver_name = "ecb-des-omap",
817 + .cra_priority = 100,
818 + .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
819 + CRYPTO_ALG_KERN_DRIVER_ONLY |
820 + CRYPTO_ALG_ASYNC,
821 + .cra_blocksize = DES_BLOCK_SIZE,
822 + .cra_ctxsize = sizeof(struct omap_des_ctx),
823 + .cra_alignmask = 0,
824 + .cra_type = &crypto_ablkcipher_type,
825 + .cra_module = THIS_MODULE,
826 + .cra_init = omap_des_cra_init,
827 + .cra_exit = omap_des_cra_exit,
828 + .cra_u.ablkcipher = {
829 + .min_keysize = DES_KEY_SIZE,
830 + .max_keysize = DES_KEY_SIZE,
831 + .setkey = omap_des_setkey,
832 + .encrypt = omap_des_ecb_encrypt,
833 + .decrypt = omap_des_ecb_decrypt,
834 + }
835 +},
836 +{
837 + .cra_name = "cbc(des)",
838 + .cra_driver_name = "cbc-des-omap",
839 + .cra_priority = 100,
840 + .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
841 + CRYPTO_ALG_KERN_DRIVER_ONLY |
842 + CRYPTO_ALG_ASYNC,
843 + .cra_blocksize = DES_BLOCK_SIZE,
844 + .cra_ctxsize = sizeof(struct omap_des_ctx),
845 + .cra_alignmask = 0,
846 + .cra_type = &crypto_ablkcipher_type,
847 + .cra_module = THIS_MODULE,
848 + .cra_init = omap_des_cra_init,
849 + .cra_exit = omap_des_cra_exit,
850 + .cra_u.ablkcipher = {
851 + .min_keysize = DES_KEY_SIZE,
852 + .max_keysize = DES_KEY_SIZE,
853 + .ivsize = DES_BLOCK_SIZE,
854 + .setkey = omap_des_setkey,
855 + .encrypt = omap_des_cbc_encrypt,
856 + .decrypt = omap_des_cbc_decrypt,
857 + }
858 +}
859 +};
860 +
861 +static struct omap_des_algs_info omap_des_algs_info_ecb_cbc[] = {
862 + {
863 + .algs_list = algs_ecb_cbc,
864 + .size = ARRAY_SIZE(algs_ecb_cbc),
865 + },
866 +};
867 +
868 +#ifdef CONFIG_OF
869 +static const struct omap_des_pdata omap_des_pdata_omap4 = {
870 + .algs_info = omap_des_algs_info_ecb_cbc,
871 + .algs_info_size = ARRAY_SIZE(omap_des_algs_info_ecb_cbc),
872 + .trigger = omap_des_dma_trigger_omap4,
873 + .key_ofs = 0x14,
874 + .iv_ofs = 0x18,
875 + .ctrl_ofs = 0x20,
876 + .data_ofs = 0x28,
877 + .rev_ofs = 0x30,
878 + .mask_ofs = 0x34,
879 + .irq_status_ofs = 0x3c,
880 + .irq_enable_ofs = 0x40,
881 + .dma_enable_in = BIT(5),
882 + .dma_enable_out = BIT(6),
883 + .major_mask = 0x0700,
884 + .major_shift = 8,
885 + .minor_mask = 0x003f,
886 + .minor_shift = 0,
887 +};
888 +
889 +static irqreturn_t omap_des_irq(int irq, void *dev_id)
890 +{
891 + struct omap_des_dev *dd = dev_id;
892 + u32 status, i;
893 + u32 *src, *dst;
894 +
895 + status = omap_des_read(dd, DES_REG_IRQ_STATUS(dd));
896 + if (status & DES_REG_IRQ_DATA_IN) {
897 + omap_des_write(dd, DES_REG_IRQ_ENABLE(dd), 0x0);
898 +
899 + BUG_ON(!dd->in_sg);
900 +
901 + BUG_ON(_calc_walked(in) > dd->in_sg->length);
902 +
903 + src = sg_virt(dd->in_sg) + _calc_walked(in);
904 +
905 + for (i = 0; i < DES_BLOCK_WORDS; i++) {
906 + omap_des_write(dd, DES_REG_DATA_N(dd, i), *src);
907 +
908 + scatterwalk_advance(&dd->in_walk, 4);
909 + if (dd->in_sg->length == _calc_walked(in)) {
910 + dd->in_sg = scatterwalk_sg_next(dd->in_sg);
911 + if (dd->in_sg) {
912 + scatterwalk_start(&dd->in_walk,
913 + dd->in_sg);
914 + src = sg_virt(dd->in_sg) +
915 + _calc_walked(in);
916 + }
917 + } else {
918 + src++;
919 + }
920 + }
921 +
922 + /* Clear IRQ status */
923 + status &= ~DES_REG_IRQ_DATA_IN;
924 + omap_des_write(dd, DES_REG_IRQ_STATUS(dd), status);
925 +
926 + /* Enable DATA_OUT interrupt */
927 + omap_des_write(dd, DES_REG_IRQ_ENABLE(dd), 0x4);
928 +
929 + } else if (status & DES_REG_IRQ_DATA_OUT) {
930 + omap_des_write(dd, DES_REG_IRQ_ENABLE(dd), 0x0);
931 +
932 + BUG_ON(!dd->out_sg);
933 +
934 + BUG_ON(_calc_walked(out) > dd->out_sg->length);
935 +
936 + dst = sg_virt(dd->out_sg) + _calc_walked(out);
937 +
938 + for (i = 0; i < DES_BLOCK_WORDS; i++) {
939 + *dst = omap_des_read(dd, DES_REG_DATA_N(dd, i));
940 + scatterwalk_advance(&dd->out_walk, 4);
941 + if (dd->out_sg->length == _calc_walked(out)) {
942 + dd->out_sg = scatterwalk_sg_next(dd->out_sg);
943 + if (dd->out_sg) {
944 + scatterwalk_start(&dd->out_walk,
945 + dd->out_sg);
946 + dst = sg_virt(dd->out_sg) +
947 + _calc_walked(out);
948 + }
949 + } else {
950 + dst++;
951 + }
952 + }
953 +
954 + dd->total -= DES_BLOCK_SIZE;
955 +
956 + BUG_ON(dd->total < 0);
957 +
958 + /* Clear IRQ status */
959 + status &= ~DES_REG_IRQ_DATA_OUT;
960 + omap_des_write(dd, DES_REG_IRQ_STATUS(dd), status);
961 +
962 + if (!dd->total)
963 + /* All bytes read! */
964 + tasklet_schedule(&dd->done_task);
965 + else
966 + /* Enable DATA_IN interrupt for next block */
967 + omap_des_write(dd, DES_REG_IRQ_ENABLE(dd), 0x2);
968 + }
969 +
970 + return IRQ_HANDLED;
971 +}
972 +
973 +static const struct of_device_id omap_des_of_match[] = {
974 + {
975 + .compatible = "ti,omap4-des",
976 + .data = &omap_des_pdata_omap4,
977 + },
978 + {},
979 +};
980 +MODULE_DEVICE_TABLE(of, omap_des_of_match);
981 +
982 +static int omap_des_get_res_of(struct omap_des_dev *dd,
983 + struct device *dev, struct resource *res)
984 +{
985 + struct device_node *node = dev->of_node;
986 + const struct of_device_id *match;
987 + int err = 0;
988 +
989 + match = of_match_device(of_match_ptr(omap_des_of_match), dev);
990 + if (!match) {
991 + dev_err(dev, "no compatible OF match\n");
992 + err = -EINVAL;
993 + goto err;
994 + }
995 +
996 + err = of_address_to_resource(node, 0, res);
997 + if (err < 0) {
998 + dev_err(dev, "can't translate OF node address\n");
999 + err = -EINVAL;
1000 + goto err;
1001 + }
1002 +
1003 + dd->dma_out = -1; /* Dummy value that's unused */
1004 + dd->dma_in = -1; /* Dummy value that's unused */
1005 +
1006 + dd->pdata = match->data;
1007 +
1008 +err:
1009 + return err;
1010 +}
1011 +#else
1012 +static const struct of_device_id omap_des_of_match[] = {
1013 + {},
1014 +};
1015 +
1016 +static int omap_des_get_res_of(struct omap_des_dev *dd,
1017 + struct device *dev, struct resource *res)
1018 +{
1019 + return -EINVAL;
1020 +}
1021 +#endif
1022 +
1023 +static int omap_des_get_res_pdev(struct omap_des_dev *dd,
1024 + struct platform_device *pdev, struct resource *res)
1025 +{
1026 + struct device *dev = &pdev->dev;
1027 + struct resource *r;
1028 + int err = 0;
1029 +
1030 + /* Get the base address */
1031 + r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1032 + if (!r) {
1033 + dev_err(dev, "no MEM resource info\n");
1034 + err = -ENODEV;
1035 + goto err;
1036 + }
1037 + memcpy(res, r, sizeof(*res));
1038 +
1039 + /* Get the DMA out channel */
1040 + r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
1041 + if (!r) {
1042 + dev_err(dev, "no DMA out resource info\n");
1043 + err = -ENODEV;
1044 + goto err;
1045 + }
1046 + dd->dma_out = r->start;
1047 +
1048 + /* Get the DMA in channel */
1049 + r = platform_get_resource(pdev, IORESOURCE_DMA, 1);
1050 + if (!r) {
1051 + dev_err(dev, "no DMA in resource info\n");
1052 + err = -ENODEV;
1053 + goto err;
1054 + }
1055 + dd->dma_in = r->start;
1056 +
1057 + /* non-DT devices get pdata from pdev */
1058 + dd->pdata = pdev->dev.platform_data;
1059 +
1060 +err:
1061 + return err;
1062 +}
1063 +
1064 +static int omap_des_probe(struct platform_device *pdev)
1065 +{
1066 + struct device *dev = &pdev->dev;
1067 + struct omap_des_dev *dd;
1068 + struct crypto_alg *algp;
1069 + struct resource res;
1070 + int err = -ENOMEM, i, j, irq = -1;
1071 + u32 reg;
1072 +
1073 + dd = devm_kzalloc(dev, sizeof(struct omap_des_dev), GFP_KERNEL);
1074 + if (dd == NULL) {
1075 + dev_err(dev, "unable to alloc data struct.\n");
1076 + goto err_data;
1077 + }
1078 + dd->dev = dev;
1079 + platform_set_drvdata(pdev, dd);
1080 +
1081 + spin_lock_init(&dd->lock);
1082 + crypto_init_queue(&dd->queue, OMAP_DES_QUEUE_LENGTH);
1083 +
1084 + err = (dev->of_node) ? omap_des_get_res_of(dd, dev, &res) :
1085 + omap_des_get_res_pdev(dd, pdev, &res);
1086 + if (err)
1087 + goto err_res;
1088 +
1089 + dd->io_base = devm_request_and_ioremap(dev, &res);
1090 + if (!dd->io_base) {
1091 + dev_err(dev, "can't ioremap\n");
1092 + err = -ENOMEM;
1093 + goto err_res;
1094 + }
1095 + dd->phys_base = res.start;
1096 +
1097 + pm_runtime_enable(dev);
1098 + pm_runtime_get_sync(dev);
1099 +
1100 + omap_des_dma_stop(dd);
1101 +
1102 + reg = omap_des_read(dd, DES_REG_REV(dd));
1103 +
1104 + pm_runtime_put_sync(dev);
1105 +
1106 + dev_info(dev, "OMAP DES hw accel rev: %u.%u\n",
1107 + (reg & dd->pdata->major_mask) >> dd->pdata->major_shift,
1108 + (reg & dd->pdata->minor_mask) >> dd->pdata->minor_shift);
1109 +
1110 + tasklet_init(&dd->done_task, omap_des_done_task, (unsigned long)dd);
1111 + tasklet_init(&dd->queue_task, omap_des_queue_task, (unsigned long)dd);
1112 +
1113 + err = omap_des_dma_init(dd);
1114 + if (err && DES_REG_IRQ_STATUS(dd) && DES_REG_IRQ_ENABLE(dd)) {
1115 + dd->pio_only = 1;
1116 +
1117 + irq = platform_get_irq(pdev, 0);
1118 + if (irq < 0) {
1119 + dev_err(dev, "can't get IRQ resource\n");
1120 + goto err_irq;
1121 + }
1122 +
1123 + err = devm_request_irq(dev, irq, omap_des_irq, 0,
1124 + dev_name(dev), dd);
1125 + if (err) {
1126 + dev_err(dev, "Unable to grab omap-des IRQ\n");
1127 + goto err_irq;
1128 + }
1129 + }
1130 +
1131 +
1132 + INIT_LIST_HEAD(&dd->list);
1133 + spin_lock(&list_lock);
1134 + list_add_tail(&dd->list, &dev_list);
1135 + spin_unlock(&list_lock);
1136 +
1137 + for (i = 0; i < dd->pdata->algs_info_size; i++) {
1138 + for (j = 0; j < dd->pdata->algs_info[i].size; j++) {
1139 + algp = &dd->pdata->algs_info[i].algs_list[j];
1140 +
1141 + pr_debug("reg alg: %s\n", algp->cra_name);
1142 + INIT_LIST_HEAD(&algp->cra_list);
1143 +
1144 + err = crypto_register_alg(algp);
1145 + if (err)
1146 + goto err_algs;
1147 +
1148 + dd->pdata->algs_info[i].registered++;
1149 + }
1150 + }
1151 +
1152 + return 0;
1153 +err_algs:
1154 + for (i = dd->pdata->algs_info_size - 1; i >= 0; i--)
1155 + for (j = dd->pdata->algs_info[i].registered - 1; j >= 0; j--)
1156 + crypto_unregister_alg(
1157 + &dd->pdata->algs_info[i].algs_list[j]);
1158 + if (!dd->pio_only)
1159 + omap_des_dma_cleanup(dd);
1160 +err_irq:
1161 + tasklet_kill(&dd->done_task);
1162 + tasklet_kill(&dd->queue_task);
1163 + pm_runtime_disable(dev);
1164 +err_res:
1165 + dd = NULL;
1166 +err_data:
1167 + dev_err(dev, "initialization failed.\n");
1168 + return err;
1169 +}
1170 +
1171 +static int omap_des_remove(struct platform_device *pdev)
1172 +{
1173 + struct omap_des_dev *dd = platform_get_drvdata(pdev);
1174 + int i, j;
1175 +
1176 + if (!dd)
1177 + return -ENODEV;
1178 +
1179 + spin_lock(&list_lock);
1180 + list_del(&dd->list);
1181 + spin_unlock(&list_lock);
1182 +
1183 + for (i = dd->pdata->algs_info_size - 1; i >= 0; i--)
1184 + for (j = dd->pdata->algs_info[i].registered - 1; j >= 0; j--)
1185 + crypto_unregister_alg(
1186 + &dd->pdata->algs_info[i].algs_list[j]);
1187 +
1188 + tasklet_kill(&dd->done_task);
1189 + tasklet_kill(&dd->queue_task);
1190 + omap_des_dma_cleanup(dd);
1191 + pm_runtime_disable(dd->dev);
1192 + dd = NULL;
1193 +
1194 + return 0;
1195 +}
1196 +
1197 +#ifdef CONFIG_PM_SLEEP
1198 +static int omap_des_suspend(struct device *dev)
1199 +{
1200 + pm_runtime_put_sync(dev);
1201 + return 0;
1202 +}
1203 +
1204 +static int omap_des_resume(struct device *dev)
1205 +{
1206 + pm_runtime_get_sync(dev);
1207 + return 0;
1208 +}
1209 +#endif
1210 +
1211 +static const struct dev_pm_ops omap_des_pm_ops = {
1212 + SET_SYSTEM_SLEEP_PM_OPS(omap_des_suspend, omap_des_resume)
1213 +};
1214 +
1215 +static struct platform_driver omap_des_driver = {
1216 + .probe = omap_des_probe,
1217 + .remove = omap_des_remove,
1218 + .driver = {
1219 + .name = "omap-des",
1220 + .owner = THIS_MODULE,
1221 + .pm = &omap_des_pm_ops,
1222 + .of_match_table = omap_des_of_match,
1223 + },
1224 +};
1225 +
1226 +module_platform_driver(omap_des_driver);
1227 +
1228 +MODULE_DESCRIPTION("OMAP DES hw acceleration support.");
1229 +MODULE_LICENSE("GPL v2");
1230 +MODULE_AUTHOR("Joel Fernandes <joelf@ti.com>");
OpenWrt Source Repository