1 /* Copyright (C) 2004-2006, Advanced Micro Devices, Inc.
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/pci.h>
12 #include <linux/pci_ids.h>
13 #include <linux/crypto.h>
14 #include <linux/spinlock.h>
15 #include <crypto/algapi.h>
18 #include <asm/delay.h>
20 #include "geode-aes.h"
22 /* Register definitions */
24 #define AES_CTRLA_REG 0x0000
26 #define AES_CTRL_START 0x01
27 #define AES_CTRL_DECRYPT 0x00
28 #define AES_CTRL_ENCRYPT 0x02
29 #define AES_CTRL_WRKEY 0x04
30 #define AES_CTRL_DCA 0x08
31 #define AES_CTRL_SCA 0x10
32 #define AES_CTRL_CBC 0x20
34 #define AES_INTR_REG 0x0008
36 #define AES_INTRA_PENDING (1 << 16)
37 #define AES_INTRB_PENDING (1 << 17)
39 #define AES_INTR_PENDING (AES_INTRA_PENDING | AES_INTRB_PENDING)
40 #define AES_INTR_MASK 0x07
42 #define AES_SOURCEA_REG 0x0010
43 #define AES_DSTA_REG 0x0014
44 #define AES_LENA_REG 0x0018
45 #define AES_WRITEKEY0_REG 0x0030
46 #define AES_WRITEIV0_REG 0x0040
48 /* A very large counter that is used to gracefully bail out of an
49 * operation in case of trouble
52 #define AES_OP_TIMEOUT 0x50000
54 /* Static structures */
56 static void __iomem
* _iobase
;
57 static spinlock_t lock
;
59 /* Write a 128 bit field (either a writable key or IV) */
61 _writefield(u32 offset
, void *value
)
64 for(i
= 0; i
< 4; i
++)
65 iowrite32(((u32
*) value
)[i
], _iobase
+ offset
+ (i
* 4));
68 /* Read a 128 bit field (either a writable key or IV) */
70 _readfield(u32 offset
, void *value
)
73 for(i
= 0; i
< 4; i
++)
74 ((u32
*) value
)[i
] = ioread32(_iobase
+ offset
+ (i
* 4));
78 do_crypt(void *src
, void *dst
, int len
, u32 flags
)
81 u32 counter
= AES_OP_TIMEOUT
;
83 iowrite32(virt_to_phys(src
), _iobase
+ AES_SOURCEA_REG
);
84 iowrite32(virt_to_phys(dst
), _iobase
+ AES_DSTA_REG
);
85 iowrite32(len
, _iobase
+ AES_LENA_REG
);
87 /* Start the operation */
88 iowrite32(AES_CTRL_START
| flags
, _iobase
+ AES_CTRLA_REG
);
91 status
= ioread32(_iobase
+ AES_INTR_REG
);
92 while(!(status
& AES_INTRA_PENDING
) && --counter
);
95 iowrite32((status
& 0xFF) | AES_INTRA_PENDING
, _iobase
+ AES_INTR_REG
);
96 return counter
? 0 : 1;
100 geode_aes_crypt(struct geode_aes_op
*op
)
103 unsigned long iflags
;
108 /* If the source and destination is the same, then
109 * we need to turn on the coherent flags, otherwise
110 * we don't need to worry
113 if (op
->src
== op
->dst
)
114 flags
|= (AES_CTRL_DCA
| AES_CTRL_SCA
);
116 if (op
->dir
== AES_DIR_ENCRYPT
)
117 flags
|= AES_CTRL_ENCRYPT
;
119 /* Start the critical section */
121 spin_lock_irqsave(&lock
, iflags
);
123 if (op
->mode
== AES_MODE_CBC
) {
124 flags
|= AES_CTRL_CBC
;
125 _writefield(AES_WRITEIV0_REG
, op
->iv
);
128 if (!(op
->flags
& AES_FLAGS_HIDDENKEY
)) {
129 flags
|= AES_CTRL_WRKEY
;
130 _writefield(AES_WRITEKEY0_REG
, op
->key
);
133 do_crypt(op
->src
, op
->dst
, op
->len
, flags
);
135 if (op
->mode
== AES_MODE_CBC
)
136 _readfield(AES_WRITEIV0_REG
, op
->iv
);
138 spin_unlock_irqrestore(&lock
, iflags
);
143 /* CRYPTO-API Functions */
146 geode_setkey(struct crypto_tfm
*tfm
, const u8
*key
, unsigned int len
)
148 struct geode_aes_op
*op
= crypto_tfm_ctx(tfm
);
150 if (len
!= AES_KEY_LENGTH
) {
151 tfm
->crt_flags
|= CRYPTO_TFM_RES_BAD_KEY_LEN
;
155 memcpy(op
->key
, key
, len
);
160 geode_encrypt(struct crypto_tfm
*tfm
, u8
*out
, const u8
*in
)
162 struct geode_aes_op
*op
= crypto_tfm_ctx(tfm
);
164 if ((out
== NULL
) || (in
== NULL
))
167 op
->src
= (void *) in
;
168 op
->dst
= (void *) out
;
169 op
->mode
= AES_MODE_ECB
;
171 op
->len
= AES_MIN_BLOCK_SIZE
;
172 op
->dir
= AES_DIR_ENCRYPT
;
179 geode_decrypt(struct crypto_tfm
*tfm
, u8
*out
, const u8
*in
)
181 struct geode_aes_op
*op
= crypto_tfm_ctx(tfm
);
183 if ((out
== NULL
) || (in
== NULL
))
186 op
->src
= (void *) in
;
187 op
->dst
= (void *) out
;
188 op
->mode
= AES_MODE_ECB
;
190 op
->len
= AES_MIN_BLOCK_SIZE
;
191 op
->dir
= AES_DIR_DECRYPT
;
197 static struct crypto_alg geode_alg
= {
199 .cra_driver_name
= "geode-aes-128",
202 .cra_flags
= CRYPTO_ALG_TYPE_CIPHER
,
203 .cra_blocksize
= AES_MIN_BLOCK_SIZE
,
204 .cra_ctxsize
= sizeof(struct geode_aes_op
),
205 .cra_module
= THIS_MODULE
,
206 .cra_list
= LIST_HEAD_INIT(geode_alg
.cra_list
),
209 .cia_min_keysize
= AES_KEY_LENGTH
,
210 .cia_max_keysize
= AES_KEY_LENGTH
,
211 .cia_setkey
= geode_setkey
,
212 .cia_encrypt
= geode_encrypt
,
213 .cia_decrypt
= geode_decrypt
219 geode_cbc_decrypt(struct blkcipher_desc
*desc
,
220 struct scatterlist
*dst
, struct scatterlist
*src
,
223 struct geode_aes_op
*op
= crypto_blkcipher_ctx(desc
->tfm
);
224 struct blkcipher_walk walk
;
227 blkcipher_walk_init(&walk
, dst
, src
, nbytes
);
228 err
= blkcipher_walk_virt(desc
, &walk
);
230 while((nbytes
= walk
.nbytes
)) {
231 op
->src
= walk
.src
.virt
.addr
,
232 op
->dst
= walk
.dst
.virt
.addr
;
233 op
->mode
= AES_MODE_CBC
;
234 op
->len
= nbytes
- (nbytes
% AES_MIN_BLOCK_SIZE
);
235 op
->dir
= AES_DIR_DECRYPT
;
237 memcpy(op
->iv
, walk
.iv
, AES_IV_LENGTH
);
239 ret
= geode_aes_crypt(op
);
241 memcpy(walk
.iv
, op
->iv
, AES_IV_LENGTH
);
244 err
= blkcipher_walk_done(desc
, &walk
, nbytes
);
251 geode_cbc_encrypt(struct blkcipher_desc
*desc
,
252 struct scatterlist
*dst
, struct scatterlist
*src
,
255 struct geode_aes_op
*op
= crypto_blkcipher_ctx(desc
->tfm
);
256 struct blkcipher_walk walk
;
259 blkcipher_walk_init(&walk
, dst
, src
, nbytes
);
260 err
= blkcipher_walk_virt(desc
, &walk
);
262 while((nbytes
= walk
.nbytes
)) {
263 op
->src
= walk
.src
.virt
.addr
,
264 op
->dst
= walk
.dst
.virt
.addr
;
265 op
->mode
= AES_MODE_CBC
;
266 op
->len
= nbytes
- (nbytes
% AES_MIN_BLOCK_SIZE
);
267 op
->dir
= AES_DIR_ENCRYPT
;
269 memcpy(op
->iv
, walk
.iv
, AES_IV_LENGTH
);
271 ret
= geode_aes_crypt(op
);
273 err
= blkcipher_walk_done(desc
, &walk
, nbytes
);
279 static struct crypto_alg geode_cbc_alg
= {
280 .cra_name
= "cbc(aes)",
281 .cra_driver_name
= "cbc-aes-geode-128",
283 .cra_flags
= CRYPTO_ALG_TYPE_BLKCIPHER
,
284 .cra_blocksize
= AES_MIN_BLOCK_SIZE
,
285 .cra_ctxsize
= sizeof(struct geode_aes_op
),
287 .cra_type
= &crypto_blkcipher_type
,
288 .cra_module
= THIS_MODULE
,
289 .cra_list
= LIST_HEAD_INIT(geode_cbc_alg
.cra_list
),
292 .min_keysize
= AES_KEY_LENGTH
,
293 .max_keysize
= AES_KEY_LENGTH
,
294 .setkey
= geode_setkey
,
295 .encrypt
= geode_cbc_encrypt
,
296 .decrypt
= geode_cbc_decrypt
,
297 .ivsize
= AES_IV_LENGTH
,
303 geode_ecb_decrypt(struct blkcipher_desc
*desc
,
304 struct scatterlist
*dst
, struct scatterlist
*src
,
307 struct geode_aes_op
*op
= crypto_blkcipher_ctx(desc
->tfm
);
308 struct blkcipher_walk walk
;
311 blkcipher_walk_init(&walk
, dst
, src
, nbytes
);
312 err
= blkcipher_walk_virt(desc
, &walk
);
314 while((nbytes
= walk
.nbytes
)) {
315 op
->src
= walk
.src
.virt
.addr
,
316 op
->dst
= walk
.dst
.virt
.addr
;
317 op
->mode
= AES_MODE_ECB
;
318 op
->len
= nbytes
- (nbytes
% AES_MIN_BLOCK_SIZE
);
319 op
->dir
= AES_DIR_DECRYPT
;
321 ret
= geode_aes_crypt(op
);
323 err
= blkcipher_walk_done(desc
, &walk
, nbytes
);
330 geode_ecb_encrypt(struct blkcipher_desc
*desc
,
331 struct scatterlist
*dst
, struct scatterlist
*src
,
334 struct geode_aes_op
*op
= crypto_blkcipher_ctx(desc
->tfm
);
335 struct blkcipher_walk walk
;
338 blkcipher_walk_init(&walk
, dst
, src
, nbytes
);
339 err
= blkcipher_walk_virt(desc
, &walk
);
341 while((nbytes
= walk
.nbytes
)) {
342 op
->src
= walk
.src
.virt
.addr
,
343 op
->dst
= walk
.dst
.virt
.addr
;
344 op
->mode
= AES_MODE_ECB
;
345 op
->len
= nbytes
- (nbytes
% AES_MIN_BLOCK_SIZE
);
346 op
->dir
= AES_DIR_ENCRYPT
;
348 ret
= geode_aes_crypt(op
);
350 ret
= blkcipher_walk_done(desc
, &walk
, nbytes
);
356 static struct crypto_alg geode_ecb_alg
= {
357 .cra_name
= "ecb(aes)",
358 .cra_driver_name
= "ecb-aes-geode-128",
360 .cra_flags
= CRYPTO_ALG_TYPE_BLKCIPHER
,
361 .cra_blocksize
= AES_MIN_BLOCK_SIZE
,
362 .cra_ctxsize
= sizeof(struct geode_aes_op
),
364 .cra_type
= &crypto_blkcipher_type
,
365 .cra_module
= THIS_MODULE
,
366 .cra_list
= LIST_HEAD_INIT(geode_ecb_alg
.cra_list
),
369 .min_keysize
= AES_KEY_LENGTH
,
370 .max_keysize
= AES_KEY_LENGTH
,
371 .setkey
= geode_setkey
,
372 .encrypt
= geode_ecb_encrypt
,
373 .decrypt
= geode_ecb_decrypt
,
379 geode_aes_remove(struct pci_dev
*dev
)
381 crypto_unregister_alg(&geode_alg
);
382 crypto_unregister_alg(&geode_ecb_alg
);
383 crypto_unregister_alg(&geode_cbc_alg
);
385 pci_iounmap(dev
, _iobase
);
388 pci_release_regions(dev
);
389 pci_disable_device(dev
);
394 geode_aes_probe(struct pci_dev
*dev
, const struct pci_device_id
*id
)
398 if ((ret
= pci_enable_device(dev
)))
401 if ((ret
= pci_request_regions(dev
, "geode-aes-128")))
404 _iobase
= pci_iomap(dev
, 0, 0);
406 if (_iobase
== NULL
) {
411 spin_lock_init(&lock
);
413 /* Clear any pending activity */
414 iowrite32(AES_INTR_PENDING
| AES_INTR_MASK
, _iobase
+ AES_INTR_REG
);
416 if ((ret
= crypto_register_alg(&geode_alg
)))
419 if ((ret
= crypto_register_alg(&geode_ecb_alg
)))
422 if ((ret
= crypto_register_alg(&geode_cbc_alg
)))
425 printk(KERN_NOTICE
"geode-aes: GEODE AES engine enabled.\n");
429 crypto_unregister_alg(&geode_ecb_alg
);
432 crypto_unregister_alg(&geode_alg
);
435 pci_iounmap(dev
, _iobase
);
438 pci_release_regions(dev
);
441 pci_disable_device(dev
);
443 printk(KERN_ERR
"geode-aes: GEODE AES initialization failed.\n");
447 static struct pci_device_id geode_aes_tbl
[] = {
448 { PCI_VENDOR_ID_AMD
, PCI_DEVICE_ID_AMD_LX_AES
, PCI_ANY_ID
, PCI_ANY_ID
} ,
452 MODULE_DEVICE_TABLE(pci
, geode_aes_tbl
);
454 static struct pci_driver geode_aes_driver
= {
455 .name
= "Geode LX AES",
456 .id_table
= geode_aes_tbl
,
457 .probe
= geode_aes_probe
,
458 .remove
= __devexit_p(geode_aes_remove
)
464 return pci_register_driver(&geode_aes_driver
);
470 pci_unregister_driver(&geode_aes_driver
);
473 MODULE_AUTHOR("Advanced Micro Devices, Inc.");
474 MODULE_DESCRIPTION("Geode LX Hardware AES driver");
475 MODULE_LICENSE("GPL");
478 module_init(geode_aes_init
);
479 module_exit(geode_aes_exit
);