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
));
279 writel(SEC_CMD_EN_SEC_ACCL0
, cpg
->reg
+ SEC_ACCEL_CMD
);
282 * XXX: add timer if the interrupt does not occur for some mystery
287 static void mv_crypto_algo_completion(void)
289 struct ablkcipher_request
*req
= ablkcipher_request_cast(cpg
->cur_req
);
290 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
292 sg_miter_stop(&cpg
->p
.src_sg_it
);
293 sg_miter_stop(&cpg
->p
.dst_sg_it
);
295 if (req_ctx
->op
!= COP_AES_CBC
)
298 memcpy(req
->info
, cpg
->sram
+ SRAM_DATA_IV_BUF
, 16);
301 static void mv_process_hash_current(int first_block
)
303 struct ahash_request
*req
= ahash_request_cast(cpg
->cur_req
);
304 struct mv_req_hash_ctx
*req_ctx
= ahash_request_ctx(req
);
305 struct req_progress
*p
= &cpg
->p
;
306 struct sec_accel_config op
= { 0 };
309 switch (req_ctx
->op
) {
312 op
.config
= CFG_OP_MAC_ONLY
| CFG_MACM_SHA1
;
315 op
.config
= CFG_OP_MAC_ONLY
| CFG_MACM_HMAC_SHA1
;
320 MAC_SRC_DATA_P(SRAM_DATA_IN_START
) | MAC_SRC_TOTAL_LEN((u32
)
327 MAC_DIGEST_P(SRAM_DIGEST_BUF
) | MAC_FRAG_LEN(p
->crypt_len
);
329 MAC_INNER_IV_P(SRAM_HMAC_IV_IN
) |
330 MAC_OUTER_IV_P(SRAM_HMAC_IV_OUT
);
332 is_last
= req_ctx
->last_chunk
333 && (p
->hw_processed_bytes
+ p
->crypt_len
>= p
->hw_nbytes
)
334 && (req_ctx
->count
<= MAX_HW_HASH_SIZE
);
335 if (req_ctx
->first_hash
) {
337 op
.config
|= CFG_NOT_FRAG
;
339 op
.config
|= CFG_FIRST_FRAG
;
341 req_ctx
->first_hash
= 0;
344 op
.config
|= CFG_LAST_FRAG
;
346 op
.config
|= CFG_MID_FRAG
;
349 memcpy(cpg
->sram
+ SRAM_CONFIG
, &op
, sizeof(struct sec_accel_config
));
352 writel(SEC_CMD_EN_SEC_ACCL0
, cpg
->reg
+ SEC_ACCEL_CMD
);
355 * XXX: add timer if the interrupt does not occur for some mystery
360 static inline int mv_hash_import_sha1_ctx(const struct mv_req_hash_ctx
*ctx
,
361 struct shash_desc
*desc
)
364 struct sha1_state shash_state
;
366 shash_state
.count
= ctx
->count
+ ctx
->count_add
;
367 for (i
= 0; i
< 5; i
++)
368 shash_state
.state
[i
] = ctx
->state
[i
];
369 memcpy(shash_state
.buffer
, ctx
->buffer
, sizeof(shash_state
.buffer
));
370 return crypto_shash_import(desc
, &shash_state
);
373 static int mv_hash_final_fallback(struct ahash_request
*req
)
375 const struct mv_tfm_hash_ctx
*tfm_ctx
= crypto_tfm_ctx(req
->base
.tfm
);
376 struct mv_req_hash_ctx
*req_ctx
= ahash_request_ctx(req
);
378 struct shash_desc shash
;
379 char ctx
[crypto_shash_descsize(tfm_ctx
->fallback
)];
383 desc
.shash
.tfm
= tfm_ctx
->fallback
;
384 desc
.shash
.flags
= CRYPTO_TFM_REQ_MAY_SLEEP
;
385 if (unlikely(req_ctx
->first_hash
)) {
386 crypto_shash_init(&desc
.shash
);
387 crypto_shash_update(&desc
.shash
, req_ctx
->buffer
,
388 req_ctx
->extra_bytes
);
390 /* only SHA1 for now....
392 rc
= mv_hash_import_sha1_ctx(req_ctx
, &desc
.shash
);
396 rc
= crypto_shash_final(&desc
.shash
, req
->result
);
401 static void mv_hash_algo_completion(void)
403 struct ahash_request
*req
= ahash_request_cast(cpg
->cur_req
);
404 struct mv_req_hash_ctx
*ctx
= ahash_request_ctx(req
);
406 if (ctx
->extra_bytes
)
407 copy_src_to_buf(&cpg
->p
, ctx
->buffer
, ctx
->extra_bytes
);
408 sg_miter_stop(&cpg
->p
.src_sg_it
);
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
);
418 ctx
->state
[0] = readl(cpg
->reg
+ DIGEST_INITIAL_VAL_A
);
419 ctx
->state
[1] = readl(cpg
->reg
+ DIGEST_INITIAL_VAL_B
);
420 ctx
->state
[2] = readl(cpg
->reg
+ DIGEST_INITIAL_VAL_C
);
421 ctx
->state
[3] = readl(cpg
->reg
+ DIGEST_INITIAL_VAL_D
);
422 ctx
->state
[4] = readl(cpg
->reg
+ DIGEST_INITIAL_VAL_E
);
426 static void dequeue_complete_req(void)
428 struct crypto_async_request
*req
= cpg
->cur_req
;
431 cpg
->p
.hw_processed_bytes
+= cpg
->p
.crypt_len
;
432 if (cpg
->p
.copy_back
) {
433 int need_copy_len
= cpg
->p
.crypt_len
;
438 if (!cpg
->p
.sg_dst_left
) {
439 ret
= sg_miter_next(&cpg
->p
.dst_sg_it
);
441 cpg
->p
.sg_dst_left
= cpg
->p
.dst_sg_it
.length
;
442 cpg
->p
.dst_start
= 0;
445 buf
= cpg
->p
.dst_sg_it
.addr
;
446 buf
+= cpg
->p
.dst_start
;
448 dst_copy
= min(need_copy_len
, cpg
->p
.sg_dst_left
);
451 cpg
->sram
+ SRAM_DATA_OUT_START
+ sram_offset
,
453 sram_offset
+= dst_copy
;
454 cpg
->p
.sg_dst_left
-= dst_copy
;
455 need_copy_len
-= dst_copy
;
456 cpg
->p
.dst_start
+= dst_copy
;
457 } while (need_copy_len
> 0);
460 cpg
->p
.crypt_len
= 0;
462 BUG_ON(cpg
->eng_st
!= ENGINE_W_DEQUEUE
);
463 if (cpg
->p
.hw_processed_bytes
< cpg
->p
.hw_nbytes
) {
464 /* process next scatter list entry */
465 cpg
->eng_st
= ENGINE_BUSY
;
469 cpg
->eng_st
= ENGINE_IDLE
;
471 req
->complete(req
, 0);
476 static int count_sgs(struct scatterlist
*sl
, unsigned int total_bytes
)
482 cur_len
= sl
[i
].length
;
484 if (total_bytes
> cur_len
)
485 total_bytes
-= cur_len
;
493 static void mv_start_new_crypt_req(struct ablkcipher_request
*req
)
495 struct req_progress
*p
= &cpg
->p
;
498 cpg
->cur_req
= &req
->base
;
499 memset(p
, 0, sizeof(struct req_progress
));
500 p
->hw_nbytes
= req
->nbytes
;
501 p
->complete
= mv_crypto_algo_completion
;
502 p
->process
= mv_process_current_q
;
505 num_sgs
= count_sgs(req
->src
, req
->nbytes
);
506 sg_miter_start(&p
->src_sg_it
, req
->src
, num_sgs
, SG_MITER_FROM_SG
);
508 num_sgs
= count_sgs(req
->dst
, req
->nbytes
);
509 sg_miter_start(&p
->dst_sg_it
, req
->dst
, num_sgs
, SG_MITER_TO_SG
);
511 mv_process_current_q(1);
514 static void mv_start_new_hash_req(struct ahash_request
*req
)
516 struct req_progress
*p
= &cpg
->p
;
517 struct mv_req_hash_ctx
*ctx
= ahash_request_ctx(req
);
518 const struct mv_tfm_hash_ctx
*tfm_ctx
= crypto_tfm_ctx(req
->base
.tfm
);
519 int num_sgs
, hw_bytes
, old_extra_bytes
, rc
;
520 cpg
->cur_req
= &req
->base
;
521 memset(p
, 0, sizeof(struct req_progress
));
522 hw_bytes
= req
->nbytes
+ ctx
->extra_bytes
;
523 old_extra_bytes
= ctx
->extra_bytes
;
525 if (unlikely(ctx
->extra_bytes
)) {
526 memcpy(cpg
->sram
+ SRAM_DATA_IN_START
, ctx
->buffer
,
528 p
->crypt_len
= ctx
->extra_bytes
;
531 memcpy(cpg
->sram
+ SRAM_HMAC_IV_IN
, tfm_ctx
->ivs
, sizeof(tfm_ctx
->ivs
));
533 if (unlikely(!ctx
->first_hash
)) {
534 writel(ctx
->state
[0], cpg
->reg
+ DIGEST_INITIAL_VAL_A
);
535 writel(ctx
->state
[1], cpg
->reg
+ DIGEST_INITIAL_VAL_B
);
536 writel(ctx
->state
[2], cpg
->reg
+ DIGEST_INITIAL_VAL_C
);
537 writel(ctx
->state
[3], cpg
->reg
+ DIGEST_INITIAL_VAL_D
);
538 writel(ctx
->state
[4], cpg
->reg
+ DIGEST_INITIAL_VAL_E
);
541 ctx
->extra_bytes
= hw_bytes
% SHA1_BLOCK_SIZE
;
542 if (ctx
->extra_bytes
!= 0
543 && (!ctx
->last_chunk
|| ctx
->count
> MAX_HW_HASH_SIZE
))
544 hw_bytes
-= ctx
->extra_bytes
;
546 ctx
->extra_bytes
= 0;
548 num_sgs
= count_sgs(req
->src
, req
->nbytes
);
549 sg_miter_start(&p
->src_sg_it
, req
->src
, num_sgs
, SG_MITER_FROM_SG
);
552 p
->hw_nbytes
= hw_bytes
;
553 p
->complete
= mv_hash_algo_completion
;
554 p
->process
= mv_process_hash_current
;
556 mv_process_hash_current(1);
558 copy_src_to_buf(p
, ctx
->buffer
+ old_extra_bytes
,
559 ctx
->extra_bytes
- old_extra_bytes
);
560 sg_miter_stop(&p
->src_sg_it
);
562 rc
= mv_hash_final_fallback(req
);
565 cpg
->eng_st
= ENGINE_IDLE
;
567 req
->base
.complete(&req
->base
, rc
);
572 static int queue_manag(void *data
)
574 cpg
->eng_st
= ENGINE_IDLE
;
576 struct crypto_async_request
*async_req
= NULL
;
577 struct crypto_async_request
*backlog
;
579 __set_current_state(TASK_INTERRUPTIBLE
);
581 if (cpg
->eng_st
== ENGINE_W_DEQUEUE
)
582 dequeue_complete_req();
584 spin_lock_irq(&cpg
->lock
);
585 if (cpg
->eng_st
== ENGINE_IDLE
) {
586 backlog
= crypto_get_backlog(&cpg
->queue
);
587 async_req
= crypto_dequeue_request(&cpg
->queue
);
589 BUG_ON(cpg
->eng_st
!= ENGINE_IDLE
);
590 cpg
->eng_st
= ENGINE_BUSY
;
593 spin_unlock_irq(&cpg
->lock
);
596 backlog
->complete(backlog
, -EINPROGRESS
);
601 if (async_req
->tfm
->__crt_alg
->cra_type
!=
602 &crypto_ahash_type
) {
603 struct ablkcipher_request
*req
=
604 ablkcipher_request_cast(async_req
);
605 mv_start_new_crypt_req(req
);
607 struct ahash_request
*req
=
608 ahash_request_cast(async_req
);
609 mv_start_new_hash_req(req
);
616 } while (!kthread_should_stop());
620 static int mv_handle_req(struct crypto_async_request
*req
)
625 spin_lock_irqsave(&cpg
->lock
, flags
);
626 ret
= crypto_enqueue_request(&cpg
->queue
, req
);
627 spin_unlock_irqrestore(&cpg
->lock
, flags
);
628 wake_up_process(cpg
->queue_th
);
632 static int mv_enc_aes_ecb(struct ablkcipher_request
*req
)
634 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
636 req_ctx
->op
= COP_AES_ECB
;
637 req_ctx
->decrypt
= 0;
639 return mv_handle_req(&req
->base
);
642 static int mv_dec_aes_ecb(struct ablkcipher_request
*req
)
644 struct mv_ctx
*ctx
= crypto_tfm_ctx(req
->base
.tfm
);
645 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
647 req_ctx
->op
= COP_AES_ECB
;
648 req_ctx
->decrypt
= 1;
650 compute_aes_dec_key(ctx
);
651 return mv_handle_req(&req
->base
);
654 static int mv_enc_aes_cbc(struct ablkcipher_request
*req
)
656 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
658 req_ctx
->op
= COP_AES_CBC
;
659 req_ctx
->decrypt
= 0;
661 return mv_handle_req(&req
->base
);
664 static int mv_dec_aes_cbc(struct ablkcipher_request
*req
)
666 struct mv_ctx
*ctx
= crypto_tfm_ctx(req
->base
.tfm
);
667 struct mv_req_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
669 req_ctx
->op
= COP_AES_CBC
;
670 req_ctx
->decrypt
= 1;
672 compute_aes_dec_key(ctx
);
673 return mv_handle_req(&req
->base
);
676 static int mv_cra_init(struct crypto_tfm
*tfm
)
678 tfm
->crt_ablkcipher
.reqsize
= sizeof(struct mv_req_ctx
);
682 static void mv_init_hash_req_ctx(struct mv_req_hash_ctx
*ctx
, int op
,
683 int is_last
, unsigned int req_len
,
686 memset(ctx
, 0, sizeof(*ctx
));
688 ctx
->count
= req_len
;
690 ctx
->last_chunk
= is_last
;
691 ctx
->count_add
= count_add
;
694 static void mv_update_hash_req_ctx(struct mv_req_hash_ctx
*ctx
, int is_last
,
697 ctx
->last_chunk
= is_last
;
698 ctx
->count
+= req_len
;
701 static int mv_hash_init(struct ahash_request
*req
)
703 const struct mv_tfm_hash_ctx
*tfm_ctx
= crypto_tfm_ctx(req
->base
.tfm
);
704 mv_init_hash_req_ctx(ahash_request_ctx(req
), tfm_ctx
->op
, 0, 0,
709 static int mv_hash_update(struct ahash_request
*req
)
714 mv_update_hash_req_ctx(ahash_request_ctx(req
), 0, req
->nbytes
);
715 return mv_handle_req(&req
->base
);
718 static int mv_hash_final(struct ahash_request
*req
)
720 struct mv_req_hash_ctx
*ctx
= ahash_request_ctx(req
);
721 /* dummy buffer of 4 bytes */
722 sg_init_one(&ctx
->dummysg
, ctx
->buffer
, 4);
723 /* I think I'm allowed to do that... */
724 ahash_request_set_crypt(req
, &ctx
->dummysg
, req
->result
, 0);
725 mv_update_hash_req_ctx(ctx
, 1, 0);
726 return mv_handle_req(&req
->base
);
729 static int mv_hash_finup(struct ahash_request
*req
)
731 mv_update_hash_req_ctx(ahash_request_ctx(req
), 1, req
->nbytes
);
732 return mv_handle_req(&req
->base
);
735 static int mv_hash_digest(struct ahash_request
*req
)
737 const struct mv_tfm_hash_ctx
*tfm_ctx
= crypto_tfm_ctx(req
->base
.tfm
);
738 mv_init_hash_req_ctx(ahash_request_ctx(req
), tfm_ctx
->op
, 1,
739 req
->nbytes
, tfm_ctx
->count_add
);
740 return mv_handle_req(&req
->base
);
743 static void mv_hash_init_ivs(struct mv_tfm_hash_ctx
*ctx
, const void *istate
,
746 const struct sha1_state
*isha1_state
= istate
, *osha1_state
= ostate
;
748 for (i
= 0; i
< 5; i
++) {
749 ctx
->ivs
[i
] = cpu_to_be32(isha1_state
->state
[i
]);
750 ctx
->ivs
[i
+ 5] = cpu_to_be32(osha1_state
->state
[i
]);
754 static int mv_hash_setkey(struct crypto_ahash
*tfm
, const u8
* key
,
758 struct mv_tfm_hash_ctx
*ctx
= crypto_tfm_ctx(&tfm
->base
);
764 rc
= crypto_shash_setkey(ctx
->fallback
, key
, keylen
);
768 /* Can't see a way to extract the ipad/opad from the fallback tfm
769 so I'm basically copying code from the hmac module */
770 bs
= crypto_shash_blocksize(ctx
->base_hash
);
771 ds
= crypto_shash_digestsize(ctx
->base_hash
);
772 ss
= crypto_shash_statesize(ctx
->base_hash
);
776 struct shash_desc shash
;
777 char ctx
[crypto_shash_descsize(ctx
->base_hash
)];
783 desc
.shash
.tfm
= ctx
->base_hash
;
784 desc
.shash
.flags
= crypto_shash_get_flags(ctx
->base_hash
) &
785 CRYPTO_TFM_REQ_MAY_SLEEP
;
791 crypto_shash_digest(&desc
.shash
, key
, keylen
, ipad
);
797 memcpy(ipad
, key
, keylen
);
799 memset(ipad
+ keylen
, 0, bs
- keylen
);
800 memcpy(opad
, ipad
, bs
);
802 for (i
= 0; i
< bs
; i
++) {
807 rc
= crypto_shash_init(&desc
.shash
) ? :
808 crypto_shash_update(&desc
.shash
, ipad
, bs
) ? :
809 crypto_shash_export(&desc
.shash
, ipad
) ? :
810 crypto_shash_init(&desc
.shash
) ? :
811 crypto_shash_update(&desc
.shash
, opad
, bs
) ? :
812 crypto_shash_export(&desc
.shash
, opad
);
815 mv_hash_init_ivs(ctx
, ipad
, opad
);
821 static int mv_cra_hash_init(struct crypto_tfm
*tfm
, const char *base_hash_name
,
822 enum hash_op op
, int count_add
)
824 const char *fallback_driver_name
= tfm
->__crt_alg
->cra_name
;
825 struct mv_tfm_hash_ctx
*ctx
= crypto_tfm_ctx(tfm
);
826 struct crypto_shash
*fallback_tfm
= NULL
;
827 struct crypto_shash
*base_hash
= NULL
;
831 ctx
->count_add
= count_add
;
833 /* Allocate a fallback and abort if it failed. */
834 fallback_tfm
= crypto_alloc_shash(fallback_driver_name
, 0,
835 CRYPTO_ALG_NEED_FALLBACK
);
836 if (IS_ERR(fallback_tfm
)) {
837 printk(KERN_WARNING MV_CESA
838 "Fallback driver '%s' could not be loaded!\n",
839 fallback_driver_name
);
840 err
= PTR_ERR(fallback_tfm
);
843 ctx
->fallback
= fallback_tfm
;
845 if (base_hash_name
) {
846 /* Allocate a hash to compute the ipad/opad of hmac. */
847 base_hash
= crypto_alloc_shash(base_hash_name
, 0,
848 CRYPTO_ALG_NEED_FALLBACK
);
849 if (IS_ERR(base_hash
)) {
850 printk(KERN_WARNING MV_CESA
851 "Base driver '%s' could not be loaded!\n",
853 err
= PTR_ERR(base_hash
);
857 ctx
->base_hash
= base_hash
;
859 crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm
),
860 sizeof(struct mv_req_hash_ctx
) +
861 crypto_shash_descsize(ctx
->fallback
));
864 crypto_free_shash(fallback_tfm
);
869 static void mv_cra_hash_exit(struct crypto_tfm
*tfm
)
871 struct mv_tfm_hash_ctx
*ctx
= crypto_tfm_ctx(tfm
);
873 crypto_free_shash(ctx
->fallback
);
875 crypto_free_shash(ctx
->base_hash
);
878 static int mv_cra_hash_sha1_init(struct crypto_tfm
*tfm
)
880 return mv_cra_hash_init(tfm
, NULL
, COP_SHA1
, 0);
883 static int mv_cra_hash_hmac_sha1_init(struct crypto_tfm
*tfm
)
885 return mv_cra_hash_init(tfm
, "sha1", COP_HMAC_SHA1
, SHA1_BLOCK_SIZE
);
888 irqreturn_t
crypto_int(int irq
, void *priv
)
892 val
= readl(cpg
->reg
+ SEC_ACCEL_INT_STATUS
);
893 if (!(val
& SEC_INT_ACCEL0_DONE
))
896 val
&= ~SEC_INT_ACCEL0_DONE
;
897 writel(val
, cpg
->reg
+ FPGA_INT_STATUS
);
898 writel(val
, cpg
->reg
+ SEC_ACCEL_INT_STATUS
);
899 BUG_ON(cpg
->eng_st
!= ENGINE_BUSY
);
900 cpg
->eng_st
= ENGINE_W_DEQUEUE
;
901 wake_up_process(cpg
->queue_th
);
905 struct crypto_alg mv_aes_alg_ecb
= {
906 .cra_name
= "ecb(aes)",
907 .cra_driver_name
= "mv-ecb-aes",
909 .cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
| CRYPTO_ALG_ASYNC
,
911 .cra_ctxsize
= sizeof(struct mv_ctx
),
913 .cra_type
= &crypto_ablkcipher_type
,
914 .cra_module
= THIS_MODULE
,
915 .cra_init
= mv_cra_init
,
918 .min_keysize
= AES_MIN_KEY_SIZE
,
919 .max_keysize
= AES_MAX_KEY_SIZE
,
920 .setkey
= mv_setkey_aes
,
921 .encrypt
= mv_enc_aes_ecb
,
922 .decrypt
= mv_dec_aes_ecb
,
927 struct crypto_alg mv_aes_alg_cbc
= {
928 .cra_name
= "cbc(aes)",
929 .cra_driver_name
= "mv-cbc-aes",
931 .cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
| CRYPTO_ALG_ASYNC
,
932 .cra_blocksize
= AES_BLOCK_SIZE
,
933 .cra_ctxsize
= sizeof(struct mv_ctx
),
935 .cra_type
= &crypto_ablkcipher_type
,
936 .cra_module
= THIS_MODULE
,
937 .cra_init
= mv_cra_init
,
940 .ivsize
= AES_BLOCK_SIZE
,
941 .min_keysize
= AES_MIN_KEY_SIZE
,
942 .max_keysize
= AES_MAX_KEY_SIZE
,
943 .setkey
= mv_setkey_aes
,
944 .encrypt
= mv_enc_aes_cbc
,
945 .decrypt
= mv_dec_aes_cbc
,
950 struct ahash_alg mv_sha1_alg
= {
951 .init
= mv_hash_init
,
952 .update
= mv_hash_update
,
953 .final
= mv_hash_final
,
954 .finup
= mv_hash_finup
,
955 .digest
= mv_hash_digest
,
957 .digestsize
= SHA1_DIGEST_SIZE
,
960 .cra_driver_name
= "mv-sha1",
963 CRYPTO_ALG_ASYNC
| CRYPTO_ALG_NEED_FALLBACK
,
964 .cra_blocksize
= SHA1_BLOCK_SIZE
,
965 .cra_ctxsize
= sizeof(struct mv_tfm_hash_ctx
),
966 .cra_init
= mv_cra_hash_sha1_init
,
967 .cra_exit
= mv_cra_hash_exit
,
968 .cra_module
= THIS_MODULE
,
973 struct ahash_alg mv_hmac_sha1_alg
= {
974 .init
= mv_hash_init
,
975 .update
= mv_hash_update
,
976 .final
= mv_hash_final
,
977 .finup
= mv_hash_finup
,
978 .digest
= mv_hash_digest
,
979 .setkey
= mv_hash_setkey
,
981 .digestsize
= SHA1_DIGEST_SIZE
,
983 .cra_name
= "hmac(sha1)",
984 .cra_driver_name
= "mv-hmac-sha1",
987 CRYPTO_ALG_ASYNC
| CRYPTO_ALG_NEED_FALLBACK
,
988 .cra_blocksize
= SHA1_BLOCK_SIZE
,
989 .cra_ctxsize
= sizeof(struct mv_tfm_hash_ctx
),
990 .cra_init
= mv_cra_hash_hmac_sha1_init
,
991 .cra_exit
= mv_cra_hash_exit
,
992 .cra_module
= THIS_MODULE
,
997 static int mv_probe(struct platform_device
*pdev
)
999 struct crypto_priv
*cp
;
1000 struct resource
*res
;
1005 printk(KERN_ERR MV_CESA
"Second crypto dev?\n");
1009 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "regs");
1013 cp
= kzalloc(sizeof(*cp
), GFP_KERNEL
);
1017 spin_lock_init(&cp
->lock
);
1018 crypto_init_queue(&cp
->queue
, 50);
1019 cp
->reg
= ioremap(res
->start
, resource_size(res
));
1025 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "sram");
1030 cp
->sram_size
= resource_size(res
);
1031 cp
->max_req_size
= cp
->sram_size
- SRAM_CFG_SPACE
;
1032 cp
->sram
= ioremap(res
->start
, cp
->sram_size
);
1038 irq
= platform_get_irq(pdev
, 0);
1039 if (irq
< 0 || irq
== NO_IRQ
) {
1041 goto err_unmap_sram
;
1045 platform_set_drvdata(pdev
, cp
);
1048 cp
->queue_th
= kthread_run(queue_manag
, cp
, "mv_crypto");
1049 if (IS_ERR(cp
->queue_th
)) {
1050 ret
= PTR_ERR(cp
->queue_th
);
1051 goto err_unmap_sram
;
1054 ret
= request_irq(irq
, crypto_int
, IRQF_DISABLED
, dev_name(&pdev
->dev
),
1059 writel(SEC_INT_ACCEL0_DONE
, cpg
->reg
+ SEC_ACCEL_INT_MASK
);
1060 writel(SEC_CFG_STOP_DIG_ERR
, cpg
->reg
+ SEC_ACCEL_CFG
);
1061 writel(SRAM_CONFIG
, cpg
->reg
+ SEC_ACCEL_DESC_P0
);
1063 ret
= crypto_register_alg(&mv_aes_alg_ecb
);
1065 printk(KERN_WARNING MV_CESA
1066 "Could not register aes-ecb driver\n");
1070 ret
= crypto_register_alg(&mv_aes_alg_cbc
);
1072 printk(KERN_WARNING MV_CESA
1073 "Could not register aes-cbc driver\n");
1077 ret
= crypto_register_ahash(&mv_sha1_alg
);
1081 printk(KERN_WARNING MV_CESA
"Could not register sha1 driver\n");
1083 ret
= crypto_register_ahash(&mv_hmac_sha1_alg
);
1085 cpg
->has_hmac_sha1
= 1;
1087 printk(KERN_WARNING MV_CESA
1088 "Could not register hmac-sha1 driver\n");
1093 crypto_unregister_alg(&mv_aes_alg_ecb
);
1097 kthread_stop(cp
->queue_th
);
1105 platform_set_drvdata(pdev
, NULL
);
1109 static int mv_remove(struct platform_device
*pdev
)
1111 struct crypto_priv
*cp
= platform_get_drvdata(pdev
);
1113 crypto_unregister_alg(&mv_aes_alg_ecb
);
1114 crypto_unregister_alg(&mv_aes_alg_cbc
);
1116 crypto_unregister_ahash(&mv_sha1_alg
);
1117 if (cp
->has_hmac_sha1
)
1118 crypto_unregister_ahash(&mv_hmac_sha1_alg
);
1119 kthread_stop(cp
->queue_th
);
1120 free_irq(cp
->irq
, cp
);
1121 memset(cp
->sram
, 0, cp
->sram_size
);
1129 static struct platform_driver marvell_crypto
= {
1131 .remove
= mv_remove
,
1133 .owner
= THIS_MODULE
,
1134 .name
= "mv_crypto",
1137 MODULE_ALIAS("platform:mv_crypto");
1139 static int __init
mv_crypto_init(void)
1141 return platform_driver_register(&marvell_crypto
);
1143 module_init(mv_crypto_init
);
1145 static void __exit
mv_crypto_exit(void)
1147 platform_driver_unregister(&marvell_crypto
);
1149 module_exit(mv_crypto_exit
);
1151 MODULE_AUTHOR("Sebastian Andrzej Siewior <sebastian@breakpoint.cc>");
1152 MODULE_DESCRIPTION("Support for Marvell's cryptographic engine");
1153 MODULE_LICENSE("GPL");