2 * Freescale i.MX23/i.MX28 Data Co-Processor driver
4 * Copyright (C) 2013 Marek Vasut <marex@denx.de>
6 * The code contained herein is licensed under the GNU General Public
7 * License. You may obtain a copy of the GNU General Public License
8 * Version 2 or later at the following locations:
10 * http://www.opensource.org/licenses/gpl-license.html
11 * http://www.gnu.org/copyleft/gpl.html
14 #include <linux/crypto.h>
15 #include <linux/dma-mapping.h>
16 #include <linux/interrupt.h>
18 #include <linux/kernel.h>
19 #include <linux/kthread.h>
20 #include <linux/module.h>
22 #include <linux/platform_device.h>
23 #include <linux/stmp_device.h>
25 #include <crypto/aes.h>
26 #include <crypto/sha.h>
27 #include <crypto/internal/hash.h>
29 #define DCP_MAX_CHANS 4
30 #define DCP_BUF_SZ PAGE_SIZE
32 /* DCP DMA descriptor. */
34 uint32_t next_cmd_addr
;
44 /* Coherent aligned block for bounce buffering. */
45 struct dcp_coherent_block
{
46 uint8_t aes_in_buf
[DCP_BUF_SZ
];
47 uint8_t aes_out_buf
[DCP_BUF_SZ
];
48 uint8_t sha_in_buf
[DCP_BUF_SZ
];
50 uint8_t aes_key
[2 * AES_KEYSIZE_128
];
51 uint8_t sha_digest
[SHA256_DIGEST_SIZE
];
53 struct dcp_dma_desc desc
[DCP_MAX_CHANS
];
62 struct dcp_coherent_block
*coh
;
64 struct completion completion
[DCP_MAX_CHANS
];
65 struct mutex mutex
[DCP_MAX_CHANS
];
66 struct task_struct
*thread
[DCP_MAX_CHANS
];
67 struct crypto_queue queue
[DCP_MAX_CHANS
];
71 DCP_CHAN_HASH_SHA
= 0,
75 struct dcp_async_ctx
{
80 /* SHA Hash-specific context */
85 /* Crypto-specific context */
86 struct crypto_ablkcipher
*fallback
;
88 uint8_t key
[AES_KEYSIZE_128
];
91 struct dcp_aes_req_ctx
{
96 struct dcp_sha_req_ctx
{
102 * There can even be only one instance of the MXS DCP due to the
103 * design of Linux Crypto API.
105 static struct dcp
*global_sdcp
;
106 static DEFINE_MUTEX(global_mutex
);
108 /* DCP register layout. */
109 #define MXS_DCP_CTRL 0x00
110 #define MXS_DCP_CTRL_GATHER_RESIDUAL_WRITES (1 << 23)
111 #define MXS_DCP_CTRL_ENABLE_CONTEXT_CACHING (1 << 22)
113 #define MXS_DCP_STAT 0x10
114 #define MXS_DCP_STAT_CLR 0x18
115 #define MXS_DCP_STAT_IRQ_MASK 0xf
117 #define MXS_DCP_CHANNELCTRL 0x20
118 #define MXS_DCP_CHANNELCTRL_ENABLE_CHANNEL_MASK 0xff
120 #define MXS_DCP_CAPABILITY1 0x40
121 #define MXS_DCP_CAPABILITY1_SHA256 (4 << 16)
122 #define MXS_DCP_CAPABILITY1_SHA1 (1 << 16)
123 #define MXS_DCP_CAPABILITY1_AES128 (1 << 0)
125 #define MXS_DCP_CONTEXT 0x50
127 #define MXS_DCP_CH_N_CMDPTR(n) (0x100 + ((n) * 0x40))
129 #define MXS_DCP_CH_N_SEMA(n) (0x110 + ((n) * 0x40))
131 #define MXS_DCP_CH_N_STAT(n) (0x120 + ((n) * 0x40))
132 #define MXS_DCP_CH_N_STAT_CLR(n) (0x128 + ((n) * 0x40))
134 /* DMA descriptor bits. */
135 #define MXS_DCP_CONTROL0_HASH_TERM (1 << 13)
136 #define MXS_DCP_CONTROL0_HASH_INIT (1 << 12)
137 #define MXS_DCP_CONTROL0_PAYLOAD_KEY (1 << 11)
138 #define MXS_DCP_CONTROL0_CIPHER_ENCRYPT (1 << 8)
139 #define MXS_DCP_CONTROL0_CIPHER_INIT (1 << 9)
140 #define MXS_DCP_CONTROL0_ENABLE_HASH (1 << 6)
141 #define MXS_DCP_CONTROL0_ENABLE_CIPHER (1 << 5)
142 #define MXS_DCP_CONTROL0_DECR_SEMAPHORE (1 << 1)
143 #define MXS_DCP_CONTROL0_INTERRUPT (1 << 0)
145 #define MXS_DCP_CONTROL1_HASH_SELECT_SHA256 (2 << 16)
146 #define MXS_DCP_CONTROL1_HASH_SELECT_SHA1 (0 << 16)
147 #define MXS_DCP_CONTROL1_CIPHER_MODE_CBC (1 << 4)
148 #define MXS_DCP_CONTROL1_CIPHER_MODE_ECB (0 << 4)
149 #define MXS_DCP_CONTROL1_CIPHER_SELECT_AES128 (0 << 0)
151 static int mxs_dcp_start_dma(struct dcp_async_ctx
*actx
)
153 struct dcp
*sdcp
= global_sdcp
;
154 const int chan
= actx
->chan
;
157 struct dcp_dma_desc
*desc
= &sdcp
->coh
->desc
[actx
->chan
];
159 dma_addr_t desc_phys
= dma_map_single(sdcp
->dev
, desc
, sizeof(*desc
),
162 reinit_completion(&sdcp
->completion
[chan
]);
164 /* Clear status register. */
165 writel(0xffffffff, sdcp
->base
+ MXS_DCP_CH_N_STAT_CLR(chan
));
167 /* Load the DMA descriptor. */
168 writel(desc_phys
, sdcp
->base
+ MXS_DCP_CH_N_CMDPTR(chan
));
170 /* Increment the semaphore to start the DMA transfer. */
171 writel(1, sdcp
->base
+ MXS_DCP_CH_N_SEMA(chan
));
173 ret
= wait_for_completion_timeout(&sdcp
->completion
[chan
],
174 msecs_to_jiffies(1000));
176 dev_err(sdcp
->dev
, "Channel %i timeout (DCP_STAT=0x%08x)\n",
177 chan
, readl(sdcp
->base
+ MXS_DCP_STAT
));
181 stat
= readl(sdcp
->base
+ MXS_DCP_CH_N_STAT(chan
));
183 dev_err(sdcp
->dev
, "Channel %i error (CH_STAT=0x%08x)\n",
188 dma_unmap_single(sdcp
->dev
, desc_phys
, sizeof(*desc
), DMA_TO_DEVICE
);
194 * Encryption (AES128)
196 static int mxs_dcp_run_aes(struct dcp_async_ctx
*actx
,
197 struct ablkcipher_request
*req
, int init
)
199 struct dcp
*sdcp
= global_sdcp
;
200 struct dcp_dma_desc
*desc
= &sdcp
->coh
->desc
[actx
->chan
];
201 struct dcp_aes_req_ctx
*rctx
= ablkcipher_request_ctx(req
);
204 dma_addr_t key_phys
= dma_map_single(sdcp
->dev
, sdcp
->coh
->aes_key
,
207 dma_addr_t src_phys
= dma_map_single(sdcp
->dev
, sdcp
->coh
->aes_in_buf
,
208 DCP_BUF_SZ
, DMA_TO_DEVICE
);
209 dma_addr_t dst_phys
= dma_map_single(sdcp
->dev
, sdcp
->coh
->aes_out_buf
,
210 DCP_BUF_SZ
, DMA_FROM_DEVICE
);
212 /* Fill in the DMA descriptor. */
213 desc
->control0
= MXS_DCP_CONTROL0_DECR_SEMAPHORE
|
214 MXS_DCP_CONTROL0_INTERRUPT
|
215 MXS_DCP_CONTROL0_ENABLE_CIPHER
;
217 /* Payload contains the key. */
218 desc
->control0
|= MXS_DCP_CONTROL0_PAYLOAD_KEY
;
221 desc
->control0
|= MXS_DCP_CONTROL0_CIPHER_ENCRYPT
;
223 desc
->control0
|= MXS_DCP_CONTROL0_CIPHER_INIT
;
225 desc
->control1
= MXS_DCP_CONTROL1_CIPHER_SELECT_AES128
;
228 desc
->control1
|= MXS_DCP_CONTROL1_CIPHER_MODE_ECB
;
230 desc
->control1
|= MXS_DCP_CONTROL1_CIPHER_MODE_CBC
;
232 desc
->next_cmd_addr
= 0;
233 desc
->source
= src_phys
;
234 desc
->destination
= dst_phys
;
235 desc
->size
= actx
->fill
;
236 desc
->payload
= key_phys
;
239 ret
= mxs_dcp_start_dma(actx
);
241 dma_unmap_single(sdcp
->dev
, key_phys
, 2 * AES_KEYSIZE_128
,
243 dma_unmap_single(sdcp
->dev
, src_phys
, DCP_BUF_SZ
, DMA_TO_DEVICE
);
244 dma_unmap_single(sdcp
->dev
, dst_phys
, DCP_BUF_SZ
, DMA_FROM_DEVICE
);
249 static int mxs_dcp_aes_block_crypt(struct crypto_async_request
*arq
)
251 struct dcp
*sdcp
= global_sdcp
;
253 struct ablkcipher_request
*req
= ablkcipher_request_cast(arq
);
254 struct dcp_async_ctx
*actx
= crypto_tfm_ctx(arq
->tfm
);
255 struct dcp_aes_req_ctx
*rctx
= ablkcipher_request_ctx(req
);
257 struct scatterlist
*dst
= req
->dst
;
258 struct scatterlist
*src
= req
->src
;
259 const int nents
= sg_nents(req
->src
);
261 const int out_off
= DCP_BUF_SZ
;
262 uint8_t *in_buf
= sdcp
->coh
->aes_in_buf
;
263 uint8_t *out_buf
= sdcp
->coh
->aes_out_buf
;
265 uint8_t *out_tmp
, *src_buf
, *dst_buf
= NULL
;
266 uint32_t dst_off
= 0;
268 uint8_t *key
= sdcp
->coh
->aes_key
;
272 unsigned int i
, len
, clen
, rem
= 0;
277 /* Copy the key from the temporary location. */
278 memcpy(key
, actx
->key
, actx
->key_len
);
281 /* Copy the CBC IV just past the key. */
282 memcpy(key
+ AES_KEYSIZE_128
, req
->info
, AES_KEYSIZE_128
);
283 /* CBC needs the INIT set. */
286 memset(key
+ AES_KEYSIZE_128
, 0, AES_KEYSIZE_128
);
289 for_each_sg(req
->src
, src
, nents
, i
) {
290 src_buf
= sg_virt(src
);
291 len
= sg_dma_len(src
);
294 if (actx
->fill
+ len
> out_off
)
295 clen
= out_off
- actx
->fill
;
299 memcpy(in_buf
+ actx
->fill
, src_buf
, clen
);
305 * If we filled the buffer or this is the last SG,
308 if (actx
->fill
== out_off
|| sg_is_last(src
)) {
309 ret
= mxs_dcp_run_aes(actx
, req
, init
);
315 while (dst
&& actx
->fill
) {
317 dst_buf
= sg_virt(dst
);
320 rem
= min(sg_dma_len(dst
) - dst_off
,
323 memcpy(dst_buf
+ dst_off
, out_tmp
, rem
);
328 if (dst_off
== sg_dma_len(dst
)) {
342 static int dcp_chan_thread_aes(void *data
)
344 struct dcp
*sdcp
= global_sdcp
;
345 const int chan
= DCP_CHAN_CRYPTO
;
347 struct crypto_async_request
*backlog
;
348 struct crypto_async_request
*arq
;
353 __set_current_state(TASK_INTERRUPTIBLE
);
355 mutex_lock(&sdcp
->mutex
[chan
]);
356 backlog
= crypto_get_backlog(&sdcp
->queue
[chan
]);
357 arq
= crypto_dequeue_request(&sdcp
->queue
[chan
]);
358 mutex_unlock(&sdcp
->mutex
[chan
]);
361 backlog
->complete(backlog
, -EINPROGRESS
);
364 ret
= mxs_dcp_aes_block_crypt(arq
);
365 arq
->complete(arq
, ret
);
370 } while (!kthread_should_stop());
375 static int mxs_dcp_block_fallback(struct ablkcipher_request
*req
, int enc
)
377 struct crypto_tfm
*tfm
=
378 crypto_ablkcipher_tfm(crypto_ablkcipher_reqtfm(req
));
379 struct dcp_async_ctx
*ctx
= crypto_ablkcipher_ctx(
380 crypto_ablkcipher_reqtfm(req
));
383 ablkcipher_request_set_tfm(req
, ctx
->fallback
);
386 ret
= crypto_ablkcipher_encrypt(req
);
388 ret
= crypto_ablkcipher_decrypt(req
);
390 ablkcipher_request_set_tfm(req
, __crypto_ablkcipher_cast(tfm
));
395 static int mxs_dcp_aes_enqueue(struct ablkcipher_request
*req
, int enc
, int ecb
)
397 struct dcp
*sdcp
= global_sdcp
;
398 struct crypto_async_request
*arq
= &req
->base
;
399 struct dcp_async_ctx
*actx
= crypto_tfm_ctx(arq
->tfm
);
400 struct dcp_aes_req_ctx
*rctx
= ablkcipher_request_ctx(req
);
403 if (unlikely(actx
->key_len
!= AES_KEYSIZE_128
))
404 return mxs_dcp_block_fallback(req
, enc
);
408 actx
->chan
= DCP_CHAN_CRYPTO
;
410 mutex_lock(&sdcp
->mutex
[actx
->chan
]);
411 ret
= crypto_enqueue_request(&sdcp
->queue
[actx
->chan
], &req
->base
);
412 mutex_unlock(&sdcp
->mutex
[actx
->chan
]);
414 wake_up_process(sdcp
->thread
[actx
->chan
]);
419 static int mxs_dcp_aes_ecb_decrypt(struct ablkcipher_request
*req
)
421 return mxs_dcp_aes_enqueue(req
, 0, 1);
424 static int mxs_dcp_aes_ecb_encrypt(struct ablkcipher_request
*req
)
426 return mxs_dcp_aes_enqueue(req
, 1, 1);
429 static int mxs_dcp_aes_cbc_decrypt(struct ablkcipher_request
*req
)
431 return mxs_dcp_aes_enqueue(req
, 0, 0);
434 static int mxs_dcp_aes_cbc_encrypt(struct ablkcipher_request
*req
)
436 return mxs_dcp_aes_enqueue(req
, 1, 0);
439 static int mxs_dcp_aes_setkey(struct crypto_ablkcipher
*tfm
, const u8
*key
,
442 struct dcp_async_ctx
*actx
= crypto_ablkcipher_ctx(tfm
);
446 * AES 128 is supposed by the hardware, store key into temporary
447 * buffer and exit. We must use the temporary buffer here, since
448 * there can still be an operation in progress.
451 if (len
== AES_KEYSIZE_128
) {
452 memcpy(actx
->key
, key
, len
);
456 /* Check if the key size is supported by kernel at all. */
457 if (len
!= AES_KEYSIZE_192
&& len
!= AES_KEYSIZE_256
) {
458 tfm
->base
.crt_flags
|= CRYPTO_TFM_RES_BAD_KEY_LEN
;
463 * If the requested AES key size is not supported by the hardware,
464 * but is supported by in-kernel software implementation, we use
467 actx
->fallback
->base
.crt_flags
&= ~CRYPTO_TFM_REQ_MASK
;
468 actx
->fallback
->base
.crt_flags
|=
469 tfm
->base
.crt_flags
& CRYPTO_TFM_REQ_MASK
;
471 ret
= crypto_ablkcipher_setkey(actx
->fallback
, key
, len
);
475 tfm
->base
.crt_flags
&= ~CRYPTO_TFM_RES_MASK
;
476 tfm
->base
.crt_flags
|=
477 actx
->fallback
->base
.crt_flags
& CRYPTO_TFM_RES_MASK
;
482 static int mxs_dcp_aes_fallback_init(struct crypto_tfm
*tfm
)
484 const char *name
= tfm
->__crt_alg
->cra_name
;
485 const uint32_t flags
= CRYPTO_ALG_ASYNC
| CRYPTO_ALG_NEED_FALLBACK
;
486 struct dcp_async_ctx
*actx
= crypto_tfm_ctx(tfm
);
487 struct crypto_ablkcipher
*blk
;
489 blk
= crypto_alloc_ablkcipher(name
, 0, flags
);
493 actx
->fallback
= blk
;
494 tfm
->crt_ablkcipher
.reqsize
= sizeof(struct dcp_aes_req_ctx
);
498 static void mxs_dcp_aes_fallback_exit(struct crypto_tfm
*tfm
)
500 struct dcp_async_ctx
*actx
= crypto_tfm_ctx(tfm
);
502 crypto_free_ablkcipher(actx
->fallback
);
503 actx
->fallback
= NULL
;
507 * Hashing (SHA1/SHA256)
509 static int mxs_dcp_run_sha(struct ahash_request
*req
)
511 struct dcp
*sdcp
= global_sdcp
;
514 struct crypto_ahash
*tfm
= crypto_ahash_reqtfm(req
);
515 struct dcp_async_ctx
*actx
= crypto_ahash_ctx(tfm
);
516 struct dcp_sha_req_ctx
*rctx
= ahash_request_ctx(req
);
518 struct dcp_dma_desc
*desc
= &sdcp
->coh
->desc
[actx
->chan
];
519 dma_addr_t digest_phys
= dma_map_single(sdcp
->dev
,
520 sdcp
->coh
->sha_digest
,
524 dma_addr_t buf_phys
= dma_map_single(sdcp
->dev
, sdcp
->coh
->sha_in_buf
,
525 DCP_BUF_SZ
, DMA_TO_DEVICE
);
527 /* Fill in the DMA descriptor. */
528 desc
->control0
= MXS_DCP_CONTROL0_DECR_SEMAPHORE
|
529 MXS_DCP_CONTROL0_INTERRUPT
|
530 MXS_DCP_CONTROL0_ENABLE_HASH
;
532 desc
->control0
|= MXS_DCP_CONTROL0_HASH_INIT
;
534 desc
->control1
= actx
->alg
;
535 desc
->next_cmd_addr
= 0;
536 desc
->source
= buf_phys
;
537 desc
->destination
= 0;
538 desc
->size
= actx
->fill
;
542 /* Set HASH_TERM bit for last transfer block. */
544 desc
->control0
|= MXS_DCP_CONTROL0_HASH_TERM
;
545 desc
->payload
= digest_phys
;
548 ret
= mxs_dcp_start_dma(actx
);
550 dma_unmap_single(sdcp
->dev
, digest_phys
, SHA256_DIGEST_SIZE
,
552 dma_unmap_single(sdcp
->dev
, buf_phys
, DCP_BUF_SZ
, DMA_TO_DEVICE
);
557 static int dcp_sha_req_to_buf(struct crypto_async_request
*arq
)
559 struct dcp
*sdcp
= global_sdcp
;
561 struct ahash_request
*req
= ahash_request_cast(arq
);
562 struct crypto_ahash
*tfm
= crypto_ahash_reqtfm(req
);
563 struct dcp_async_ctx
*actx
= crypto_ahash_ctx(tfm
);
564 struct dcp_sha_req_ctx
*rctx
= ahash_request_ctx(req
);
565 struct hash_alg_common
*halg
= crypto_hash_alg_common(tfm
);
566 const int nents
= sg_nents(req
->src
);
568 uint8_t *digest
= sdcp
->coh
->sha_digest
;
569 uint8_t *in_buf
= sdcp
->coh
->sha_in_buf
;
573 struct scatterlist
*src
;
575 unsigned int i
, len
, clen
;
578 int fin
= rctx
->fini
;
582 for_each_sg(req
->src
, src
, nents
, i
) {
583 src_buf
= sg_virt(src
);
584 len
= sg_dma_len(src
);
587 if (actx
->fill
+ len
> DCP_BUF_SZ
)
588 clen
= DCP_BUF_SZ
- actx
->fill
;
592 memcpy(in_buf
+ actx
->fill
, src_buf
, clen
);
598 * If we filled the buffer and still have some
599 * more data, submit the buffer.
601 if (len
&& actx
->fill
== DCP_BUF_SZ
) {
602 ret
= mxs_dcp_run_sha(req
);
614 /* Submit whatever is left. */
615 ret
= mxs_dcp_run_sha(req
);
616 if (ret
|| !req
->result
)
620 /* For some reason, the result is flipped. */
621 for (i
= 0; i
< halg
->digestsize
; i
++)
622 req
->result
[i
] = digest
[halg
->digestsize
- i
- 1];
628 static int dcp_chan_thread_sha(void *data
)
630 struct dcp
*sdcp
= global_sdcp
;
631 const int chan
= DCP_CHAN_HASH_SHA
;
633 struct crypto_async_request
*backlog
;
634 struct crypto_async_request
*arq
;
636 struct dcp_sha_req_ctx
*rctx
;
638 struct ahash_request
*req
;
642 __set_current_state(TASK_INTERRUPTIBLE
);
644 mutex_lock(&sdcp
->mutex
[chan
]);
645 backlog
= crypto_get_backlog(&sdcp
->queue
[chan
]);
646 arq
= crypto_dequeue_request(&sdcp
->queue
[chan
]);
647 mutex_unlock(&sdcp
->mutex
[chan
]);
650 backlog
->complete(backlog
, -EINPROGRESS
);
653 req
= ahash_request_cast(arq
);
654 rctx
= ahash_request_ctx(req
);
656 ret
= dcp_sha_req_to_buf(arq
);
658 arq
->complete(arq
, ret
);
664 } while (!kthread_should_stop());
669 static int dcp_sha_init(struct ahash_request
*req
)
671 struct crypto_ahash
*tfm
= crypto_ahash_reqtfm(req
);
672 struct dcp_async_ctx
*actx
= crypto_ahash_ctx(tfm
);
674 struct hash_alg_common
*halg
= crypto_hash_alg_common(tfm
);
677 * Start hashing session. The code below only inits the
678 * hashing session context, nothing more.
680 memset(actx
, 0, sizeof(*actx
));
682 if (strcmp(halg
->base
.cra_name
, "sha1") == 0)
683 actx
->alg
= MXS_DCP_CONTROL1_HASH_SELECT_SHA1
;
685 actx
->alg
= MXS_DCP_CONTROL1_HASH_SELECT_SHA256
;
689 actx
->chan
= DCP_CHAN_HASH_SHA
;
691 mutex_init(&actx
->mutex
);
696 static int dcp_sha_update_fx(struct ahash_request
*req
, int fini
)
698 struct dcp
*sdcp
= global_sdcp
;
700 struct dcp_sha_req_ctx
*rctx
= ahash_request_ctx(req
);
701 struct crypto_ahash
*tfm
= crypto_ahash_reqtfm(req
);
702 struct dcp_async_ctx
*actx
= crypto_ahash_ctx(tfm
);
707 * Ignore requests that have no data in them and are not
708 * the trailing requests in the stream of requests.
710 if (!req
->nbytes
&& !fini
)
713 mutex_lock(&actx
->mutex
);
722 mutex_lock(&sdcp
->mutex
[actx
->chan
]);
723 ret
= crypto_enqueue_request(&sdcp
->queue
[actx
->chan
], &req
->base
);
724 mutex_unlock(&sdcp
->mutex
[actx
->chan
]);
726 wake_up_process(sdcp
->thread
[actx
->chan
]);
727 mutex_unlock(&actx
->mutex
);
732 static int dcp_sha_update(struct ahash_request
*req
)
734 return dcp_sha_update_fx(req
, 0);
737 static int dcp_sha_final(struct ahash_request
*req
)
739 ahash_request_set_crypt(req
, NULL
, req
->result
, 0);
741 return dcp_sha_update_fx(req
, 1);
744 static int dcp_sha_finup(struct ahash_request
*req
)
746 return dcp_sha_update_fx(req
, 1);
749 static int dcp_sha_digest(struct ahash_request
*req
)
753 ret
= dcp_sha_init(req
);
757 return dcp_sha_finup(req
);
760 static int dcp_sha_cra_init(struct crypto_tfm
*tfm
)
762 crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm
),
763 sizeof(struct dcp_sha_req_ctx
));
767 static void dcp_sha_cra_exit(struct crypto_tfm
*tfm
)
771 /* AES 128 ECB and AES 128 CBC */
772 static struct crypto_alg dcp_aes_algs
[] = {
774 .cra_name
= "ecb(aes)",
775 .cra_driver_name
= "ecb-aes-dcp",
778 .cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
|
780 CRYPTO_ALG_NEED_FALLBACK
,
781 .cra_init
= mxs_dcp_aes_fallback_init
,
782 .cra_exit
= mxs_dcp_aes_fallback_exit
,
783 .cra_blocksize
= AES_BLOCK_SIZE
,
784 .cra_ctxsize
= sizeof(struct dcp_async_ctx
),
785 .cra_type
= &crypto_ablkcipher_type
,
786 .cra_module
= THIS_MODULE
,
789 .min_keysize
= AES_MIN_KEY_SIZE
,
790 .max_keysize
= AES_MAX_KEY_SIZE
,
791 .setkey
= mxs_dcp_aes_setkey
,
792 .encrypt
= mxs_dcp_aes_ecb_encrypt
,
793 .decrypt
= mxs_dcp_aes_ecb_decrypt
797 .cra_name
= "cbc(aes)",
798 .cra_driver_name
= "cbc-aes-dcp",
801 .cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
|
803 CRYPTO_ALG_NEED_FALLBACK
,
804 .cra_init
= mxs_dcp_aes_fallback_init
,
805 .cra_exit
= mxs_dcp_aes_fallback_exit
,
806 .cra_blocksize
= AES_BLOCK_SIZE
,
807 .cra_ctxsize
= sizeof(struct dcp_async_ctx
),
808 .cra_type
= &crypto_ablkcipher_type
,
809 .cra_module
= THIS_MODULE
,
812 .min_keysize
= AES_MIN_KEY_SIZE
,
813 .max_keysize
= AES_MAX_KEY_SIZE
,
814 .setkey
= mxs_dcp_aes_setkey
,
815 .encrypt
= mxs_dcp_aes_cbc_encrypt
,
816 .decrypt
= mxs_dcp_aes_cbc_decrypt
,
817 .ivsize
= AES_BLOCK_SIZE
,
824 static struct ahash_alg dcp_sha1_alg
= {
825 .init
= dcp_sha_init
,
826 .update
= dcp_sha_update
,
827 .final
= dcp_sha_final
,
828 .finup
= dcp_sha_finup
,
829 .digest
= dcp_sha_digest
,
831 .digestsize
= SHA1_DIGEST_SIZE
,
834 .cra_driver_name
= "sha1-dcp",
837 .cra_flags
= CRYPTO_ALG_ASYNC
,
838 .cra_blocksize
= SHA1_BLOCK_SIZE
,
839 .cra_ctxsize
= sizeof(struct dcp_async_ctx
),
840 .cra_module
= THIS_MODULE
,
841 .cra_init
= dcp_sha_cra_init
,
842 .cra_exit
= dcp_sha_cra_exit
,
848 static struct ahash_alg dcp_sha256_alg
= {
849 .init
= dcp_sha_init
,
850 .update
= dcp_sha_update
,
851 .final
= dcp_sha_final
,
852 .finup
= dcp_sha_finup
,
853 .digest
= dcp_sha_digest
,
855 .digestsize
= SHA256_DIGEST_SIZE
,
857 .cra_name
= "sha256",
858 .cra_driver_name
= "sha256-dcp",
861 .cra_flags
= CRYPTO_ALG_ASYNC
,
862 .cra_blocksize
= SHA256_BLOCK_SIZE
,
863 .cra_ctxsize
= sizeof(struct dcp_async_ctx
),
864 .cra_module
= THIS_MODULE
,
865 .cra_init
= dcp_sha_cra_init
,
866 .cra_exit
= dcp_sha_cra_exit
,
871 static irqreturn_t
mxs_dcp_irq(int irq
, void *context
)
873 struct dcp
*sdcp
= context
;
877 stat
= readl(sdcp
->base
+ MXS_DCP_STAT
);
878 stat
&= MXS_DCP_STAT_IRQ_MASK
;
882 /* Clear the interrupts. */
883 writel(stat
, sdcp
->base
+ MXS_DCP_STAT_CLR
);
885 /* Complete the DMA requests that finished. */
886 for (i
= 0; i
< DCP_MAX_CHANS
; i
++)
888 complete(&sdcp
->completion
[i
]);
893 static int mxs_dcp_probe(struct platform_device
*pdev
)
895 struct device
*dev
= &pdev
->dev
;
896 struct dcp
*sdcp
= NULL
;
899 struct resource
*iores
;
900 int dcp_vmi_irq
, dcp_irq
;
902 mutex_lock(&global_mutex
);
904 dev_err(dev
, "Only one DCP instance allowed!\n");
909 iores
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
910 dcp_vmi_irq
= platform_get_irq(pdev
, 0);
911 dcp_irq
= platform_get_irq(pdev
, 1);
912 if (dcp_vmi_irq
< 0 || dcp_irq
< 0) {
917 sdcp
= devm_kzalloc(dev
, sizeof(*sdcp
), GFP_KERNEL
);
924 sdcp
->base
= devm_ioremap_resource(dev
, iores
);
925 if (IS_ERR(sdcp
->base
)) {
926 ret
= PTR_ERR(sdcp
->base
);
930 ret
= devm_request_irq(dev
, dcp_vmi_irq
, mxs_dcp_irq
, 0,
931 "dcp-vmi-irq", sdcp
);
933 dev_err(dev
, "Failed to claim DCP VMI IRQ!\n");
937 ret
= devm_request_irq(dev
, dcp_irq
, mxs_dcp_irq
, 0,
940 dev_err(dev
, "Failed to claim DCP IRQ!\n");
944 /* Allocate coherent helper block. */
945 sdcp
->coh
= devm_kzalloc(dev
, sizeof(*sdcp
->coh
), GFP_KERNEL
);
951 /* Restart the DCP block. */
952 ret
= stmp_reset_block(sdcp
->base
);
956 /* Initialize control register. */
957 writel(MXS_DCP_CTRL_GATHER_RESIDUAL_WRITES
|
958 MXS_DCP_CTRL_ENABLE_CONTEXT_CACHING
| 0xf,
959 sdcp
->base
+ MXS_DCP_CTRL
);
961 /* Enable all DCP DMA channels. */
962 writel(MXS_DCP_CHANNELCTRL_ENABLE_CHANNEL_MASK
,
963 sdcp
->base
+ MXS_DCP_CHANNELCTRL
);
966 * We do not enable context switching. Give the context buffer a
967 * pointer to an illegal address so if context switching is
968 * inadvertantly enabled, the DCP will return an error instead of
969 * trashing good memory. The DCP DMA cannot access ROM, so any ROM
972 writel(0xffff0000, sdcp
->base
+ MXS_DCP_CONTEXT
);
973 for (i
= 0; i
< DCP_MAX_CHANS
; i
++)
974 writel(0xffffffff, sdcp
->base
+ MXS_DCP_CH_N_STAT_CLR(i
));
975 writel(0xffffffff, sdcp
->base
+ MXS_DCP_STAT_CLR
);
979 platform_set_drvdata(pdev
, sdcp
);
981 for (i
= 0; i
< DCP_MAX_CHANS
; i
++) {
982 mutex_init(&sdcp
->mutex
[i
]);
983 init_completion(&sdcp
->completion
[i
]);
984 crypto_init_queue(&sdcp
->queue
[i
], 50);
987 /* Create the SHA and AES handler threads. */
988 sdcp
->thread
[DCP_CHAN_HASH_SHA
] = kthread_run(dcp_chan_thread_sha
,
989 NULL
, "mxs_dcp_chan/sha");
990 if (IS_ERR(sdcp
->thread
[DCP_CHAN_HASH_SHA
])) {
991 dev_err(dev
, "Error starting SHA thread!\n");
992 ret
= PTR_ERR(sdcp
->thread
[DCP_CHAN_HASH_SHA
]);
996 sdcp
->thread
[DCP_CHAN_CRYPTO
] = kthread_run(dcp_chan_thread_aes
,
997 NULL
, "mxs_dcp_chan/aes");
998 if (IS_ERR(sdcp
->thread
[DCP_CHAN_CRYPTO
])) {
999 dev_err(dev
, "Error starting SHA thread!\n");
1000 ret
= PTR_ERR(sdcp
->thread
[DCP_CHAN_CRYPTO
]);
1001 goto err_destroy_sha_thread
;
1004 /* Register the various crypto algorithms. */
1005 sdcp
->caps
= readl(sdcp
->base
+ MXS_DCP_CAPABILITY1
);
1007 if (sdcp
->caps
& MXS_DCP_CAPABILITY1_AES128
) {
1008 ret
= crypto_register_algs(dcp_aes_algs
,
1009 ARRAY_SIZE(dcp_aes_algs
));
1011 /* Failed to register algorithm. */
1012 dev_err(dev
, "Failed to register AES crypto!\n");
1013 goto err_destroy_aes_thread
;
1017 if (sdcp
->caps
& MXS_DCP_CAPABILITY1_SHA1
) {
1018 ret
= crypto_register_ahash(&dcp_sha1_alg
);
1020 dev_err(dev
, "Failed to register %s hash!\n",
1021 dcp_sha1_alg
.halg
.base
.cra_name
);
1022 goto err_unregister_aes
;
1026 if (sdcp
->caps
& MXS_DCP_CAPABILITY1_SHA256
) {
1027 ret
= crypto_register_ahash(&dcp_sha256_alg
);
1029 dev_err(dev
, "Failed to register %s hash!\n",
1030 dcp_sha256_alg
.halg
.base
.cra_name
);
1031 goto err_unregister_sha1
;
1037 err_unregister_sha1
:
1038 if (sdcp
->caps
& MXS_DCP_CAPABILITY1_SHA1
)
1039 crypto_unregister_ahash(&dcp_sha1_alg
);
1042 if (sdcp
->caps
& MXS_DCP_CAPABILITY1_AES128
)
1043 crypto_unregister_algs(dcp_aes_algs
, ARRAY_SIZE(dcp_aes_algs
));
1045 err_destroy_aes_thread
:
1046 kthread_stop(sdcp
->thread
[DCP_CHAN_CRYPTO
]);
1048 err_destroy_sha_thread
:
1049 kthread_stop(sdcp
->thread
[DCP_CHAN_HASH_SHA
]);
1052 mutex_unlock(&global_mutex
);
1056 static int mxs_dcp_remove(struct platform_device
*pdev
)
1058 struct dcp
*sdcp
= platform_get_drvdata(pdev
);
1060 if (sdcp
->caps
& MXS_DCP_CAPABILITY1_SHA256
)
1061 crypto_unregister_ahash(&dcp_sha256_alg
);
1063 if (sdcp
->caps
& MXS_DCP_CAPABILITY1_SHA1
)
1064 crypto_unregister_ahash(&dcp_sha1_alg
);
1066 if (sdcp
->caps
& MXS_DCP_CAPABILITY1_AES128
)
1067 crypto_unregister_algs(dcp_aes_algs
, ARRAY_SIZE(dcp_aes_algs
));
1069 kthread_stop(sdcp
->thread
[DCP_CHAN_HASH_SHA
]);
1070 kthread_stop(sdcp
->thread
[DCP_CHAN_CRYPTO
]);
1072 platform_set_drvdata(pdev
, NULL
);
1074 mutex_lock(&global_mutex
);
1076 mutex_unlock(&global_mutex
);
1081 static const struct of_device_id mxs_dcp_dt_ids
[] = {
1082 { .compatible
= "fsl,imx23-dcp", .data
= NULL
, },
1083 { .compatible
= "fsl,imx28-dcp", .data
= NULL
, },
1087 MODULE_DEVICE_TABLE(of
, mxs_dcp_dt_ids
);
1089 static struct platform_driver mxs_dcp_driver
= {
1090 .probe
= mxs_dcp_probe
,
1091 .remove
= mxs_dcp_remove
,
1094 .owner
= THIS_MODULE
,
1095 .of_match_table
= mxs_dcp_dt_ids
,
1099 module_platform_driver(mxs_dcp_driver
);
1101 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
1102 MODULE_DESCRIPTION("Freescale MXS DCP Driver");
1103 MODULE_LICENSE("GPL");
1104 MODULE_ALIAS("platform:mxs-dcp");