2 * Support for Marvell's crypto engine which can be found on some Orion5X
5 * Author: Sebastian Andrzej Siewior < sebastian at breakpoint dot cc >
9 #include <crypto/aes.h>
10 #include <crypto/algapi.h>
11 #include <linux/crypto.h>
12 #include <linux/interrupt.h>
14 #include <linux/kthread.h>
15 #include <linux/platform_device.h>
16 #include <linux/scatterlist.h>
17 #include <linux/slab.h>
18 #include <crypto/internal/hash.h>
19 #include <crypto/sha.h>
23 #define MV_CESA "MV-CESA:"
24 #define MAX_HW_HASH_SIZE 0xFFFF
28 * /---------------------------------------\
29 * | | request complete
31 * IDLE -> new request -> BUSY -> done -> DEQUEUE
33 * | | more scatter entries
43 * struct req_progress - used for every crypt request
44 * @src_sg_it: sg iterator for src
45 * @dst_sg_it: sg iterator for dst
46 * @sg_src_left: bytes left in src to process (scatter list)
47 * @src_start: offset to add to src start position (scatter list)
48 * @crypt_len: length of current hw crypt/hash process
49 * @hw_nbytes: total bytes to process in hw for this request
50 * @copy_back: whether to copy data back (crypt) or not (hash)
51 * @sg_dst_left: bytes left dst to process in this scatter list
52 * @dst_start: offset to add to dst start position (scatter list)
53 * @hw_processed_bytes: number of bytes processed by hw (request).
55 * sg helper are used to iterate over the scatterlist. Since the size of the
56 * SRAM may be less than the scatter size, this struct struct is used to keep
57 * track of progress within current scatterlist.
60 struct sg_mapping_iter src_sg_it
;
61 struct sg_mapping_iter dst_sg_it
;
62 void (*complete
) (void);
63 void (*process
) (int is_first
);
74 int hw_processed_bytes
;
81 struct task_struct
*queue_th
;
83 /* the lock protects queue and eng_st */
85 struct crypto_queue queue
;
86 enum engine_status eng_st
;
87 struct crypto_async_request
*cur_req
;
88 struct req_progress p
;
95 static struct crypto_priv
*cpg
;
98 u8 aes_enc_key
[AES_KEY_LEN
];
101 u32 need_calc_aes_dkey
;
119 struct mv_tfm_hash_ctx
{
120 struct crypto_shash
*fallback
;
121 struct crypto_shash
*base_hash
;
122 u32 ivs
[2 * SHA1_DIGEST_SIZE
/ 4];
127 struct mv_req_hash_ctx
{
129 u32 state
[SHA1_DIGEST_SIZE
/ 4];
130 u8 buffer
[SHA1_BLOCK_SIZE
];
131 int first_hash
; /* marks that we don't have previous state */
132 int last_chunk
; /* marks that this is the 'final' request */
133 int extra_bytes
; /* unprocessed bytes in buffer */
136 struct scatterlist dummysg
;
139 static void compute_aes_dec_key(struct mv_ctx
*ctx
)
141 struct crypto_aes_ctx gen_aes_key
;
144 if (!ctx
->need_calc_aes_dkey
)
147 crypto_aes_expand_key(&gen_aes_key
, ctx
->aes_enc_key
, ctx
->key_len
);
149 key_pos
= ctx
->key_len
+ 24;
150 memcpy(ctx
->aes_dec_key
, &gen_aes_key
.key_enc
[key_pos
], 4 * 4);
151 switch (ctx
->key_len
) {
152 case AES_KEYSIZE_256
:
155 case AES_KEYSIZE_192
:
157 memcpy(&ctx
->aes_dec_key
[4], &gen_aes_key
.key_enc
[key_pos
],
161 ctx
->need_calc_aes_dkey
= 0;
164 static int mv_setkey_aes(struct crypto_ablkcipher
*cipher
, const u8
*key
,
167 struct crypto_tfm
*tfm
= crypto_ablkcipher_tfm(cipher
);
168 struct mv_ctx
*ctx
= crypto_tfm_ctx(tfm
);
171 case AES_KEYSIZE_128
:
172 case AES_KEYSIZE_192
:
173 case AES_KEYSIZE_256
:
176 crypto_ablkcipher_set_flags(cipher
, CRYPTO_TFM_RES_BAD_KEY_LEN
);
180 ctx
->need_calc_aes_dkey
= 1;
182 memcpy(ctx
->aes_enc_key
, key
, AES_KEY_LEN
);
186 static void copy_src_to_buf(struct req_progress
*p
, char *dbuf
, int len
)
193 if (!p
->sg_src_left
) {
194 ret
= sg_miter_next(&p
->src_sg_it
);
196 p
->sg_src_left
= p
->src_sg_it
.length
;
200 sbuf
= p
->src_sg_it
.addr
+ p
->src_start
;
202 if (p
->sg_src_left
<= len
- copied
) {
203 memcpy(dbuf
+ copied
, sbuf
, p
->sg_src_left
);
204 copied
+= p
->sg_src_left
;
209 int copy_len
= len
- copied
;
210 memcpy(dbuf
+ copied
, sbuf
, copy_len
);
211 p
->src_start
+= copy_len
;
212 p
->sg_src_left
-= copy_len
;
218 static void setup_data_in(void)
220 struct req_progress
*p
= &cpg
->p
;
222 min(p
->hw_nbytes
- p
->hw_processed_bytes
, cpg
->max_req_size
);
223 copy_src_to_buf(p
, cpg
->sram
+ SRAM_DATA_IN_START
+ p
->crypt_len
,
224 data_in_sram
- p
->crypt_len
);
225 p
->crypt_len
= data_in_sram
;
228 static void mv_process_current_q(int first_block
)
230 struct ablkcipher_request
*req
= ablkcipher_request_cast(cpg
->cur_req
);
231 struct mv_ctx
*ctx
= crypto_tfm_ctx(req
->base
.tfm
);
232 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
233 struct sec_accel_config op
;
235 switch (req_ctx
->op
) {
237 op
.config
= CFG_OP_CRYPT_ONLY
| CFG_ENCM_AES
| CFG_ENC_MODE_ECB
;
241 op
.config
= CFG_OP_CRYPT_ONLY
| CFG_ENCM_AES
| CFG_ENC_MODE_CBC
;
242 op
.enc_iv
= ENC_IV_POINT(SRAM_DATA_IV
) |
243 ENC_IV_BUF_POINT(SRAM_DATA_IV_BUF
);
245 memcpy(cpg
->sram
+ SRAM_DATA_IV
, req
->info
, 16);
248 if (req_ctx
->decrypt
) {
249 op
.config
|= CFG_DIR_DEC
;
250 memcpy(cpg
->sram
+ SRAM_DATA_KEY_P
, ctx
->aes_dec_key
,
253 op
.config
|= CFG_DIR_ENC
;
254 memcpy(cpg
->sram
+ SRAM_DATA_KEY_P
, ctx
->aes_enc_key
,
258 switch (ctx
->key_len
) {
259 case AES_KEYSIZE_128
:
260 op
.config
|= CFG_AES_LEN_128
;
262 case AES_KEYSIZE_192
:
263 op
.config
|= CFG_AES_LEN_192
;
265 case AES_KEYSIZE_256
:
266 op
.config
|= CFG_AES_LEN_256
;
269 op
.enc_p
= ENC_P_SRC(SRAM_DATA_IN_START
) |
270 ENC_P_DST(SRAM_DATA_OUT_START
);
271 op
.enc_key_p
= SRAM_DATA_KEY_P
;
274 op
.enc_len
= cpg
->p
.crypt_len
;
275 memcpy(cpg
->sram
+ SRAM_CONFIG
, &op
,
276 sizeof(struct sec_accel_config
));
278 writel(SRAM_CONFIG
, cpg
->reg
+ SEC_ACCEL_DESC_P0
);
280 writel(SEC_CMD_EN_SEC_ACCL0
, cpg
->reg
+ SEC_ACCEL_CMD
);
284 static void mv_crypto_algo_completion(void)
286 struct ablkcipher_request
*req
= ablkcipher_request_cast(cpg
->cur_req
);
287 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
289 sg_miter_stop(&cpg
->p
.src_sg_it
);
290 sg_miter_stop(&cpg
->p
.dst_sg_it
);
292 if (req_ctx
->op
!= COP_AES_CBC
)
295 memcpy(req
->info
, cpg
->sram
+ SRAM_DATA_IV_BUF
, 16);
298 static void mv_process_hash_current(int first_block
)
300 struct ahash_request
*req
= ahash_request_cast(cpg
->cur_req
);
301 struct mv_req_hash_ctx
*req_ctx
= ahash_request_ctx(req
);
302 struct req_progress
*p
= &cpg
->p
;
303 struct sec_accel_config op
= { 0 };
306 switch (req_ctx
->op
) {
309 op
.config
= CFG_OP_MAC_ONLY
| CFG_MACM_SHA1
;
312 op
.config
= CFG_OP_MAC_ONLY
| CFG_MACM_HMAC_SHA1
;
317 MAC_SRC_DATA_P(SRAM_DATA_IN_START
) | MAC_SRC_TOTAL_LEN((u32
)
324 MAC_DIGEST_P(SRAM_DIGEST_BUF
) | MAC_FRAG_LEN(p
->crypt_len
);
326 MAC_INNER_IV_P(SRAM_HMAC_IV_IN
) |
327 MAC_OUTER_IV_P(SRAM_HMAC_IV_OUT
);
329 is_last
= req_ctx
->last_chunk
330 && (p
->hw_processed_bytes
+ p
->crypt_len
>= p
->hw_nbytes
)
331 && (req_ctx
->count
<= MAX_HW_HASH_SIZE
);
332 if (req_ctx
->first_hash
) {
334 op
.config
|= CFG_NOT_FRAG
;
336 op
.config
|= CFG_FIRST_FRAG
;
338 req_ctx
->first_hash
= 0;
341 op
.config
|= CFG_LAST_FRAG
;
343 op
.config
|= CFG_MID_FRAG
;
346 memcpy(cpg
->sram
+ SRAM_CONFIG
, &op
, sizeof(struct sec_accel_config
));
348 writel(SRAM_CONFIG
, cpg
->reg
+ SEC_ACCEL_DESC_P0
);
350 writel(SEC_CMD_EN_SEC_ACCL0
, cpg
->reg
+ SEC_ACCEL_CMD
);
354 static inline int mv_hash_import_sha1_ctx(const struct mv_req_hash_ctx
*ctx
,
355 struct shash_desc
*desc
)
358 struct sha1_state shash_state
;
360 shash_state
.count
= ctx
->count
+ ctx
->count_add
;
361 for (i
= 0; i
< 5; i
++)
362 shash_state
.state
[i
] = ctx
->state
[i
];
363 memcpy(shash_state
.buffer
, ctx
->buffer
, sizeof(shash_state
.buffer
));
364 return crypto_shash_import(desc
, &shash_state
);
367 static int mv_hash_final_fallback(struct ahash_request
*req
)
369 const struct mv_tfm_hash_ctx
*tfm_ctx
= crypto_tfm_ctx(req
->base
.tfm
);
370 struct mv_req_hash_ctx
*req_ctx
= ahash_request_ctx(req
);
372 struct shash_desc shash
;
373 char ctx
[crypto_shash_descsize(tfm_ctx
->fallback
)];
377 desc
.shash
.tfm
= tfm_ctx
->fallback
;
378 desc
.shash
.flags
= CRYPTO_TFM_REQ_MAY_SLEEP
;
379 if (unlikely(req_ctx
->first_hash
)) {
380 crypto_shash_init(&desc
.shash
);
381 crypto_shash_update(&desc
.shash
, req_ctx
->buffer
,
382 req_ctx
->extra_bytes
);
384 /* only SHA1 for now....
386 rc
= mv_hash_import_sha1_ctx(req_ctx
, &desc
.shash
);
390 rc
= crypto_shash_final(&desc
.shash
, req
->result
);
395 static void mv_hash_algo_completion(void)
397 struct ahash_request
*req
= ahash_request_cast(cpg
->cur_req
);
398 struct mv_req_hash_ctx
*ctx
= ahash_request_ctx(req
);
400 if (ctx
->extra_bytes
)
401 copy_src_to_buf(&cpg
->p
, ctx
->buffer
, ctx
->extra_bytes
);
402 sg_miter_stop(&cpg
->p
.src_sg_it
);
404 ctx
->state
[0] = readl(cpg
->reg
+ DIGEST_INITIAL_VAL_A
);
405 ctx
->state
[1] = readl(cpg
->reg
+ DIGEST_INITIAL_VAL_B
);
406 ctx
->state
[2] = readl(cpg
->reg
+ DIGEST_INITIAL_VAL_C
);
407 ctx
->state
[3] = readl(cpg
->reg
+ DIGEST_INITIAL_VAL_D
);
408 ctx
->state
[4] = readl(cpg
->reg
+ DIGEST_INITIAL_VAL_E
);
410 if (likely(ctx
->last_chunk
)) {
411 if (likely(ctx
->count
<= MAX_HW_HASH_SIZE
)) {
412 memcpy(req
->result
, cpg
->sram
+ SRAM_DIGEST_BUF
,
413 crypto_ahash_digestsize(crypto_ahash_reqtfm
416 mv_hash_final_fallback(req
);
420 static void dequeue_complete_req(void)
422 struct crypto_async_request
*req
= cpg
->cur_req
;
425 cpg
->p
.hw_processed_bytes
+= cpg
->p
.crypt_len
;
426 if (cpg
->p
.copy_back
) {
427 int need_copy_len
= cpg
->p
.crypt_len
;
432 if (!cpg
->p
.sg_dst_left
) {
433 ret
= sg_miter_next(&cpg
->p
.dst_sg_it
);
435 cpg
->p
.sg_dst_left
= cpg
->p
.dst_sg_it
.length
;
436 cpg
->p
.dst_start
= 0;
439 buf
= cpg
->p
.dst_sg_it
.addr
;
440 buf
+= cpg
->p
.dst_start
;
442 dst_copy
= min(need_copy_len
, cpg
->p
.sg_dst_left
);
445 cpg
->sram
+ SRAM_DATA_OUT_START
+ sram_offset
,
447 sram_offset
+= dst_copy
;
448 cpg
->p
.sg_dst_left
-= dst_copy
;
449 need_copy_len
-= dst_copy
;
450 cpg
->p
.dst_start
+= dst_copy
;
451 } while (need_copy_len
> 0);
454 cpg
->p
.crypt_len
= 0;
456 BUG_ON(cpg
->eng_st
!= ENGINE_W_DEQUEUE
);
457 if (cpg
->p
.hw_processed_bytes
< cpg
->p
.hw_nbytes
) {
458 /* process next scatter list entry */
459 cpg
->eng_st
= ENGINE_BUSY
;
463 cpg
->eng_st
= ENGINE_IDLE
;
465 req
->complete(req
, 0);
470 static int count_sgs(struct scatterlist
*sl
, unsigned int total_bytes
)
476 cur_len
= sl
[i
].length
;
478 if (total_bytes
> cur_len
)
479 total_bytes
-= cur_len
;
487 static void mv_start_new_crypt_req(struct ablkcipher_request
*req
)
489 struct req_progress
*p
= &cpg
->p
;
492 cpg
->cur_req
= &req
->base
;
493 memset(p
, 0, sizeof(struct req_progress
));
494 p
->hw_nbytes
= req
->nbytes
;
495 p
->complete
= mv_crypto_algo_completion
;
496 p
->process
= mv_process_current_q
;
499 num_sgs
= count_sgs(req
->src
, req
->nbytes
);
500 sg_miter_start(&p
->src_sg_it
, req
->src
, num_sgs
, SG_MITER_FROM_SG
);
502 num_sgs
= count_sgs(req
->dst
, req
->nbytes
);
503 sg_miter_start(&p
->dst_sg_it
, req
->dst
, num_sgs
, SG_MITER_TO_SG
);
505 mv_process_current_q(1);
508 static void mv_start_new_hash_req(struct ahash_request
*req
)
510 struct req_progress
*p
= &cpg
->p
;
511 struct mv_req_hash_ctx
*ctx
= ahash_request_ctx(req
);
512 const struct mv_tfm_hash_ctx
*tfm_ctx
= crypto_tfm_ctx(req
->base
.tfm
);
513 int num_sgs
, hw_bytes
, old_extra_bytes
, rc
;
514 cpg
->cur_req
= &req
->base
;
515 memset(p
, 0, sizeof(struct req_progress
));
516 hw_bytes
= req
->nbytes
+ ctx
->extra_bytes
;
517 old_extra_bytes
= ctx
->extra_bytes
;
519 if (unlikely(ctx
->extra_bytes
)) {
520 memcpy(cpg
->sram
+ SRAM_DATA_IN_START
, ctx
->buffer
,
522 p
->crypt_len
= ctx
->extra_bytes
;
525 memcpy(cpg
->sram
+ SRAM_HMAC_IV_IN
, tfm_ctx
->ivs
, sizeof(tfm_ctx
->ivs
));
527 if (unlikely(!ctx
->first_hash
)) {
528 writel(ctx
->state
[0], cpg
->reg
+ DIGEST_INITIAL_VAL_A
);
529 writel(ctx
->state
[1], cpg
->reg
+ DIGEST_INITIAL_VAL_B
);
530 writel(ctx
->state
[2], cpg
->reg
+ DIGEST_INITIAL_VAL_C
);
531 writel(ctx
->state
[3], cpg
->reg
+ DIGEST_INITIAL_VAL_D
);
532 writel(ctx
->state
[4], cpg
->reg
+ DIGEST_INITIAL_VAL_E
);
535 ctx
->extra_bytes
= hw_bytes
% SHA1_BLOCK_SIZE
;
536 if (ctx
->extra_bytes
!= 0
537 && (!ctx
->last_chunk
|| ctx
->count
> MAX_HW_HASH_SIZE
))
538 hw_bytes
-= ctx
->extra_bytes
;
540 ctx
->extra_bytes
= 0;
542 num_sgs
= count_sgs(req
->src
, req
->nbytes
);
543 sg_miter_start(&p
->src_sg_it
, req
->src
, num_sgs
, SG_MITER_FROM_SG
);
546 p
->hw_nbytes
= hw_bytes
;
547 p
->complete
= mv_hash_algo_completion
;
548 p
->process
= mv_process_hash_current
;
550 mv_process_hash_current(1);
552 copy_src_to_buf(p
, ctx
->buffer
+ old_extra_bytes
,
553 ctx
->extra_bytes
- old_extra_bytes
);
554 sg_miter_stop(&p
->src_sg_it
);
556 rc
= mv_hash_final_fallback(req
);
559 cpg
->eng_st
= ENGINE_IDLE
;
561 req
->base
.complete(&req
->base
, rc
);
566 static int queue_manag(void *data
)
568 cpg
->eng_st
= ENGINE_IDLE
;
570 struct crypto_async_request
*async_req
= NULL
;
571 struct crypto_async_request
*backlog
;
573 __set_current_state(TASK_INTERRUPTIBLE
);
575 if (cpg
->eng_st
== ENGINE_W_DEQUEUE
)
576 dequeue_complete_req();
578 spin_lock_irq(&cpg
->lock
);
579 if (cpg
->eng_st
== ENGINE_IDLE
) {
580 backlog
= crypto_get_backlog(&cpg
->queue
);
581 async_req
= crypto_dequeue_request(&cpg
->queue
);
583 BUG_ON(cpg
->eng_st
!= ENGINE_IDLE
);
584 cpg
->eng_st
= ENGINE_BUSY
;
587 spin_unlock_irq(&cpg
->lock
);
590 backlog
->complete(backlog
, -EINPROGRESS
);
595 if (async_req
->tfm
->__crt_alg
->cra_type
!=
596 &crypto_ahash_type
) {
597 struct ablkcipher_request
*req
=
598 container_of(async_req
,
599 struct ablkcipher_request
,
601 mv_start_new_crypt_req(req
);
603 struct ahash_request
*req
=
604 ahash_request_cast(async_req
);
605 mv_start_new_hash_req(req
);
612 } while (!kthread_should_stop());
616 static int mv_handle_req(struct crypto_async_request
*req
)
621 spin_lock_irqsave(&cpg
->lock
, flags
);
622 ret
= crypto_enqueue_request(&cpg
->queue
, req
);
623 spin_unlock_irqrestore(&cpg
->lock
, flags
);
624 wake_up_process(cpg
->queue_th
);
628 static int mv_enc_aes_ecb(struct ablkcipher_request
*req
)
630 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
632 req_ctx
->op
= COP_AES_ECB
;
633 req_ctx
->decrypt
= 0;
635 return mv_handle_req(&req
->base
);
638 static int mv_dec_aes_ecb(struct ablkcipher_request
*req
)
640 struct mv_ctx
*ctx
= crypto_tfm_ctx(req
->base
.tfm
);
641 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
643 req_ctx
->op
= COP_AES_ECB
;
644 req_ctx
->decrypt
= 1;
646 compute_aes_dec_key(ctx
);
647 return mv_handle_req(&req
->base
);
650 static int mv_enc_aes_cbc(struct ablkcipher_request
*req
)
652 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
654 req_ctx
->op
= COP_AES_CBC
;
655 req_ctx
->decrypt
= 0;
657 return mv_handle_req(&req
->base
);
660 static int mv_dec_aes_cbc(struct ablkcipher_request
*req
)
662 struct mv_ctx
*ctx
= crypto_tfm_ctx(req
->base
.tfm
);
663 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
665 req_ctx
->op
= COP_AES_CBC
;
666 req_ctx
->decrypt
= 1;
668 compute_aes_dec_key(ctx
);
669 return mv_handle_req(&req
->base
);
672 static int mv_cra_init(struct crypto_tfm
*tfm
)
674 tfm
->crt_ablkcipher
.reqsize
= sizeof(struct mv_req_ctx
);
678 static void mv_init_hash_req_ctx(struct mv_req_hash_ctx
*ctx
, int op
,
679 int is_last
, unsigned int req_len
,
682 memset(ctx
, 0, sizeof(*ctx
));
684 ctx
->count
= req_len
;
686 ctx
->last_chunk
= is_last
;
687 ctx
->count_add
= count_add
;
690 static void mv_update_hash_req_ctx(struct mv_req_hash_ctx
*ctx
, int is_last
,
693 ctx
->last_chunk
= is_last
;
694 ctx
->count
+= req_len
;
697 static int mv_hash_init(struct ahash_request
*req
)
699 const struct mv_tfm_hash_ctx
*tfm_ctx
= crypto_tfm_ctx(req
->base
.tfm
);
700 mv_init_hash_req_ctx(ahash_request_ctx(req
), tfm_ctx
->op
, 0, 0,
705 static int mv_hash_update(struct ahash_request
*req
)
710 mv_update_hash_req_ctx(ahash_request_ctx(req
), 0, req
->nbytes
);
711 return mv_handle_req(&req
->base
);
714 static int mv_hash_final(struct ahash_request
*req
)
716 struct mv_req_hash_ctx
*ctx
= ahash_request_ctx(req
);
717 /* dummy buffer of 4 bytes */
718 sg_init_one(&ctx
->dummysg
, ctx
->buffer
, 4);
719 /* I think I'm allowed to do that... */
720 ahash_request_set_crypt(req
, &ctx
->dummysg
, req
->result
, 0);
721 mv_update_hash_req_ctx(ctx
, 1, 0);
722 return mv_handle_req(&req
->base
);
725 static int mv_hash_finup(struct ahash_request
*req
)
728 return mv_hash_final(req
);
730 mv_update_hash_req_ctx(ahash_request_ctx(req
), 1, req
->nbytes
);
731 return mv_handle_req(&req
->base
);
734 static int mv_hash_digest(struct ahash_request
*req
)
736 const struct mv_tfm_hash_ctx
*tfm_ctx
= crypto_tfm_ctx(req
->base
.tfm
);
737 mv_init_hash_req_ctx(ahash_request_ctx(req
), tfm_ctx
->op
, 1,
738 req
->nbytes
, tfm_ctx
->count_add
);
739 return mv_handle_req(&req
->base
);
742 static void mv_hash_init_ivs(struct mv_tfm_hash_ctx
*ctx
, const void *istate
,
745 const struct sha1_state
*isha1_state
= istate
, *osha1_state
= ostate
;
747 for (i
= 0; i
< 5; i
++) {
748 ctx
->ivs
[i
] = cpu_to_be32(isha1_state
->state
[i
]);
749 ctx
->ivs
[i
+ 5] = cpu_to_be32(osha1_state
->state
[i
]);
753 static int mv_hash_setkey(struct crypto_ahash
*tfm
, const u8
* key
,
757 struct mv_tfm_hash_ctx
*ctx
= crypto_tfm_ctx(&tfm
->base
);
763 rc
= crypto_shash_setkey(ctx
->fallback
, key
, keylen
);
767 /* Can't see a way to extract the ipad/opad from the fallback tfm
768 so I'm basically copying code from the hmac module */
769 bs
= crypto_shash_blocksize(ctx
->base_hash
);
770 ds
= crypto_shash_digestsize(ctx
->base_hash
);
771 ss
= crypto_shash_statesize(ctx
->base_hash
);
775 struct shash_desc shash
;
776 char ctx
[crypto_shash_descsize(ctx
->base_hash
)];
782 desc
.shash
.tfm
= ctx
->base_hash
;
783 desc
.shash
.flags
= crypto_shash_get_flags(ctx
->base_hash
) &
784 CRYPTO_TFM_REQ_MAY_SLEEP
;
790 crypto_shash_digest(&desc
.shash
, key
, keylen
, ipad
);
796 memcpy(ipad
, key
, keylen
);
798 memset(ipad
+ keylen
, 0, bs
- keylen
);
799 memcpy(opad
, ipad
, bs
);
801 for (i
= 0; i
< bs
; i
++) {
806 rc
= crypto_shash_init(&desc
.shash
) ? :
807 crypto_shash_update(&desc
.shash
, ipad
, bs
) ? :
808 crypto_shash_export(&desc
.shash
, ipad
) ? :
809 crypto_shash_init(&desc
.shash
) ? :
810 crypto_shash_update(&desc
.shash
, opad
, bs
) ? :
811 crypto_shash_export(&desc
.shash
, opad
);
814 mv_hash_init_ivs(ctx
, ipad
, opad
);
820 static int mv_cra_hash_init(struct crypto_tfm
*tfm
, const char *base_hash_name
,
821 enum hash_op op
, int count_add
)
823 const char *fallback_driver_name
= tfm
->__crt_alg
->cra_name
;
824 struct mv_tfm_hash_ctx
*ctx
= crypto_tfm_ctx(tfm
);
825 struct crypto_shash
*fallback_tfm
= NULL
;
826 struct crypto_shash
*base_hash
= NULL
;
830 ctx
->count_add
= count_add
;
832 /* Allocate a fallback and abort if it failed. */
833 fallback_tfm
= crypto_alloc_shash(fallback_driver_name
, 0,
834 CRYPTO_ALG_NEED_FALLBACK
);
835 if (IS_ERR(fallback_tfm
)) {
836 printk(KERN_WARNING MV_CESA
837 "Fallback driver '%s' could not be loaded!\n",
838 fallback_driver_name
);
839 err
= PTR_ERR(fallback_tfm
);
842 ctx
->fallback
= fallback_tfm
;
844 if (base_hash_name
) {
845 /* Allocate a hash to compute the ipad/opad of hmac. */
846 base_hash
= crypto_alloc_shash(base_hash_name
, 0,
847 CRYPTO_ALG_NEED_FALLBACK
);
848 if (IS_ERR(base_hash
)) {
849 printk(KERN_WARNING MV_CESA
850 "Base driver '%s' could not be loaded!\n",
852 err
= PTR_ERR(fallback_tfm
);
856 ctx
->base_hash
= base_hash
;
858 crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm
),
859 sizeof(struct mv_req_hash_ctx
) +
860 crypto_shash_descsize(ctx
->fallback
));
863 crypto_free_shash(fallback_tfm
);
868 static void mv_cra_hash_exit(struct crypto_tfm
*tfm
)
870 struct mv_tfm_hash_ctx
*ctx
= crypto_tfm_ctx(tfm
);
872 crypto_free_shash(ctx
->fallback
);
874 crypto_free_shash(ctx
->base_hash
);
877 static int mv_cra_hash_sha1_init(struct crypto_tfm
*tfm
)
879 return mv_cra_hash_init(tfm
, NULL
, COP_SHA1
, 0);
882 static int mv_cra_hash_hmac_sha1_init(struct crypto_tfm
*tfm
)
884 return mv_cra_hash_init(tfm
, "sha1", COP_HMAC_SHA1
, SHA1_BLOCK_SIZE
);
887 irqreturn_t
crypto_int(int irq
, void *priv
)
891 val
= readl(cpg
->reg
+ SEC_ACCEL_INT_STATUS
);
892 if (!(val
& SEC_INT_ACCEL0_DONE
))
895 val
&= ~SEC_INT_ACCEL0_DONE
;
896 writel(val
, cpg
->reg
+ FPGA_INT_STATUS
);
897 writel(val
, cpg
->reg
+ SEC_ACCEL_INT_STATUS
);
898 BUG_ON(cpg
->eng_st
!= ENGINE_BUSY
);
899 cpg
->eng_st
= ENGINE_W_DEQUEUE
;
900 wake_up_process(cpg
->queue_th
);
904 struct crypto_alg mv_aes_alg_ecb
= {
905 .cra_name
= "ecb(aes)",
906 .cra_driver_name
= "mv-ecb-aes",
908 .cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
| CRYPTO_ALG_ASYNC
,
910 .cra_ctxsize
= sizeof(struct mv_ctx
),
912 .cra_type
= &crypto_ablkcipher_type
,
913 .cra_module
= THIS_MODULE
,
914 .cra_init
= mv_cra_init
,
917 .min_keysize
= AES_MIN_KEY_SIZE
,
918 .max_keysize
= AES_MAX_KEY_SIZE
,
919 .setkey
= mv_setkey_aes
,
920 .encrypt
= mv_enc_aes_ecb
,
921 .decrypt
= mv_dec_aes_ecb
,
926 struct crypto_alg mv_aes_alg_cbc
= {
927 .cra_name
= "cbc(aes)",
928 .cra_driver_name
= "mv-cbc-aes",
930 .cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
| CRYPTO_ALG_ASYNC
,
931 .cra_blocksize
= AES_BLOCK_SIZE
,
932 .cra_ctxsize
= sizeof(struct mv_ctx
),
934 .cra_type
= &crypto_ablkcipher_type
,
935 .cra_module
= THIS_MODULE
,
936 .cra_init
= mv_cra_init
,
939 .ivsize
= AES_BLOCK_SIZE
,
940 .min_keysize
= AES_MIN_KEY_SIZE
,
941 .max_keysize
= AES_MAX_KEY_SIZE
,
942 .setkey
= mv_setkey_aes
,
943 .encrypt
= mv_enc_aes_cbc
,
944 .decrypt
= mv_dec_aes_cbc
,
949 struct ahash_alg mv_sha1_alg
= {
950 .init
= mv_hash_init
,
951 .update
= mv_hash_update
,
952 .final
= mv_hash_final
,
953 .finup
= mv_hash_finup
,
954 .digest
= mv_hash_digest
,
956 .digestsize
= SHA1_DIGEST_SIZE
,
959 .cra_driver_name
= "mv-sha1",
962 CRYPTO_ALG_ASYNC
| CRYPTO_ALG_NEED_FALLBACK
,
963 .cra_blocksize
= SHA1_BLOCK_SIZE
,
964 .cra_ctxsize
= sizeof(struct mv_tfm_hash_ctx
),
965 .cra_init
= mv_cra_hash_sha1_init
,
966 .cra_exit
= mv_cra_hash_exit
,
967 .cra_module
= THIS_MODULE
,
972 struct ahash_alg mv_hmac_sha1_alg
= {
973 .init
= mv_hash_init
,
974 .update
= mv_hash_update
,
975 .final
= mv_hash_final
,
976 .finup
= mv_hash_finup
,
977 .digest
= mv_hash_digest
,
978 .setkey
= mv_hash_setkey
,
980 .digestsize
= SHA1_DIGEST_SIZE
,
982 .cra_name
= "hmac(sha1)",
983 .cra_driver_name
= "mv-hmac-sha1",
986 CRYPTO_ALG_ASYNC
| CRYPTO_ALG_NEED_FALLBACK
,
987 .cra_blocksize
= SHA1_BLOCK_SIZE
,
988 .cra_ctxsize
= sizeof(struct mv_tfm_hash_ctx
),
989 .cra_init
= mv_cra_hash_hmac_sha1_init
,
990 .cra_exit
= mv_cra_hash_exit
,
991 .cra_module
= THIS_MODULE
,
996 static int mv_probe(struct platform_device
*pdev
)
998 struct crypto_priv
*cp
;
999 struct resource
*res
;
1004 printk(KERN_ERR MV_CESA
"Second crypto dev?\n");
1008 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "regs");
1012 cp
= kzalloc(sizeof(*cp
), GFP_KERNEL
);
1016 spin_lock_init(&cp
->lock
);
1017 crypto_init_queue(&cp
->queue
, 50);
1018 cp
->reg
= ioremap(res
->start
, resource_size(res
));
1024 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "sram");
1029 cp
->sram_size
= resource_size(res
);
1030 cp
->max_req_size
= cp
->sram_size
- SRAM_CFG_SPACE
;
1031 cp
->sram
= ioremap(res
->start
, cp
->sram_size
);
1037 irq
= platform_get_irq(pdev
, 0);
1038 if (irq
< 0 || irq
== NO_IRQ
) {
1040 goto err_unmap_sram
;
1044 platform_set_drvdata(pdev
, cp
);
1047 cp
->queue_th
= kthread_run(queue_manag
, cp
, "mv_crypto");
1048 if (IS_ERR(cp
->queue_th
)) {
1049 ret
= PTR_ERR(cp
->queue_th
);
1050 goto err_unmap_sram
;
1053 ret
= request_irq(irq
, crypto_int
, IRQF_DISABLED
, dev_name(&pdev
->dev
),
1058 writel(SEC_INT_ACCEL0_DONE
, cpg
->reg
+ SEC_ACCEL_INT_MASK
);
1059 writel(SEC_CFG_STOP_DIG_ERR
, cpg
->reg
+ SEC_ACCEL_CFG
);
1061 ret
= crypto_register_alg(&mv_aes_alg_ecb
);
1065 ret
= crypto_register_alg(&mv_aes_alg_cbc
);
1069 ret
= crypto_register_ahash(&mv_sha1_alg
);
1073 printk(KERN_WARNING MV_CESA
"Could not register sha1 driver\n");
1075 ret
= crypto_register_ahash(&mv_hmac_sha1_alg
);
1077 cpg
->has_hmac_sha1
= 1;
1079 printk(KERN_WARNING MV_CESA
1080 "Could not register hmac-sha1 driver\n");
1085 crypto_unregister_alg(&mv_aes_alg_ecb
);
1089 kthread_stop(cp
->queue_th
);
1097 platform_set_drvdata(pdev
, NULL
);
1101 static int mv_remove(struct platform_device
*pdev
)
1103 struct crypto_priv
*cp
= platform_get_drvdata(pdev
);
1105 crypto_unregister_alg(&mv_aes_alg_ecb
);
1106 crypto_unregister_alg(&mv_aes_alg_cbc
);
1108 crypto_unregister_ahash(&mv_sha1_alg
);
1109 if (cp
->has_hmac_sha1
)
1110 crypto_unregister_ahash(&mv_hmac_sha1_alg
);
1111 kthread_stop(cp
->queue_th
);
1112 free_irq(cp
->irq
, cp
);
1113 memset(cp
->sram
, 0, cp
->sram_size
);
1121 static struct platform_driver marvell_crypto
= {
1123 .remove
= mv_remove
,
1125 .owner
= THIS_MODULE
,
1126 .name
= "mv_crypto",
1129 MODULE_ALIAS("platform:mv_crypto");
1131 static int __init
mv_crypto_init(void)
1133 return platform_driver_register(&marvell_crypto
);
1135 module_init(mv_crypto_init
);
1137 static void __exit
mv_crypto_exit(void)
1139 platform_driver_unregister(&marvell_crypto
);
1141 module_exit(mv_crypto_exit
);
1143 MODULE_AUTHOR("Sebastian Andrzej Siewior <sebastian@breakpoint.cc>");
1144 MODULE_DESCRIPTION("Support for Marvell's cryptographic engine");
1145 MODULE_LICENSE("GPL");