[PATCH] remove many unneeded #includes of sched.h
[linux-2.6.git] / drivers / crypto / geode-aes.c
1  /* Copyright (C) 2004-2006, Advanced Micro Devices, Inc.
2  *
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.
7  */
8
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>
16
17 #include <asm/io.h>
18 #include <asm/delay.h>
19
20 #include "geode-aes.h"
21
22 /* Register definitions */
23
24 #define AES_CTRLA_REG  0x0000
25
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
33
34 #define AES_INTR_REG  0x0008
35
36 #define AES_INTRA_PENDING (1 << 16)
37 #define AES_INTRB_PENDING (1 << 17)
38
39 #define AES_INTR_PENDING  (AES_INTRA_PENDING | AES_INTRB_PENDING)
40 #define AES_INTR_MASK     0x07
41
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
47
48 /*  A very large counter that is used to gracefully bail out of an
49  *  operation in case of trouble
50  */
51
52 #define AES_OP_TIMEOUT    0x50000
53
54 /* Static structures */
55
56 static void __iomem * _iobase;
57 static spinlock_t lock;
58
59 /* Write a 128 bit field (either a writable key or IV) */
60 static inline void
61 _writefield(u32 offset, void *value)
62 {
63         int i;
64         for(i = 0; i < 4; i++)
65                 iowrite32(((u32 *) value)[i], _iobase + offset + (i * 4));
66 }
67
68 /* Read a 128 bit field (either a writable key or IV) */
69 static inline void
70 _readfield(u32 offset, void *value)
71 {
72         int i;
73         for(i = 0; i < 4; i++)
74                 ((u32 *) value)[i] = ioread32(_iobase + offset + (i * 4));
75 }
76
77 static int
78 do_crypt(void *src, void *dst, int len, u32 flags)
79 {
80         u32 status;
81         u32 counter = AES_OP_TIMEOUT;
82
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);
86
87         /* Start the operation */
88         iowrite32(AES_CTRL_START | flags, _iobase + AES_CTRLA_REG);
89
90         do
91                 status = ioread32(_iobase + AES_INTR_REG);
92         while(!(status & AES_INTRA_PENDING) && --counter);
93
94         /* Clear the event */
95         iowrite32((status & 0xFF) | AES_INTRA_PENDING, _iobase + AES_INTR_REG);
96         return counter ? 0 : 1;
97 }
98
99 static unsigned int
100 geode_aes_crypt(struct geode_aes_op *op)
101 {
102
103         u32 flags = 0;
104         int iflags;
105
106         if (op->len == 0 || op->src == op->dst)
107                 return 0;
108
109         if (op->flags & AES_FLAGS_COHERENT)
110                 flags |= (AES_CTRL_DCA | AES_CTRL_SCA);
111
112         if (op->dir == AES_DIR_ENCRYPT)
113                 flags |= AES_CTRL_ENCRYPT;
114
115         /* Start the critical section */
116
117         spin_lock_irqsave(&lock, iflags);
118
119         if (op->mode == AES_MODE_CBC) {
120                 flags |= AES_CTRL_CBC;
121                 _writefield(AES_WRITEIV0_REG, op->iv);
122         }
123
124         if (op->flags & AES_FLAGS_USRKEY) {
125                 flags |= AES_CTRL_WRKEY;
126                 _writefield(AES_WRITEKEY0_REG, op->key);
127         }
128
129         do_crypt(op->src, op->dst, op->len, flags);
130
131         if (op->mode == AES_MODE_CBC)
132                 _readfield(AES_WRITEIV0_REG, op->iv);
133
134         spin_unlock_irqrestore(&lock, iflags);
135
136         return op->len;
137 }
138
139 /* CRYPTO-API Functions */
140
141 static int
142 geode_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int len)
143 {
144         struct geode_aes_op *op = crypto_tfm_ctx(tfm);
145
146         if (len != AES_KEY_LENGTH) {
147                 tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
148                 return -EINVAL;
149         }
150
151         memcpy(op->key, key, len);
152         return 0;
153 }
154
155 static void
156 geode_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
157 {
158         struct geode_aes_op *op = crypto_tfm_ctx(tfm);
159
160         if ((out == NULL) || (in == NULL))
161                 return;
162
163         op->src = (void *) in;
164         op->dst = (void *) out;
165         op->mode = AES_MODE_ECB;
166         op->flags = 0;
167         op->len = AES_MIN_BLOCK_SIZE;
168         op->dir = AES_DIR_ENCRYPT;
169
170         geode_aes_crypt(op);
171 }
172
173
174 static void
175 geode_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
176 {
177         struct geode_aes_op *op = crypto_tfm_ctx(tfm);
178
179         if ((out == NULL) || (in == NULL))
180                 return;
181
182         op->src = (void *) in;
183         op->dst = (void *) out;
184         op->mode = AES_MODE_ECB;
185         op->flags = 0;
186         op->len = AES_MIN_BLOCK_SIZE;
187         op->dir = AES_DIR_DECRYPT;
188
189         geode_aes_crypt(op);
190 }
191
192
193 static struct crypto_alg geode_alg = {
194         .cra_name               =       "aes",
195         .cra_driver_name        =       "geode-aes-128",
196         .cra_priority           =       300,
197         .cra_alignmask          =       15,
198         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
199         .cra_blocksize          =       AES_MIN_BLOCK_SIZE,
200         .cra_ctxsize            =       sizeof(struct geode_aes_op),
201         .cra_module             =       THIS_MODULE,
202         .cra_list               =       LIST_HEAD_INIT(geode_alg.cra_list),
203         .cra_u                  =       {
204                 .cipher = {
205                         .cia_min_keysize        =  AES_KEY_LENGTH,
206                         .cia_max_keysize        =  AES_KEY_LENGTH,
207                         .cia_setkey             =  geode_setkey,
208                         .cia_encrypt            =  geode_encrypt,
209                         .cia_decrypt            =  geode_decrypt
210                 }
211         }
212 };
213
214 static int
215 geode_cbc_decrypt(struct blkcipher_desc *desc,
216                   struct scatterlist *dst, struct scatterlist *src,
217                   unsigned int nbytes)
218 {
219         struct geode_aes_op *op = crypto_blkcipher_ctx(desc->tfm);
220         struct blkcipher_walk walk;
221         int err, ret;
222
223         blkcipher_walk_init(&walk, dst, src, nbytes);
224         err = blkcipher_walk_virt(desc, &walk);
225
226         while((nbytes = walk.nbytes)) {
227                 op->src = walk.src.virt.addr,
228                 op->dst = walk.dst.virt.addr;
229                 op->mode = AES_MODE_CBC;
230                 op->len = nbytes - (nbytes % AES_MIN_BLOCK_SIZE);
231                 op->dir = AES_DIR_DECRYPT;
232
233                 memcpy(op->iv, walk.iv, AES_IV_LENGTH);
234
235                 ret = geode_aes_crypt(op);
236
237                 memcpy(walk.iv, op->iv, AES_IV_LENGTH);
238                 nbytes -= ret;
239
240                 err = blkcipher_walk_done(desc, &walk, nbytes);
241         }
242
243         return err;
244 }
245
246 static int
247 geode_cbc_encrypt(struct blkcipher_desc *desc,
248                   struct scatterlist *dst, struct scatterlist *src,
249                   unsigned int nbytes)
250 {
251         struct geode_aes_op *op = crypto_blkcipher_ctx(desc->tfm);
252         struct blkcipher_walk walk;
253         int err, ret;
254
255         blkcipher_walk_init(&walk, dst, src, nbytes);
256         err = blkcipher_walk_virt(desc, &walk);
257
258         while((nbytes = walk.nbytes)) {
259                 op->src = walk.src.virt.addr,
260                 op->dst = walk.dst.virt.addr;
261                 op->mode = AES_MODE_CBC;
262                 op->len = nbytes - (nbytes % AES_MIN_BLOCK_SIZE);
263                 op->dir = AES_DIR_ENCRYPT;
264
265                 memcpy(op->iv, walk.iv, AES_IV_LENGTH);
266
267                 ret = geode_aes_crypt(op);
268                 nbytes -= ret;
269                 err = blkcipher_walk_done(desc, &walk, nbytes);
270         }
271
272         return err;
273 }
274
275 static struct crypto_alg geode_cbc_alg = {
276         .cra_name               =       "cbc(aes)",
277         .cra_driver_name        =       "cbc-aes-geode-128",
278         .cra_priority           =       400,
279         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
280         .cra_blocksize          =       AES_MIN_BLOCK_SIZE,
281         .cra_ctxsize            =       sizeof(struct geode_aes_op),
282         .cra_alignmask          =       15,
283         .cra_type               =       &crypto_blkcipher_type,
284         .cra_module             =       THIS_MODULE,
285         .cra_list               =       LIST_HEAD_INIT(geode_cbc_alg.cra_list),
286         .cra_u                  =       {
287                 .blkcipher = {
288                         .min_keysize            =       AES_KEY_LENGTH,
289                         .max_keysize            =       AES_KEY_LENGTH,
290                         .setkey                 =       geode_setkey,
291                         .encrypt                =       geode_cbc_encrypt,
292                         .decrypt                =       geode_cbc_decrypt,
293                 }
294         }
295 };
296
297 static int
298 geode_ecb_decrypt(struct blkcipher_desc *desc,
299                   struct scatterlist *dst, struct scatterlist *src,
300                   unsigned int nbytes)
301 {
302         struct geode_aes_op *op = crypto_blkcipher_ctx(desc->tfm);
303         struct blkcipher_walk walk;
304         int err, ret;
305
306         blkcipher_walk_init(&walk, dst, src, nbytes);
307         err = blkcipher_walk_virt(desc, &walk);
308
309         while((nbytes = walk.nbytes)) {
310                 op->src = walk.src.virt.addr,
311                 op->dst = walk.dst.virt.addr;
312                 op->mode = AES_MODE_ECB;
313                 op->len = nbytes - (nbytes % AES_MIN_BLOCK_SIZE);
314                 op->dir = AES_DIR_DECRYPT;
315
316                 ret = geode_aes_crypt(op);
317                 nbytes -= ret;
318                 err = blkcipher_walk_done(desc, &walk, nbytes);
319         }
320
321         return err;
322 }
323
324 static int
325 geode_ecb_encrypt(struct blkcipher_desc *desc,
326                   struct scatterlist *dst, struct scatterlist *src,
327                   unsigned int nbytes)
328 {
329         struct geode_aes_op *op = crypto_blkcipher_ctx(desc->tfm);
330         struct blkcipher_walk walk;
331         int err, ret;
332
333         blkcipher_walk_init(&walk, dst, src, nbytes);
334         err = blkcipher_walk_virt(desc, &walk);
335
336         while((nbytes = walk.nbytes)) {
337                 op->src = walk.src.virt.addr,
338                 op->dst = walk.dst.virt.addr;
339                 op->mode = AES_MODE_ECB;
340                 op->len = nbytes - (nbytes % AES_MIN_BLOCK_SIZE);
341                 op->dir = AES_DIR_ENCRYPT;
342
343                 ret = geode_aes_crypt(op);
344                 nbytes -= ret;
345                 ret =  blkcipher_walk_done(desc, &walk, nbytes);
346         }
347
348         return err;
349 }
350
351 static struct crypto_alg geode_ecb_alg = {
352         .cra_name               =       "ecb(aes)",
353         .cra_driver_name        =       "ecb-aes-geode-128",
354         .cra_priority           =       400,
355         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
356         .cra_blocksize          =       AES_MIN_BLOCK_SIZE,
357         .cra_ctxsize            =       sizeof(struct geode_aes_op),
358         .cra_alignmask          =       15,
359         .cra_type               =       &crypto_blkcipher_type,
360         .cra_module             =       THIS_MODULE,
361         .cra_list               =       LIST_HEAD_INIT(geode_ecb_alg.cra_list),
362         .cra_u                  =       {
363                 .blkcipher = {
364                         .min_keysize            =       AES_KEY_LENGTH,
365                         .max_keysize            =       AES_KEY_LENGTH,
366                         .setkey                 =       geode_setkey,
367                         .encrypt                =       geode_ecb_encrypt,
368                         .decrypt                =       geode_ecb_decrypt,
369                 }
370         }
371 };
372
373 static void
374 geode_aes_remove(struct pci_dev *dev)
375 {
376         crypto_unregister_alg(&geode_alg);
377         crypto_unregister_alg(&geode_ecb_alg);
378         crypto_unregister_alg(&geode_cbc_alg);
379
380         pci_iounmap(dev, _iobase);
381         _iobase = NULL;
382
383         pci_release_regions(dev);
384         pci_disable_device(dev);
385 }
386
387
388 static int
389 geode_aes_probe(struct pci_dev *dev, const struct pci_device_id *id)
390 {
391         int ret;
392
393         if ((ret = pci_enable_device(dev)))
394                 return ret;
395
396         if ((ret = pci_request_regions(dev, "geode-aes-128")))
397                 goto eenable;
398
399         _iobase = pci_iomap(dev, 0, 0);
400
401         if (_iobase == NULL) {
402                 ret = -ENOMEM;
403                 goto erequest;
404         }
405
406         spin_lock_init(&lock);
407
408         /* Clear any pending activity */
409         iowrite32(AES_INTR_PENDING | AES_INTR_MASK, _iobase + AES_INTR_REG);
410
411         if ((ret = crypto_register_alg(&geode_alg)))
412                 goto eiomap;
413
414         if ((ret = crypto_register_alg(&geode_ecb_alg)))
415                 goto ealg;
416
417         if ((ret = crypto_register_alg(&geode_cbc_alg)))
418                 goto eecb;
419
420         printk(KERN_NOTICE "geode-aes: GEODE AES engine enabled.\n");
421         return 0;
422
423  eecb:
424         crypto_unregister_alg(&geode_ecb_alg);
425
426  ealg:
427         crypto_unregister_alg(&geode_alg);
428
429  eiomap:
430         pci_iounmap(dev, _iobase);
431
432  erequest:
433         pci_release_regions(dev);
434
435  eenable:
436         pci_disable_device(dev);
437
438         printk(KERN_ERR "geode-aes:  GEODE AES initialization failed.\n");
439         return ret;
440 }
441
442 static struct pci_device_id geode_aes_tbl[] = {
443         { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_LX_AES, PCI_ANY_ID, PCI_ANY_ID} ,
444         { 0, }
445 };
446
447 MODULE_DEVICE_TABLE(pci, geode_aes_tbl);
448
449 static struct pci_driver geode_aes_driver = {
450         .name = "Geode LX AES",
451         .id_table = geode_aes_tbl,
452         .probe = geode_aes_probe,
453         .remove = __devexit_p(geode_aes_remove)
454 };
455
456 static int __init
457 geode_aes_init(void)
458 {
459         return pci_register_driver(&geode_aes_driver);
460 }
461
462 static void __exit
463 geode_aes_exit(void)
464 {
465         pci_unregister_driver(&geode_aes_driver);
466 }
467
468 MODULE_AUTHOR("Advanced Micro Devices, Inc.");
469 MODULE_DESCRIPTION("Geode LX Hardware AES driver");
470 MODULE_LICENSE("GPL");
471
472 module_init(geode_aes_init);
473 module_exit(geode_aes_exit);