2 * Intel IXP4xx NPE-C crypto driver
4 * Copyright (C) 2008 Christian Hohnstaedt <chohnstaedt@innominate.com>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of version 2 of the GNU General Public License
8 * as published by the Free Software Foundation.
12 #include <linux/platform_device.h>
13 #include <linux/dma-mapping.h>
14 #include <linux/dmapool.h>
15 #include <linux/crypto.h>
16 #include <linux/kernel.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/interrupt.h>
19 #include <linux/spinlock.h>
20 #include <linux/gfp.h>
21 #include <linux/module.h>
23 #include <crypto/ctr.h>
24 #include <crypto/des.h>
25 #include <crypto/aes.h>
26 #include <crypto/sha.h>
27 #include <crypto/algapi.h>
28 #include <crypto/internal/aead.h>
29 #include <crypto/authenc.h>
30 #include <crypto/scatterwalk.h>
33 #include <mach/qmgr.h>
37 /* hash: cfgword + 2 * digestlen; crypt: keylen + cfgword */
38 #define NPE_CTX_LEN 80
39 #define AES_BLOCK128 16
41 #define NPE_OP_HASH_VERIFY 0x01
42 #define NPE_OP_CCM_ENABLE 0x04
43 #define NPE_OP_CRYPT_ENABLE 0x08
44 #define NPE_OP_HASH_ENABLE 0x10
45 #define NPE_OP_NOT_IN_PLACE 0x20
46 #define NPE_OP_HMAC_DISABLE 0x40
47 #define NPE_OP_CRYPT_ENCRYPT 0x80
49 #define NPE_OP_CCM_GEN_MIC 0xcc
50 #define NPE_OP_HASH_GEN_ICV 0x50
51 #define NPE_OP_ENC_GEN_KEY 0xc9
53 #define MOD_ECB 0x0000
54 #define MOD_CTR 0x1000
55 #define MOD_CBC_ENC 0x2000
56 #define MOD_CBC_DEC 0x3000
57 #define MOD_CCM_ENC 0x4000
58 #define MOD_CCM_DEC 0x5000
64 #define CIPH_DECR 0x0000
65 #define CIPH_ENCR 0x0400
67 #define MOD_DES 0x0000
68 #define MOD_TDEA2 0x0100
69 #define MOD_3DES 0x0200
70 #define MOD_AES 0x0800
71 #define MOD_AES128 (0x0800 | KEYLEN_128)
72 #define MOD_AES192 (0x0900 | KEYLEN_192)
73 #define MOD_AES256 (0x0a00 | KEYLEN_256)
76 #define NPE_ID 2 /* NPE C */
78 /* Space for registering when the first
79 * NPE_QLEN crypt_ctl are busy */
80 #define NPE_QLEN_TOTAL 64
85 #define CTL_FLAG_UNUSED 0x0000
86 #define CTL_FLAG_USED 0x1000
87 #define CTL_FLAG_PERFORM_ABLK 0x0001
88 #define CTL_FLAG_GEN_ICV 0x0002
89 #define CTL_FLAG_GEN_REVAES 0x0004
90 #define CTL_FLAG_PERFORM_AEAD 0x0008
91 #define CTL_FLAG_MASK 0x000f
93 #define HMAC_IPAD_VALUE 0x36
94 #define HMAC_OPAD_VALUE 0x5C
95 #define HMAC_PAD_BLOCKLEN SHA1_BLOCK_SIZE
97 #define MD5_DIGEST_SIZE 16
110 struct buffer_desc
*next
;
111 enum dma_data_direction dir
;
116 u8 mode
; /* NPE_OP_* operation mode */
122 u8 mode
; /* NPE_OP_* operation mode */
124 u8 iv
[MAX_IVLEN
]; /* IV for CBC mode or CTR IV for CTR mode */
125 u32 icv_rev_aes
; /* icv or rev aes */
129 u16 auth_offs
; /* Authentication start offset */
130 u16 auth_len
; /* Authentication data length */
131 u16 crypt_offs
; /* Cryption start offset */
132 u16 crypt_len
; /* Cryption data length */
134 u16 auth_len
; /* Authentication data length */
135 u16 auth_offs
; /* Authentication start offset */
136 u16 crypt_len
; /* Cryption data length */
137 u16 crypt_offs
; /* Cryption start offset */
139 u32 aadAddr
; /* Additional Auth Data Addr for CCM mode */
140 u32 crypto_ctx
; /* NPE Crypto Param structure address */
142 /* Used by Host: 4*4 bytes*/
145 struct ablkcipher_request
*ablk_req
;
146 struct aead_request
*aead_req
;
147 struct crypto_tfm
*tfm
;
149 struct buffer_desc
*regist_buf
;
154 struct buffer_desc
*src
;
155 struct buffer_desc
*dst
;
159 struct buffer_desc
*src
;
160 struct buffer_desc
*dst
;
161 struct scatterlist ivlist
;
162 /* used when the hmac is not on one sg entry */
167 struct ix_hash_algo
{
173 unsigned char *npe_ctx
;
174 dma_addr_t npe_ctx_phys
;
180 struct ix_sa_dir encrypt
;
181 struct ix_sa_dir decrypt
;
183 u8 authkey
[MAX_KEYLEN
];
185 u8 enckey
[MAX_KEYLEN
];
187 u8 nonce
[CTR_RFC3686_NONCE_SIZE
];
189 atomic_t configuring
;
190 struct completion completion
;
194 struct crypto_alg crypto
;
195 const struct ix_hash_algo
*hash
;
202 struct ixp_aead_alg
{
203 struct aead_alg crypto
;
204 const struct ix_hash_algo
*hash
;
211 static const struct ix_hash_algo hash_alg_md5
= {
212 .cfgword
= 0xAA010004,
213 .icv
= "\x01\x23\x45\x67\x89\xAB\xCD\xEF"
214 "\xFE\xDC\xBA\x98\x76\x54\x32\x10",
216 static const struct ix_hash_algo hash_alg_sha1
= {
217 .cfgword
= 0x00000005,
218 .icv
= "\x67\x45\x23\x01\xEF\xCD\xAB\x89\x98\xBA"
219 "\xDC\xFE\x10\x32\x54\x76\xC3\xD2\xE1\xF0",
222 static struct npe
*npe_c
;
223 static struct dma_pool
*buffer_pool
= NULL
;
224 static struct dma_pool
*ctx_pool
= NULL
;
226 static struct crypt_ctl
*crypt_virt
= NULL
;
227 static dma_addr_t crypt_phys
;
229 static int support_aes
= 1;
231 #define DRIVER_NAME "ixp4xx_crypto"
233 static struct platform_device
*pdev
;
235 static inline dma_addr_t
crypt_virt2phys(struct crypt_ctl
*virt
)
237 return crypt_phys
+ (virt
- crypt_virt
) * sizeof(struct crypt_ctl
);
240 static inline struct crypt_ctl
*crypt_phys2virt(dma_addr_t phys
)
242 return crypt_virt
+ (phys
- crypt_phys
) / sizeof(struct crypt_ctl
);
245 static inline u32
cipher_cfg_enc(struct crypto_tfm
*tfm
)
247 return container_of(tfm
->__crt_alg
, struct ixp_alg
,crypto
)->cfg_enc
;
250 static inline u32
cipher_cfg_dec(struct crypto_tfm
*tfm
)
252 return container_of(tfm
->__crt_alg
, struct ixp_alg
,crypto
)->cfg_dec
;
255 static inline const struct ix_hash_algo
*ix_hash(struct crypto_tfm
*tfm
)
257 return container_of(tfm
->__crt_alg
, struct ixp_alg
, crypto
)->hash
;
260 static int setup_crypt_desc(void)
262 struct device
*dev
= &pdev
->dev
;
263 BUILD_BUG_ON(sizeof(struct crypt_ctl
) != 64);
264 crypt_virt
= dma_alloc_coherent(dev
,
265 NPE_QLEN
* sizeof(struct crypt_ctl
),
266 &crypt_phys
, GFP_ATOMIC
);
269 memset(crypt_virt
, 0, NPE_QLEN
* sizeof(struct crypt_ctl
));
273 static spinlock_t desc_lock
;
274 static struct crypt_ctl
*get_crypt_desc(void)
280 spin_lock_irqsave(&desc_lock
, flags
);
282 if (unlikely(!crypt_virt
))
284 if (unlikely(!crypt_virt
)) {
285 spin_unlock_irqrestore(&desc_lock
, flags
);
289 if (crypt_virt
[i
].ctl_flags
== CTL_FLAG_UNUSED
) {
290 if (++idx
>= NPE_QLEN
)
292 crypt_virt
[i
].ctl_flags
= CTL_FLAG_USED
;
293 spin_unlock_irqrestore(&desc_lock
, flags
);
294 return crypt_virt
+i
;
296 spin_unlock_irqrestore(&desc_lock
, flags
);
301 static spinlock_t emerg_lock
;
302 static struct crypt_ctl
*get_crypt_desc_emerg(void)
305 static int idx
= NPE_QLEN
;
306 struct crypt_ctl
*desc
;
309 desc
= get_crypt_desc();
312 if (unlikely(!crypt_virt
))
315 spin_lock_irqsave(&emerg_lock
, flags
);
317 if (crypt_virt
[i
].ctl_flags
== CTL_FLAG_UNUSED
) {
318 if (++idx
>= NPE_QLEN_TOTAL
)
320 crypt_virt
[i
].ctl_flags
= CTL_FLAG_USED
;
321 spin_unlock_irqrestore(&emerg_lock
, flags
);
322 return crypt_virt
+i
;
324 spin_unlock_irqrestore(&emerg_lock
, flags
);
329 static void free_buf_chain(struct device
*dev
, struct buffer_desc
*buf
,u32 phys
)
332 struct buffer_desc
*buf1
;
336 phys1
= buf
->phys_next
;
337 dma_unmap_single(dev
, buf
->phys_next
, buf
->buf_len
, buf
->dir
);
338 dma_pool_free(buffer_pool
, buf
, phys
);
344 static struct tasklet_struct crypto_done_tasklet
;
346 static void finish_scattered_hmac(struct crypt_ctl
*crypt
)
348 struct aead_request
*req
= crypt
->data
.aead_req
;
349 struct aead_ctx
*req_ctx
= aead_request_ctx(req
);
350 struct crypto_aead
*tfm
= crypto_aead_reqtfm(req
);
351 int authsize
= crypto_aead_authsize(tfm
);
352 int decryptlen
= req
->assoclen
+ req
->cryptlen
- authsize
;
354 if (req_ctx
->encrypt
) {
355 scatterwalk_map_and_copy(req_ctx
->hmac_virt
,
356 req
->dst
, decryptlen
, authsize
, 1);
358 dma_pool_free(buffer_pool
, req_ctx
->hmac_virt
, crypt
->icv_rev_aes
);
361 static void one_packet(dma_addr_t phys
)
363 struct device
*dev
= &pdev
->dev
;
364 struct crypt_ctl
*crypt
;
368 failed
= phys
& 0x1 ? -EBADMSG
: 0;
370 crypt
= crypt_phys2virt(phys
);
372 switch (crypt
->ctl_flags
& CTL_FLAG_MASK
) {
373 case CTL_FLAG_PERFORM_AEAD
: {
374 struct aead_request
*req
= crypt
->data
.aead_req
;
375 struct aead_ctx
*req_ctx
= aead_request_ctx(req
);
377 free_buf_chain(dev
, req_ctx
->src
, crypt
->src_buf
);
378 free_buf_chain(dev
, req_ctx
->dst
, crypt
->dst_buf
);
379 if (req_ctx
->hmac_virt
) {
380 finish_scattered_hmac(crypt
);
382 req
->base
.complete(&req
->base
, failed
);
385 case CTL_FLAG_PERFORM_ABLK
: {
386 struct ablkcipher_request
*req
= crypt
->data
.ablk_req
;
387 struct ablk_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
390 free_buf_chain(dev
, req_ctx
->dst
, crypt
->dst_buf
);
392 free_buf_chain(dev
, req_ctx
->src
, crypt
->src_buf
);
393 req
->base
.complete(&req
->base
, failed
);
396 case CTL_FLAG_GEN_ICV
:
397 ctx
= crypto_tfm_ctx(crypt
->data
.tfm
);
398 dma_pool_free(ctx_pool
, crypt
->regist_ptr
,
399 crypt
->regist_buf
->phys_addr
);
400 dma_pool_free(buffer_pool
, crypt
->regist_buf
, crypt
->src_buf
);
401 if (atomic_dec_and_test(&ctx
->configuring
))
402 complete(&ctx
->completion
);
404 case CTL_FLAG_GEN_REVAES
:
405 ctx
= crypto_tfm_ctx(crypt
->data
.tfm
);
406 *(u32
*)ctx
->decrypt
.npe_ctx
&= cpu_to_be32(~CIPH_ENCR
);
407 if (atomic_dec_and_test(&ctx
->configuring
))
408 complete(&ctx
->completion
);
413 crypt
->ctl_flags
= CTL_FLAG_UNUSED
;
416 static void irqhandler(void *_unused
)
418 tasklet_schedule(&crypto_done_tasklet
);
421 static void crypto_done_action(unsigned long arg
)
426 dma_addr_t phys
= qmgr_get_entry(RECV_QID
);
431 tasklet_schedule(&crypto_done_tasklet
);
434 static int init_ixp_crypto(struct device
*dev
)
437 u32 msg
[2] = { 0, 0 };
439 if (! ( ~(*IXP4XX_EXP_CFG2
) & (IXP4XX_FEATURE_HASH
|
440 IXP4XX_FEATURE_AES
| IXP4XX_FEATURE_DES
))) {
441 printk(KERN_ERR
"ixp_crypto: No HW crypto available\n");
444 npe_c
= npe_request(NPE_ID
);
448 if (!npe_running(npe_c
)) {
449 ret
= npe_load_firmware(npe_c
, npe_name(npe_c
), dev
);
453 if (npe_recv_message(npe_c
, msg
, "STATUS_MSG"))
456 if (npe_send_message(npe_c
, msg
, "STATUS_MSG"))
459 if (npe_recv_message(npe_c
, msg
, "STATUS_MSG"))
463 switch ((msg
[1]>>16) & 0xff) {
465 printk(KERN_WARNING
"Firmware of %s lacks AES support\n",
474 printk(KERN_ERR
"Firmware of %s lacks crypto support\n",
478 /* buffer_pool will also be used to sometimes store the hmac,
479 * so assure it is large enough
481 BUILD_BUG_ON(SHA1_DIGEST_SIZE
> sizeof(struct buffer_desc
));
482 buffer_pool
= dma_pool_create("buffer", dev
,
483 sizeof(struct buffer_desc
), 32, 0);
488 ctx_pool
= dma_pool_create("context", dev
,
493 ret
= qmgr_request_queue(SEND_QID
, NPE_QLEN_TOTAL
, 0, 0,
494 "ixp_crypto:out", NULL
);
497 ret
= qmgr_request_queue(RECV_QID
, NPE_QLEN
, 0, 0,
498 "ixp_crypto:in", NULL
);
500 qmgr_release_queue(SEND_QID
);
503 qmgr_set_irq(RECV_QID
, QUEUE_IRQ_SRC_NOT_EMPTY
, irqhandler
, NULL
);
504 tasklet_init(&crypto_done_tasklet
, crypto_done_action
, 0);
506 qmgr_enable_irq(RECV_QID
);
510 printk(KERN_ERR
"%s not responding\n", npe_name(npe_c
));
513 dma_pool_destroy(ctx_pool
);
514 dma_pool_destroy(buffer_pool
);
519 static void release_ixp_crypto(struct device
*dev
)
521 qmgr_disable_irq(RECV_QID
);
522 tasklet_kill(&crypto_done_tasklet
);
524 qmgr_release_queue(SEND_QID
);
525 qmgr_release_queue(RECV_QID
);
527 dma_pool_destroy(ctx_pool
);
528 dma_pool_destroy(buffer_pool
);
533 dma_free_coherent(dev
,
534 NPE_QLEN_TOTAL
* sizeof( struct crypt_ctl
),
535 crypt_virt
, crypt_phys
);
540 static void reset_sa_dir(struct ix_sa_dir
*dir
)
542 memset(dir
->npe_ctx
, 0, NPE_CTX_LEN
);
543 dir
->npe_ctx_idx
= 0;
547 static int init_sa_dir(struct ix_sa_dir
*dir
)
549 dir
->npe_ctx
= dma_pool_alloc(ctx_pool
, GFP_KERNEL
, &dir
->npe_ctx_phys
);
557 static void free_sa_dir(struct ix_sa_dir
*dir
)
559 memset(dir
->npe_ctx
, 0, NPE_CTX_LEN
);
560 dma_pool_free(ctx_pool
, dir
->npe_ctx
, dir
->npe_ctx_phys
);
563 static int init_tfm(struct crypto_tfm
*tfm
)
565 struct ixp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
568 atomic_set(&ctx
->configuring
, 0);
569 ret
= init_sa_dir(&ctx
->encrypt
);
572 ret
= init_sa_dir(&ctx
->decrypt
);
574 free_sa_dir(&ctx
->encrypt
);
579 static int init_tfm_ablk(struct crypto_tfm
*tfm
)
581 tfm
->crt_ablkcipher
.reqsize
= sizeof(struct ablk_ctx
);
582 return init_tfm(tfm
);
585 static int init_tfm_aead(struct crypto_aead
*tfm
)
587 crypto_aead_set_reqsize(tfm
, sizeof(struct aead_ctx
));
588 return init_tfm(crypto_aead_tfm(tfm
));
591 static void exit_tfm(struct crypto_tfm
*tfm
)
593 struct ixp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
594 free_sa_dir(&ctx
->encrypt
);
595 free_sa_dir(&ctx
->decrypt
);
598 static void exit_tfm_aead(struct crypto_aead
*tfm
)
600 exit_tfm(crypto_aead_tfm(tfm
));
603 static int register_chain_var(struct crypto_tfm
*tfm
, u8 xpad
, u32 target
,
604 int init_len
, u32 ctx_addr
, const u8
*key
, int key_len
)
606 struct ixp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
607 struct crypt_ctl
*crypt
;
608 struct buffer_desc
*buf
;
611 u32 pad_phys
, buf_phys
;
613 BUILD_BUG_ON(NPE_CTX_LEN
< HMAC_PAD_BLOCKLEN
);
614 pad
= dma_pool_alloc(ctx_pool
, GFP_KERNEL
, &pad_phys
);
617 buf
= dma_pool_alloc(buffer_pool
, GFP_KERNEL
, &buf_phys
);
619 dma_pool_free(ctx_pool
, pad
, pad_phys
);
622 crypt
= get_crypt_desc_emerg();
624 dma_pool_free(ctx_pool
, pad
, pad_phys
);
625 dma_pool_free(buffer_pool
, buf
, buf_phys
);
629 memcpy(pad
, key
, key_len
);
630 memset(pad
+ key_len
, 0, HMAC_PAD_BLOCKLEN
- key_len
);
631 for (i
= 0; i
< HMAC_PAD_BLOCKLEN
; i
++) {
635 crypt
->data
.tfm
= tfm
;
636 crypt
->regist_ptr
= pad
;
637 crypt
->regist_buf
= buf
;
639 crypt
->auth_offs
= 0;
640 crypt
->auth_len
= HMAC_PAD_BLOCKLEN
;
641 crypt
->crypto_ctx
= ctx_addr
;
642 crypt
->src_buf
= buf_phys
;
643 crypt
->icv_rev_aes
= target
;
644 crypt
->mode
= NPE_OP_HASH_GEN_ICV
;
645 crypt
->init_len
= init_len
;
646 crypt
->ctl_flags
|= CTL_FLAG_GEN_ICV
;
649 buf
->buf_len
= HMAC_PAD_BLOCKLEN
;
651 buf
->phys_addr
= pad_phys
;
653 atomic_inc(&ctx
->configuring
);
654 qmgr_put_entry(SEND_QID
, crypt_virt2phys(crypt
));
655 BUG_ON(qmgr_stat_overflow(SEND_QID
));
659 static int setup_auth(struct crypto_tfm
*tfm
, int encrypt
, unsigned authsize
,
660 const u8
*key
, int key_len
, unsigned digest_len
)
662 u32 itarget
, otarget
, npe_ctx_addr
;
663 unsigned char *cinfo
;
664 int init_len
, ret
= 0;
666 struct ix_sa_dir
*dir
;
667 struct ixp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
668 const struct ix_hash_algo
*algo
;
670 dir
= encrypt
? &ctx
->encrypt
: &ctx
->decrypt
;
671 cinfo
= dir
->npe_ctx
+ dir
->npe_ctx_idx
;
674 /* write cfg word to cryptinfo */
675 cfgword
= algo
->cfgword
| ( authsize
<< 6); /* (authsize/4) << 8 */
677 cfgword
^= 0xAA000000; /* change the "byte swap" flags */
679 *(u32
*)cinfo
= cpu_to_be32(cfgword
);
680 cinfo
+= sizeof(cfgword
);
682 /* write ICV to cryptinfo */
683 memcpy(cinfo
, algo
->icv
, digest_len
);
686 itarget
= dir
->npe_ctx_phys
+ dir
->npe_ctx_idx
687 + sizeof(algo
->cfgword
);
688 otarget
= itarget
+ digest_len
;
689 init_len
= cinfo
- (dir
->npe_ctx
+ dir
->npe_ctx_idx
);
690 npe_ctx_addr
= dir
->npe_ctx_phys
+ dir
->npe_ctx_idx
;
692 dir
->npe_ctx_idx
+= init_len
;
693 dir
->npe_mode
|= NPE_OP_HASH_ENABLE
;
696 dir
->npe_mode
|= NPE_OP_HASH_VERIFY
;
698 ret
= register_chain_var(tfm
, HMAC_OPAD_VALUE
, otarget
,
699 init_len
, npe_ctx_addr
, key
, key_len
);
702 return register_chain_var(tfm
, HMAC_IPAD_VALUE
, itarget
,
703 init_len
, npe_ctx_addr
, key
, key_len
);
706 static int gen_rev_aes_key(struct crypto_tfm
*tfm
)
708 struct crypt_ctl
*crypt
;
709 struct ixp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
710 struct ix_sa_dir
*dir
= &ctx
->decrypt
;
712 crypt
= get_crypt_desc_emerg();
716 *(u32
*)dir
->npe_ctx
|= cpu_to_be32(CIPH_ENCR
);
718 crypt
->data
.tfm
= tfm
;
719 crypt
->crypt_offs
= 0;
720 crypt
->crypt_len
= AES_BLOCK128
;
722 crypt
->crypto_ctx
= dir
->npe_ctx_phys
;
723 crypt
->icv_rev_aes
= dir
->npe_ctx_phys
+ sizeof(u32
);
724 crypt
->mode
= NPE_OP_ENC_GEN_KEY
;
725 crypt
->init_len
= dir
->npe_ctx_idx
;
726 crypt
->ctl_flags
|= CTL_FLAG_GEN_REVAES
;
728 atomic_inc(&ctx
->configuring
);
729 qmgr_put_entry(SEND_QID
, crypt_virt2phys(crypt
));
730 BUG_ON(qmgr_stat_overflow(SEND_QID
));
734 static int setup_cipher(struct crypto_tfm
*tfm
, int encrypt
,
735 const u8
*key
, int key_len
)
740 struct ix_sa_dir
*dir
;
741 struct ixp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
742 u32
*flags
= &tfm
->crt_flags
;
744 dir
= encrypt
? &ctx
->encrypt
: &ctx
->decrypt
;
745 cinfo
= dir
->npe_ctx
;
748 cipher_cfg
= cipher_cfg_enc(tfm
);
749 dir
->npe_mode
|= NPE_OP_CRYPT_ENCRYPT
;
751 cipher_cfg
= cipher_cfg_dec(tfm
);
753 if (cipher_cfg
& MOD_AES
) {
755 case 16: keylen_cfg
= MOD_AES128
; break;
756 case 24: keylen_cfg
= MOD_AES192
; break;
757 case 32: keylen_cfg
= MOD_AES256
; break;
759 *flags
|= CRYPTO_TFM_RES_BAD_KEY_LEN
;
762 cipher_cfg
|= keylen_cfg
;
763 } else if (cipher_cfg
& MOD_3DES
) {
764 const u32
*K
= (const u32
*)key
;
765 if (unlikely(!((K
[0] ^ K
[2]) | (K
[1] ^ K
[3])) ||
766 !((K
[2] ^ K
[4]) | (K
[3] ^ K
[5]))))
768 *flags
|= CRYPTO_TFM_RES_BAD_KEY_SCHED
;
772 u32 tmp
[DES_EXPKEY_WORDS
];
773 if (des_ekey(tmp
, key
) == 0) {
774 *flags
|= CRYPTO_TFM_RES_WEAK_KEY
;
777 /* write cfg word to cryptinfo */
778 *(u32
*)cinfo
= cpu_to_be32(cipher_cfg
);
779 cinfo
+= sizeof(cipher_cfg
);
781 /* write cipher key to cryptinfo */
782 memcpy(cinfo
, key
, key_len
);
783 /* NPE wants keylen set to DES3_EDE_KEY_SIZE even for single DES */
784 if (key_len
< DES3_EDE_KEY_SIZE
&& !(cipher_cfg
& MOD_AES
)) {
785 memset(cinfo
+ key_len
, 0, DES3_EDE_KEY_SIZE
-key_len
);
786 key_len
= DES3_EDE_KEY_SIZE
;
788 dir
->npe_ctx_idx
= sizeof(cipher_cfg
) + key_len
;
789 dir
->npe_mode
|= NPE_OP_CRYPT_ENABLE
;
790 if ((cipher_cfg
& MOD_AES
) && !encrypt
) {
791 return gen_rev_aes_key(tfm
);
796 static struct buffer_desc
*chainup_buffers(struct device
*dev
,
797 struct scatterlist
*sg
, unsigned nbytes
,
798 struct buffer_desc
*buf
, gfp_t flags
,
799 enum dma_data_direction dir
)
801 for (; nbytes
> 0; sg
= sg_next(sg
)) {
802 unsigned len
= min(nbytes
, sg
->length
);
803 struct buffer_desc
*next_buf
;
808 ptr
= page_address(sg_page(sg
)) + sg
->offset
;
809 next_buf
= dma_pool_alloc(buffer_pool
, flags
, &next_buf_phys
);
814 sg_dma_address(sg
) = dma_map_single(dev
, ptr
, len
, dir
);
815 buf
->next
= next_buf
;
816 buf
->phys_next
= next_buf_phys
;
819 buf
->phys_addr
= sg_dma_address(sg
);
828 static int ablk_setkey(struct crypto_ablkcipher
*tfm
, const u8
*key
,
829 unsigned int key_len
)
831 struct ixp_ctx
*ctx
= crypto_ablkcipher_ctx(tfm
);
832 u32
*flags
= &tfm
->base
.crt_flags
;
835 init_completion(&ctx
->completion
);
836 atomic_inc(&ctx
->configuring
);
838 reset_sa_dir(&ctx
->encrypt
);
839 reset_sa_dir(&ctx
->decrypt
);
841 ctx
->encrypt
.npe_mode
= NPE_OP_HMAC_DISABLE
;
842 ctx
->decrypt
.npe_mode
= NPE_OP_HMAC_DISABLE
;
844 ret
= setup_cipher(&tfm
->base
, 0, key
, key_len
);
847 ret
= setup_cipher(&tfm
->base
, 1, key
, key_len
);
851 if (*flags
& CRYPTO_TFM_RES_WEAK_KEY
) {
852 if (*flags
& CRYPTO_TFM_REQ_WEAK_KEY
) {
855 *flags
&= ~CRYPTO_TFM_RES_WEAK_KEY
;
859 if (!atomic_dec_and_test(&ctx
->configuring
))
860 wait_for_completion(&ctx
->completion
);
864 static int ablk_rfc3686_setkey(struct crypto_ablkcipher
*tfm
, const u8
*key
,
865 unsigned int key_len
)
867 struct ixp_ctx
*ctx
= crypto_ablkcipher_ctx(tfm
);
869 /* the nonce is stored in bytes at end of key */
870 if (key_len
< CTR_RFC3686_NONCE_SIZE
)
873 memcpy(ctx
->nonce
, key
+ (key_len
- CTR_RFC3686_NONCE_SIZE
),
874 CTR_RFC3686_NONCE_SIZE
);
876 key_len
-= CTR_RFC3686_NONCE_SIZE
;
877 return ablk_setkey(tfm
, key
, key_len
);
880 static int ablk_perform(struct ablkcipher_request
*req
, int encrypt
)
882 struct crypto_ablkcipher
*tfm
= crypto_ablkcipher_reqtfm(req
);
883 struct ixp_ctx
*ctx
= crypto_ablkcipher_ctx(tfm
);
884 unsigned ivsize
= crypto_ablkcipher_ivsize(tfm
);
885 struct ix_sa_dir
*dir
;
886 struct crypt_ctl
*crypt
;
887 unsigned int nbytes
= req
->nbytes
;
888 enum dma_data_direction src_direction
= DMA_BIDIRECTIONAL
;
889 struct ablk_ctx
*req_ctx
= ablkcipher_request_ctx(req
);
890 struct buffer_desc src_hook
;
891 struct device
*dev
= &pdev
->dev
;
892 gfp_t flags
= req
->base
.flags
& CRYPTO_TFM_REQ_MAY_SLEEP
?
893 GFP_KERNEL
: GFP_ATOMIC
;
895 if (qmgr_stat_full(SEND_QID
))
897 if (atomic_read(&ctx
->configuring
))
900 dir
= encrypt
? &ctx
->encrypt
: &ctx
->decrypt
;
902 crypt
= get_crypt_desc();
906 crypt
->data
.ablk_req
= req
;
907 crypt
->crypto_ctx
= dir
->npe_ctx_phys
;
908 crypt
->mode
= dir
->npe_mode
;
909 crypt
->init_len
= dir
->npe_ctx_idx
;
911 crypt
->crypt_offs
= 0;
912 crypt
->crypt_len
= nbytes
;
914 BUG_ON(ivsize
&& !req
->info
);
915 memcpy(crypt
->iv
, req
->info
, ivsize
);
916 if (req
->src
!= req
->dst
) {
917 struct buffer_desc dst_hook
;
918 crypt
->mode
|= NPE_OP_NOT_IN_PLACE
;
919 /* This was never tested by Intel
920 * for more than one dst buffer, I think. */
922 if (!chainup_buffers(dev
, req
->dst
, nbytes
, &dst_hook
,
923 flags
, DMA_FROM_DEVICE
))
925 src_direction
= DMA_TO_DEVICE
;
926 req_ctx
->dst
= dst_hook
.next
;
927 crypt
->dst_buf
= dst_hook
.phys_next
;
932 if (!chainup_buffers(dev
, req
->src
, nbytes
, &src_hook
,
933 flags
, src_direction
))
936 req_ctx
->src
= src_hook
.next
;
937 crypt
->src_buf
= src_hook
.phys_next
;
938 crypt
->ctl_flags
|= CTL_FLAG_PERFORM_ABLK
;
939 qmgr_put_entry(SEND_QID
, crypt_virt2phys(crypt
));
940 BUG_ON(qmgr_stat_overflow(SEND_QID
));
944 free_buf_chain(dev
, req_ctx
->src
, crypt
->src_buf
);
946 if (req
->src
!= req
->dst
) {
947 free_buf_chain(dev
, req_ctx
->dst
, crypt
->dst_buf
);
949 crypt
->ctl_flags
= CTL_FLAG_UNUSED
;
953 static int ablk_encrypt(struct ablkcipher_request
*req
)
955 return ablk_perform(req
, 1);
958 static int ablk_decrypt(struct ablkcipher_request
*req
)
960 return ablk_perform(req
, 0);
963 static int ablk_rfc3686_crypt(struct ablkcipher_request
*req
)
965 struct crypto_ablkcipher
*tfm
= crypto_ablkcipher_reqtfm(req
);
966 struct ixp_ctx
*ctx
= crypto_ablkcipher_ctx(tfm
);
967 u8 iv
[CTR_RFC3686_BLOCK_SIZE
];
968 u8
*info
= req
->info
;
971 /* set up counter block */
972 memcpy(iv
, ctx
->nonce
, CTR_RFC3686_NONCE_SIZE
);
973 memcpy(iv
+ CTR_RFC3686_NONCE_SIZE
, info
, CTR_RFC3686_IV_SIZE
);
975 /* initialize counter portion of counter block */
976 *(__be32
*)(iv
+ CTR_RFC3686_NONCE_SIZE
+ CTR_RFC3686_IV_SIZE
) =
980 ret
= ablk_perform(req
, 1);
985 static int aead_perform(struct aead_request
*req
, int encrypt
,
986 int cryptoffset
, int eff_cryptlen
, u8
*iv
)
988 struct crypto_aead
*tfm
= crypto_aead_reqtfm(req
);
989 struct ixp_ctx
*ctx
= crypto_aead_ctx(tfm
);
990 unsigned ivsize
= crypto_aead_ivsize(tfm
);
991 unsigned authsize
= crypto_aead_authsize(tfm
);
992 struct ix_sa_dir
*dir
;
993 struct crypt_ctl
*crypt
;
994 unsigned int cryptlen
;
995 struct buffer_desc
*buf
, src_hook
;
996 struct aead_ctx
*req_ctx
= aead_request_ctx(req
);
997 struct device
*dev
= &pdev
->dev
;
998 gfp_t flags
= req
->base
.flags
& CRYPTO_TFM_REQ_MAY_SLEEP
?
999 GFP_KERNEL
: GFP_ATOMIC
;
1000 enum dma_data_direction src_direction
= DMA_BIDIRECTIONAL
;
1001 unsigned int lastlen
;
1003 if (qmgr_stat_full(SEND_QID
))
1005 if (atomic_read(&ctx
->configuring
))
1009 dir
= &ctx
->encrypt
;
1010 cryptlen
= req
->cryptlen
;
1012 dir
= &ctx
->decrypt
;
1013 /* req->cryptlen includes the authsize when decrypting */
1014 cryptlen
= req
->cryptlen
-authsize
;
1015 eff_cryptlen
-= authsize
;
1017 crypt
= get_crypt_desc();
1021 crypt
->data
.aead_req
= req
;
1022 crypt
->crypto_ctx
= dir
->npe_ctx_phys
;
1023 crypt
->mode
= dir
->npe_mode
;
1024 crypt
->init_len
= dir
->npe_ctx_idx
;
1026 crypt
->crypt_offs
= cryptoffset
;
1027 crypt
->crypt_len
= eff_cryptlen
;
1029 crypt
->auth_offs
= 0;
1030 crypt
->auth_len
= req
->assoclen
+ cryptlen
;
1031 BUG_ON(ivsize
&& !req
->iv
);
1032 memcpy(crypt
->iv
, req
->iv
, ivsize
);
1034 buf
= chainup_buffers(dev
, req
->src
, crypt
->auth_len
,
1035 &src_hook
, flags
, src_direction
);
1036 req_ctx
->src
= src_hook
.next
;
1037 crypt
->src_buf
= src_hook
.phys_next
;
1041 lastlen
= buf
->buf_len
;
1042 if (lastlen
>= authsize
)
1043 crypt
->icv_rev_aes
= buf
->phys_addr
+
1044 buf
->buf_len
- authsize
;
1046 req_ctx
->dst
= NULL
;
1048 if (req
->src
!= req
->dst
) {
1049 struct buffer_desc dst_hook
;
1051 crypt
->mode
|= NPE_OP_NOT_IN_PLACE
;
1052 src_direction
= DMA_TO_DEVICE
;
1054 buf
= chainup_buffers(dev
, req
->dst
, crypt
->auth_len
,
1055 &dst_hook
, flags
, DMA_FROM_DEVICE
);
1056 req_ctx
->dst
= dst_hook
.next
;
1057 crypt
->dst_buf
= dst_hook
.phys_next
;
1063 lastlen
= buf
->buf_len
;
1064 if (lastlen
>= authsize
)
1065 crypt
->icv_rev_aes
= buf
->phys_addr
+
1066 buf
->buf_len
- authsize
;
1070 if (unlikely(lastlen
< authsize
)) {
1071 /* The 12 hmac bytes are scattered,
1072 * we need to copy them into a safe buffer */
1073 req_ctx
->hmac_virt
= dma_pool_alloc(buffer_pool
, flags
,
1074 &crypt
->icv_rev_aes
);
1075 if (unlikely(!req_ctx
->hmac_virt
))
1078 scatterwalk_map_and_copy(req_ctx
->hmac_virt
,
1079 req
->src
, cryptlen
, authsize
, 0);
1081 req_ctx
->encrypt
= encrypt
;
1083 req_ctx
->hmac_virt
= NULL
;
1086 crypt
->ctl_flags
|= CTL_FLAG_PERFORM_AEAD
;
1087 qmgr_put_entry(SEND_QID
, crypt_virt2phys(crypt
));
1088 BUG_ON(qmgr_stat_overflow(SEND_QID
));
1089 return -EINPROGRESS
;
1092 free_buf_chain(dev
, req_ctx
->src
, crypt
->src_buf
);
1094 free_buf_chain(dev
, req_ctx
->dst
, crypt
->dst_buf
);
1095 crypt
->ctl_flags
= CTL_FLAG_UNUSED
;
1099 static int aead_setup(struct crypto_aead
*tfm
, unsigned int authsize
)
1101 struct ixp_ctx
*ctx
= crypto_aead_ctx(tfm
);
1102 u32
*flags
= &tfm
->base
.crt_flags
;
1103 unsigned digest_len
= crypto_aead_maxauthsize(tfm
);
1106 if (!ctx
->enckey_len
&& !ctx
->authkey_len
)
1108 init_completion(&ctx
->completion
);
1109 atomic_inc(&ctx
->configuring
);
1111 reset_sa_dir(&ctx
->encrypt
);
1112 reset_sa_dir(&ctx
->decrypt
);
1114 ret
= setup_cipher(&tfm
->base
, 0, ctx
->enckey
, ctx
->enckey_len
);
1117 ret
= setup_cipher(&tfm
->base
, 1, ctx
->enckey
, ctx
->enckey_len
);
1120 ret
= setup_auth(&tfm
->base
, 0, authsize
, ctx
->authkey
,
1121 ctx
->authkey_len
, digest_len
);
1124 ret
= setup_auth(&tfm
->base
, 1, authsize
, ctx
->authkey
,
1125 ctx
->authkey_len
, digest_len
);
1129 if (*flags
& CRYPTO_TFM_RES_WEAK_KEY
) {
1130 if (*flags
& CRYPTO_TFM_REQ_WEAK_KEY
) {
1134 *flags
&= ~CRYPTO_TFM_RES_WEAK_KEY
;
1138 if (!atomic_dec_and_test(&ctx
->configuring
))
1139 wait_for_completion(&ctx
->completion
);
1143 static int aead_setauthsize(struct crypto_aead
*tfm
, unsigned int authsize
)
1145 int max
= crypto_aead_maxauthsize(tfm
) >> 2;
1147 if ((authsize
>>2) < 1 || (authsize
>>2) > max
|| (authsize
& 3))
1149 return aead_setup(tfm
, authsize
);
1152 static int aead_setkey(struct crypto_aead
*tfm
, const u8
*key
,
1153 unsigned int keylen
)
1155 struct ixp_ctx
*ctx
= crypto_aead_ctx(tfm
);
1156 struct crypto_authenc_keys keys
;
1158 if (crypto_authenc_extractkeys(&keys
, key
, keylen
) != 0)
1161 if (keys
.authkeylen
> sizeof(ctx
->authkey
))
1164 if (keys
.enckeylen
> sizeof(ctx
->enckey
))
1167 memcpy(ctx
->authkey
, keys
.authkey
, keys
.authkeylen
);
1168 memcpy(ctx
->enckey
, keys
.enckey
, keys
.enckeylen
);
1169 ctx
->authkey_len
= keys
.authkeylen
;
1170 ctx
->enckey_len
= keys
.enckeylen
;
1172 return aead_setup(tfm
, crypto_aead_authsize(tfm
));
1174 crypto_aead_set_flags(tfm
, CRYPTO_TFM_RES_BAD_KEY_LEN
);
1178 static int aead_encrypt(struct aead_request
*req
)
1180 return aead_perform(req
, 1, req
->assoclen
, req
->cryptlen
, req
->iv
);
1183 static int aead_decrypt(struct aead_request
*req
)
1185 return aead_perform(req
, 0, req
->assoclen
, req
->cryptlen
, req
->iv
);
1188 static struct ixp_alg ixp4xx_algos
[] = {
1191 .cra_name
= "cbc(des)",
1192 .cra_blocksize
= DES_BLOCK_SIZE
,
1193 .cra_u
= { .ablkcipher
= {
1194 .min_keysize
= DES_KEY_SIZE
,
1195 .max_keysize
= DES_KEY_SIZE
,
1196 .ivsize
= DES_BLOCK_SIZE
,
1201 .cfg_enc
= CIPH_ENCR
| MOD_DES
| MOD_CBC_ENC
| KEYLEN_192
,
1202 .cfg_dec
= CIPH_DECR
| MOD_DES
| MOD_CBC_DEC
| KEYLEN_192
,
1206 .cra_name
= "ecb(des)",
1207 .cra_blocksize
= DES_BLOCK_SIZE
,
1208 .cra_u
= { .ablkcipher
= {
1209 .min_keysize
= DES_KEY_SIZE
,
1210 .max_keysize
= DES_KEY_SIZE
,
1214 .cfg_enc
= CIPH_ENCR
| MOD_DES
| MOD_ECB
| KEYLEN_192
,
1215 .cfg_dec
= CIPH_DECR
| MOD_DES
| MOD_ECB
| KEYLEN_192
,
1218 .cra_name
= "cbc(des3_ede)",
1219 .cra_blocksize
= DES3_EDE_BLOCK_SIZE
,
1220 .cra_u
= { .ablkcipher
= {
1221 .min_keysize
= DES3_EDE_KEY_SIZE
,
1222 .max_keysize
= DES3_EDE_KEY_SIZE
,
1223 .ivsize
= DES3_EDE_BLOCK_SIZE
,
1228 .cfg_enc
= CIPH_ENCR
| MOD_3DES
| MOD_CBC_ENC
| KEYLEN_192
,
1229 .cfg_dec
= CIPH_DECR
| MOD_3DES
| MOD_CBC_DEC
| KEYLEN_192
,
1232 .cra_name
= "ecb(des3_ede)",
1233 .cra_blocksize
= DES3_EDE_BLOCK_SIZE
,
1234 .cra_u
= { .ablkcipher
= {
1235 .min_keysize
= DES3_EDE_KEY_SIZE
,
1236 .max_keysize
= DES3_EDE_KEY_SIZE
,
1240 .cfg_enc
= CIPH_ENCR
| MOD_3DES
| MOD_ECB
| KEYLEN_192
,
1241 .cfg_dec
= CIPH_DECR
| MOD_3DES
| MOD_ECB
| KEYLEN_192
,
1244 .cra_name
= "cbc(aes)",
1245 .cra_blocksize
= AES_BLOCK_SIZE
,
1246 .cra_u
= { .ablkcipher
= {
1247 .min_keysize
= AES_MIN_KEY_SIZE
,
1248 .max_keysize
= AES_MAX_KEY_SIZE
,
1249 .ivsize
= AES_BLOCK_SIZE
,
1254 .cfg_enc
= CIPH_ENCR
| MOD_AES
| MOD_CBC_ENC
,
1255 .cfg_dec
= CIPH_DECR
| MOD_AES
| MOD_CBC_DEC
,
1258 .cra_name
= "ecb(aes)",
1259 .cra_blocksize
= AES_BLOCK_SIZE
,
1260 .cra_u
= { .ablkcipher
= {
1261 .min_keysize
= AES_MIN_KEY_SIZE
,
1262 .max_keysize
= AES_MAX_KEY_SIZE
,
1266 .cfg_enc
= CIPH_ENCR
| MOD_AES
| MOD_ECB
,
1267 .cfg_dec
= CIPH_DECR
| MOD_AES
| MOD_ECB
,
1270 .cra_name
= "ctr(aes)",
1271 .cra_blocksize
= AES_BLOCK_SIZE
,
1272 .cra_u
= { .ablkcipher
= {
1273 .min_keysize
= AES_MIN_KEY_SIZE
,
1274 .max_keysize
= AES_MAX_KEY_SIZE
,
1275 .ivsize
= AES_BLOCK_SIZE
,
1280 .cfg_enc
= CIPH_ENCR
| MOD_AES
| MOD_CTR
,
1281 .cfg_dec
= CIPH_ENCR
| MOD_AES
| MOD_CTR
,
1284 .cra_name
= "rfc3686(ctr(aes))",
1285 .cra_blocksize
= AES_BLOCK_SIZE
,
1286 .cra_u
= { .ablkcipher
= {
1287 .min_keysize
= AES_MIN_KEY_SIZE
,
1288 .max_keysize
= AES_MAX_KEY_SIZE
,
1289 .ivsize
= AES_BLOCK_SIZE
,
1291 .setkey
= ablk_rfc3686_setkey
,
1292 .encrypt
= ablk_rfc3686_crypt
,
1293 .decrypt
= ablk_rfc3686_crypt
}
1296 .cfg_enc
= CIPH_ENCR
| MOD_AES
| MOD_CTR
,
1297 .cfg_dec
= CIPH_ENCR
| MOD_AES
| MOD_CTR
,
1300 static struct ixp_aead_alg ixp4xx_aeads
[] = {
1304 .cra_name
= "authenc(hmac(md5),cbc(des))",
1305 .cra_blocksize
= DES_BLOCK_SIZE
,
1307 .ivsize
= DES_BLOCK_SIZE
,
1308 .maxauthsize
= MD5_DIGEST_SIZE
,
1310 .hash
= &hash_alg_md5
,
1311 .cfg_enc
= CIPH_ENCR
| MOD_DES
| MOD_CBC_ENC
| KEYLEN_192
,
1312 .cfg_dec
= CIPH_DECR
| MOD_DES
| MOD_CBC_DEC
| KEYLEN_192
,
1316 .cra_name
= "authenc(hmac(md5),cbc(des3_ede))",
1317 .cra_blocksize
= DES3_EDE_BLOCK_SIZE
,
1319 .ivsize
= DES3_EDE_BLOCK_SIZE
,
1320 .maxauthsize
= MD5_DIGEST_SIZE
,
1322 .hash
= &hash_alg_md5
,
1323 .cfg_enc
= CIPH_ENCR
| MOD_3DES
| MOD_CBC_ENC
| KEYLEN_192
,
1324 .cfg_dec
= CIPH_DECR
| MOD_3DES
| MOD_CBC_DEC
| KEYLEN_192
,
1328 .cra_name
= "authenc(hmac(sha1),cbc(des))",
1329 .cra_blocksize
= DES_BLOCK_SIZE
,
1331 .ivsize
= DES_BLOCK_SIZE
,
1332 .maxauthsize
= SHA1_DIGEST_SIZE
,
1334 .hash
= &hash_alg_sha1
,
1335 .cfg_enc
= CIPH_ENCR
| MOD_DES
| MOD_CBC_ENC
| KEYLEN_192
,
1336 .cfg_dec
= CIPH_DECR
| MOD_DES
| MOD_CBC_DEC
| KEYLEN_192
,
1340 .cra_name
= "authenc(hmac(sha1),cbc(des3_ede))",
1341 .cra_blocksize
= DES3_EDE_BLOCK_SIZE
,
1343 .ivsize
= DES3_EDE_BLOCK_SIZE
,
1344 .maxauthsize
= SHA1_DIGEST_SIZE
,
1346 .hash
= &hash_alg_sha1
,
1347 .cfg_enc
= CIPH_ENCR
| MOD_3DES
| MOD_CBC_ENC
| KEYLEN_192
,
1348 .cfg_dec
= CIPH_DECR
| MOD_3DES
| MOD_CBC_DEC
| KEYLEN_192
,
1352 .cra_name
= "authenc(hmac(md5),cbc(aes))",
1353 .cra_blocksize
= AES_BLOCK_SIZE
,
1355 .ivsize
= AES_BLOCK_SIZE
,
1356 .maxauthsize
= MD5_DIGEST_SIZE
,
1358 .hash
= &hash_alg_md5
,
1359 .cfg_enc
= CIPH_ENCR
| MOD_AES
| MOD_CBC_ENC
,
1360 .cfg_dec
= CIPH_DECR
| MOD_AES
| MOD_CBC_DEC
,
1364 .cra_name
= "authenc(hmac(sha1),cbc(aes))",
1365 .cra_blocksize
= AES_BLOCK_SIZE
,
1367 .ivsize
= AES_BLOCK_SIZE
,
1368 .maxauthsize
= SHA1_DIGEST_SIZE
,
1370 .hash
= &hash_alg_sha1
,
1371 .cfg_enc
= CIPH_ENCR
| MOD_AES
| MOD_CBC_ENC
,
1372 .cfg_dec
= CIPH_DECR
| MOD_AES
| MOD_CBC_DEC
,
1375 #define IXP_POSTFIX "-ixp4xx"
1377 static const struct platform_device_info ixp_dev_info __initdata
= {
1378 .name
= DRIVER_NAME
,
1380 .dma_mask
= DMA_BIT_MASK(32),
1383 static int __init
ixp_module_init(void)
1385 int num
= ARRAY_SIZE(ixp4xx_algos
);
1388 pdev
= platform_device_register_full(&ixp_dev_info
);
1390 return PTR_ERR(pdev
);
1392 spin_lock_init(&desc_lock
);
1393 spin_lock_init(&emerg_lock
);
1395 err
= init_ixp_crypto(&pdev
->dev
);
1397 platform_device_unregister(pdev
);
1400 for (i
=0; i
< num
; i
++) {
1401 struct crypto_alg
*cra
= &ixp4xx_algos
[i
].crypto
;
1403 if (snprintf(cra
->cra_driver_name
, CRYPTO_MAX_ALG_NAME
,
1404 "%s"IXP_POSTFIX
, cra
->cra_name
) >=
1405 CRYPTO_MAX_ALG_NAME
)
1409 if (!support_aes
&& (ixp4xx_algos
[i
].cfg_enc
& MOD_AES
)) {
1414 cra
->cra_type
= &crypto_ablkcipher_type
;
1415 cra
->cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
|
1416 CRYPTO_ALG_KERN_DRIVER_ONLY
|
1418 if (!cra
->cra_ablkcipher
.setkey
)
1419 cra
->cra_ablkcipher
.setkey
= ablk_setkey
;
1420 if (!cra
->cra_ablkcipher
.encrypt
)
1421 cra
->cra_ablkcipher
.encrypt
= ablk_encrypt
;
1422 if (!cra
->cra_ablkcipher
.decrypt
)
1423 cra
->cra_ablkcipher
.decrypt
= ablk_decrypt
;
1424 cra
->cra_init
= init_tfm_ablk
;
1426 cra
->cra_ctxsize
= sizeof(struct ixp_ctx
);
1427 cra
->cra_module
= THIS_MODULE
;
1428 cra
->cra_alignmask
= 3;
1429 cra
->cra_priority
= 300;
1430 cra
->cra_exit
= exit_tfm
;
1431 if (crypto_register_alg(cra
))
1432 printk(KERN_ERR
"Failed to register '%s'\n",
1435 ixp4xx_algos
[i
].registered
= 1;
1438 for (i
= 0; i
< ARRAY_SIZE(ixp4xx_aeads
); i
++) {
1439 struct aead_alg
*cra
= &ixp4xx_aeads
[i
].crypto
;
1441 if (snprintf(cra
->base
.cra_driver_name
, CRYPTO_MAX_ALG_NAME
,
1442 "%s"IXP_POSTFIX
, cra
->base
.cra_name
) >=
1443 CRYPTO_MAX_ALG_NAME
)
1445 if (!support_aes
&& (ixp4xx_algos
[i
].cfg_enc
& MOD_AES
))
1449 cra
->base
.cra_flags
= CRYPTO_ALG_KERN_DRIVER_ONLY
|
1451 cra
->setkey
= aead_setkey
;
1452 cra
->setauthsize
= aead_setauthsize
;
1453 cra
->encrypt
= aead_encrypt
;
1454 cra
->decrypt
= aead_decrypt
;
1455 cra
->init
= init_tfm_aead
;
1456 cra
->exit
= exit_tfm_aead
;
1458 cra
->base
.cra_ctxsize
= sizeof(struct ixp_ctx
);
1459 cra
->base
.cra_module
= THIS_MODULE
;
1460 cra
->base
.cra_alignmask
= 3;
1461 cra
->base
.cra_priority
= 300;
1463 if (crypto_register_aead(cra
))
1464 printk(KERN_ERR
"Failed to register '%s'\n",
1465 cra
->base
.cra_driver_name
);
1467 ixp4xx_aeads
[i
].registered
= 1;
1472 static void __exit
ixp_module_exit(void)
1474 int num
= ARRAY_SIZE(ixp4xx_algos
);
1477 for (i
= 0; i
< ARRAY_SIZE(ixp4xx_aeads
); i
++) {
1478 if (ixp4xx_aeads
[i
].registered
)
1479 crypto_unregister_aead(&ixp4xx_aeads
[i
].crypto
);
1482 for (i
=0; i
< num
; i
++) {
1483 if (ixp4xx_algos
[i
].registered
)
1484 crypto_unregister_alg(&ixp4xx_algos
[i
].crypto
);
1486 release_ixp_crypto(&pdev
->dev
);
1487 platform_device_unregister(pdev
);
1490 module_init(ixp_module_init
);
1491 module_exit(ixp_module_exit
);
1493 MODULE_LICENSE("GPL");
1494 MODULE_AUTHOR("Christian Hohnstaedt <chohnstaedt@innominate.com>");
1495 MODULE_DESCRIPTION("IXP4xx hardware crypto");