[CRYPTO] aes_s390: Add fallback driver
[linux-3.10.git] / arch / s390 / crypto / aes_s390.c
1 /*
2  * Cryptographic API.
3  *
4  * s390 implementation of the AES Cipher Algorithm.
5  *
6  * s390 Version:
7  *   Copyright IBM Corp. 2005,2007
8  *   Author(s): Jan Glauber (jang@de.ibm.com)
9  *              Sebastian Siewior (sebastian@breakpoint.cc> SW-Fallback
10  *
11  * Derived from "crypto/aes_generic.c"
12  *
13  * This program is free software; you can redistribute it and/or modify it
14  * under the terms of the GNU General Public License as published by the Free
15  * Software Foundation; either version 2 of the License, or (at your option)
16  * any later version.
17  *
18  */
19
20 #include <crypto/aes.h>
21 #include <crypto/algapi.h>
22 #include <linux/err.h>
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include "crypt_s390.h"
26
27 #define AES_KEYLEN_128          1
28 #define AES_KEYLEN_192          2
29 #define AES_KEYLEN_256          4
30
31 static char keylen_flag = 0;
32
33 struct s390_aes_ctx {
34         u8 iv[AES_BLOCK_SIZE];
35         u8 key[AES_MAX_KEY_SIZE];
36         long enc;
37         long dec;
38         int key_len;
39         union {
40                 struct crypto_blkcipher *blk;
41                 struct crypto_cipher *cip;
42         } fallback;
43 };
44
45 /*
46  * Check if the key_len is supported by the HW.
47  * Returns 0 if it is, a positive number if it is not and software fallback is
48  * required or a negative number in case the key size is not valid
49  */
50 static int need_fallback(unsigned int key_len)
51 {
52         switch (key_len) {
53         case 16:
54                 if (!(keylen_flag & AES_KEYLEN_128))
55                         return 1;
56                 break;
57         case 24:
58                 if (!(keylen_flag & AES_KEYLEN_192))
59                         return 1;
60                 break;
61         case 32:
62                 if (!(keylen_flag & AES_KEYLEN_256))
63                         return 1;
64                 break;
65         default:
66                 return -1;
67                 break;
68         }
69         return 0;
70 }
71
72 static int setkey_fallback_cip(struct crypto_tfm *tfm, const u8 *in_key,
73                 unsigned int key_len)
74 {
75         struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
76         int ret;
77
78         sctx->fallback.blk->base.crt_flags &= ~CRYPTO_TFM_REQ_MASK;
79         sctx->fallback.blk->base.crt_flags |= (tfm->crt_flags &
80                         CRYPTO_TFM_REQ_MASK);
81
82         ret = crypto_cipher_setkey(sctx->fallback.cip, in_key, key_len);
83         if (ret) {
84                 tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
85                 tfm->crt_flags |= (sctx->fallback.blk->base.crt_flags &
86                                 CRYPTO_TFM_RES_MASK);
87         }
88         return ret;
89 }
90
91 static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
92                        unsigned int key_len)
93 {
94         struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
95         u32 *flags = &tfm->crt_flags;
96         int ret;
97
98         ret = need_fallback(key_len);
99         if (ret < 0) {
100                 *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
101                 return -EINVAL;
102         }
103
104         sctx->key_len = key_len;
105         if (!ret) {
106                 memcpy(sctx->key, in_key, key_len);
107                 return 0;
108         }
109
110         return setkey_fallback_cip(tfm, in_key, key_len);
111 }
112
113 static void aes_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
114 {
115         const struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
116
117         if (unlikely(need_fallback(sctx->key_len))) {
118                 crypto_cipher_encrypt_one(sctx->fallback.cip, out, in);
119                 return;
120         }
121
122         switch (sctx->key_len) {
123         case 16:
124                 crypt_s390_km(KM_AES_128_ENCRYPT, &sctx->key, out, in,
125                               AES_BLOCK_SIZE);
126                 break;
127         case 24:
128                 crypt_s390_km(KM_AES_192_ENCRYPT, &sctx->key, out, in,
129                               AES_BLOCK_SIZE);
130                 break;
131         case 32:
132                 crypt_s390_km(KM_AES_256_ENCRYPT, &sctx->key, out, in,
133                               AES_BLOCK_SIZE);
134                 break;
135         }
136 }
137
138 static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
139 {
140         const struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
141
142         if (unlikely(need_fallback(sctx->key_len))) {
143                 crypto_cipher_decrypt_one(sctx->fallback.cip, out, in);
144                 return;
145         }
146
147         switch (sctx->key_len) {
148         case 16:
149                 crypt_s390_km(KM_AES_128_DECRYPT, &sctx->key, out, in,
150                               AES_BLOCK_SIZE);
151                 break;
152         case 24:
153                 crypt_s390_km(KM_AES_192_DECRYPT, &sctx->key, out, in,
154                               AES_BLOCK_SIZE);
155                 break;
156         case 32:
157                 crypt_s390_km(KM_AES_256_DECRYPT, &sctx->key, out, in,
158                               AES_BLOCK_SIZE);
159                 break;
160         }
161 }
162
163 static int fallback_init_cip(struct crypto_tfm *tfm)
164 {
165         const char *name = tfm->__crt_alg->cra_name;
166         struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
167
168         sctx->fallback.cip = crypto_alloc_cipher(name, 0,
169                         CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK);
170
171         if (IS_ERR(sctx->fallback.cip)) {
172                 printk(KERN_ERR "Error allocating fallback algo %s\n", name);
173                 return PTR_ERR(sctx->fallback.blk);
174         }
175
176         return 0;
177 }
178
179 static void fallback_exit_cip(struct crypto_tfm *tfm)
180 {
181         struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
182
183         crypto_free_cipher(sctx->fallback.cip);
184         sctx->fallback.cip = NULL;
185 }
186
187 static struct crypto_alg aes_alg = {
188         .cra_name               =       "aes",
189         .cra_driver_name        =       "aes-s390",
190         .cra_priority           =       CRYPT_S390_PRIORITY,
191         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER |
192                                         CRYPTO_ALG_NEED_FALLBACK,
193         .cra_blocksize          =       AES_BLOCK_SIZE,
194         .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
195         .cra_module             =       THIS_MODULE,
196         .cra_list               =       LIST_HEAD_INIT(aes_alg.cra_list),
197         .cra_init               =       fallback_init_cip,
198         .cra_exit               =       fallback_exit_cip,
199         .cra_u                  =       {
200                 .cipher = {
201                         .cia_min_keysize        =       AES_MIN_KEY_SIZE,
202                         .cia_max_keysize        =       AES_MAX_KEY_SIZE,
203                         .cia_setkey             =       aes_set_key,
204                         .cia_encrypt            =       aes_encrypt,
205                         .cia_decrypt            =       aes_decrypt,
206                 }
207         }
208 };
209
210 static int setkey_fallback_blk(struct crypto_tfm *tfm, const u8 *key,
211                 unsigned int len)
212 {
213         struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
214         unsigned int ret;
215
216         sctx->fallback.blk->base.crt_flags &= ~CRYPTO_TFM_REQ_MASK;
217         sctx->fallback.blk->base.crt_flags |= (tfm->crt_flags &
218                         CRYPTO_TFM_REQ_MASK);
219
220         ret = crypto_blkcipher_setkey(sctx->fallback.blk, key, len);
221         if (ret) {
222                 tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
223                 tfm->crt_flags |= (sctx->fallback.blk->base.crt_flags &
224                                 CRYPTO_TFM_RES_MASK);
225         }
226         return ret;
227 }
228
229 static int fallback_blk_dec(struct blkcipher_desc *desc,
230                 struct scatterlist *dst, struct scatterlist *src,
231                 unsigned int nbytes)
232 {
233         unsigned int ret;
234         struct crypto_blkcipher *tfm;
235         struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
236
237         memcpy(crypto_blkcipher_crt(sctx->fallback.blk)->iv, desc->info,
238                 AES_BLOCK_SIZE);
239
240         tfm = desc->tfm;
241         desc->tfm = sctx->fallback.blk;
242
243         ret = crypto_blkcipher_decrypt(desc, dst, src, nbytes);
244
245         desc->tfm = tfm;
246         return ret;
247 }
248
249 static int fallback_blk_enc(struct blkcipher_desc *desc,
250                 struct scatterlist *dst, struct scatterlist *src,
251                 unsigned int nbytes)
252 {
253         unsigned int ret;
254         struct crypto_blkcipher *tfm;
255         struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
256
257         memcpy(crypto_blkcipher_crt(sctx->fallback.blk)->iv, desc->info,
258                 AES_BLOCK_SIZE);
259
260         tfm = desc->tfm;
261         desc->tfm = sctx->fallback.blk;
262
263         ret = crypto_blkcipher_encrypt(desc, dst, src, nbytes);
264
265         desc->tfm = tfm;
266         return ret;
267 }
268
269 static int ecb_aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
270                            unsigned int key_len)
271 {
272         struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
273         int ret;
274
275         ret = need_fallback(key_len);
276         if (ret > 0) {
277                 sctx->key_len = key_len;
278                 return setkey_fallback_blk(tfm, in_key, key_len);
279         }
280
281         switch (key_len) {
282         case 16:
283                 sctx->enc = KM_AES_128_ENCRYPT;
284                 sctx->dec = KM_AES_128_DECRYPT;
285                 break;
286         case 24:
287                 sctx->enc = KM_AES_192_ENCRYPT;
288                 sctx->dec = KM_AES_192_DECRYPT;
289                 break;
290         case 32:
291                 sctx->enc = KM_AES_256_ENCRYPT;
292                 sctx->dec = KM_AES_256_DECRYPT;
293                 break;
294         }
295
296         return aes_set_key(tfm, in_key, key_len);
297 }
298
299 static int ecb_aes_crypt(struct blkcipher_desc *desc, long func, void *param,
300                          struct blkcipher_walk *walk)
301 {
302         int ret = blkcipher_walk_virt(desc, walk);
303         unsigned int nbytes;
304
305         while ((nbytes = walk->nbytes)) {
306                 /* only use complete blocks */
307                 unsigned int n = nbytes & ~(AES_BLOCK_SIZE - 1);
308                 u8 *out = walk->dst.virt.addr;
309                 u8 *in = walk->src.virt.addr;
310
311                 ret = crypt_s390_km(func, param, out, in, n);
312                 BUG_ON((ret < 0) || (ret != n));
313
314                 nbytes &= AES_BLOCK_SIZE - 1;
315                 ret = blkcipher_walk_done(desc, walk, nbytes);
316         }
317
318         return ret;
319 }
320
321 static int ecb_aes_encrypt(struct blkcipher_desc *desc,
322                            struct scatterlist *dst, struct scatterlist *src,
323                            unsigned int nbytes)
324 {
325         struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
326         struct blkcipher_walk walk;
327
328         if (unlikely(need_fallback(sctx->key_len)))
329                 return fallback_blk_enc(desc, dst, src, nbytes);
330
331         blkcipher_walk_init(&walk, dst, src, nbytes);
332         return ecb_aes_crypt(desc, sctx->enc, sctx->key, &walk);
333 }
334
335 static int ecb_aes_decrypt(struct blkcipher_desc *desc,
336                            struct scatterlist *dst, struct scatterlist *src,
337                            unsigned int nbytes)
338 {
339         struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
340         struct blkcipher_walk walk;
341
342         if (unlikely(need_fallback(sctx->key_len)))
343                 return fallback_blk_dec(desc, dst, src, nbytes);
344
345         blkcipher_walk_init(&walk, dst, src, nbytes);
346         return ecb_aes_crypt(desc, sctx->dec, sctx->key, &walk);
347 }
348
349 static int fallback_init_blk(struct crypto_tfm *tfm)
350 {
351         const char *name = tfm->__crt_alg->cra_name;
352         struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
353
354         sctx->fallback.blk = crypto_alloc_blkcipher(name, 0,
355                         CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK);
356
357         if (IS_ERR(sctx->fallback.blk)) {
358                 printk(KERN_ERR "Error allocating fallback algo %s\n", name);
359                 return PTR_ERR(sctx->fallback.blk);
360         }
361
362         return 0;
363 }
364
365 static void fallback_exit_blk(struct crypto_tfm *tfm)
366 {
367         struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
368
369         crypto_free_blkcipher(sctx->fallback.blk);
370         sctx->fallback.blk = NULL;
371 }
372
373 static struct crypto_alg ecb_aes_alg = {
374         .cra_name               =       "ecb(aes)",
375         .cra_driver_name        =       "ecb-aes-s390",
376         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
377         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER |
378                                         CRYPTO_ALG_NEED_FALLBACK,
379         .cra_blocksize          =       AES_BLOCK_SIZE,
380         .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
381         .cra_type               =       &crypto_blkcipher_type,
382         .cra_module             =       THIS_MODULE,
383         .cra_list               =       LIST_HEAD_INIT(ecb_aes_alg.cra_list),
384         .cra_init               =       fallback_init_blk,
385         .cra_exit               =       fallback_exit_blk,
386         .cra_u                  =       {
387                 .blkcipher = {
388                         .min_keysize            =       AES_MIN_KEY_SIZE,
389                         .max_keysize            =       AES_MAX_KEY_SIZE,
390                         .setkey                 =       ecb_aes_set_key,
391                         .encrypt                =       ecb_aes_encrypt,
392                         .decrypt                =       ecb_aes_decrypt,
393                 }
394         }
395 };
396
397 static int cbc_aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
398                            unsigned int key_len)
399 {
400         struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
401         int ret;
402
403         ret = need_fallback(key_len);
404         if (ret > 0) {
405                 sctx->key_len = key_len;
406                 return setkey_fallback_blk(tfm, in_key, key_len);
407         }
408
409         switch (key_len) {
410         case 16:
411                 sctx->enc = KMC_AES_128_ENCRYPT;
412                 sctx->dec = KMC_AES_128_DECRYPT;
413                 break;
414         case 24:
415                 sctx->enc = KMC_AES_192_ENCRYPT;
416                 sctx->dec = KMC_AES_192_DECRYPT;
417                 break;
418         case 32:
419                 sctx->enc = KMC_AES_256_ENCRYPT;
420                 sctx->dec = KMC_AES_256_DECRYPT;
421                 break;
422         }
423
424         return aes_set_key(tfm, in_key, key_len);
425 }
426
427 static int cbc_aes_crypt(struct blkcipher_desc *desc, long func, void *param,
428                          struct blkcipher_walk *walk)
429 {
430         int ret = blkcipher_walk_virt(desc, walk);
431         unsigned int nbytes = walk->nbytes;
432
433         if (!nbytes)
434                 goto out;
435
436         memcpy(param, walk->iv, AES_BLOCK_SIZE);
437         do {
438                 /* only use complete blocks */
439                 unsigned int n = nbytes & ~(AES_BLOCK_SIZE - 1);
440                 u8 *out = walk->dst.virt.addr;
441                 u8 *in = walk->src.virt.addr;
442
443                 ret = crypt_s390_kmc(func, param, out, in, n);
444                 BUG_ON((ret < 0) || (ret != n));
445
446                 nbytes &= AES_BLOCK_SIZE - 1;
447                 ret = blkcipher_walk_done(desc, walk, nbytes);
448         } while ((nbytes = walk->nbytes));
449         memcpy(walk->iv, param, AES_BLOCK_SIZE);
450
451 out:
452         return ret;
453 }
454
455 static int cbc_aes_encrypt(struct blkcipher_desc *desc,
456                            struct scatterlist *dst, struct scatterlist *src,
457                            unsigned int nbytes)
458 {
459         struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
460         struct blkcipher_walk walk;
461
462         if (unlikely(need_fallback(sctx->key_len)))
463                 return fallback_blk_enc(desc, dst, src, nbytes);
464
465         blkcipher_walk_init(&walk, dst, src, nbytes);
466         return cbc_aes_crypt(desc, sctx->enc, sctx->iv, &walk);
467 }
468
469 static int cbc_aes_decrypt(struct blkcipher_desc *desc,
470                            struct scatterlist *dst, struct scatterlist *src,
471                            unsigned int nbytes)
472 {
473         struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
474         struct blkcipher_walk walk;
475
476         if (unlikely(need_fallback(sctx->key_len)))
477                 return fallback_blk_dec(desc, dst, src, nbytes);
478
479         blkcipher_walk_init(&walk, dst, src, nbytes);
480         return cbc_aes_crypt(desc, sctx->dec, sctx->iv, &walk);
481 }
482
483 static struct crypto_alg cbc_aes_alg = {
484         .cra_name               =       "cbc(aes)",
485         .cra_driver_name        =       "cbc-aes-s390",
486         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
487         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER |
488                                         CRYPTO_ALG_NEED_FALLBACK,
489         .cra_blocksize          =       AES_BLOCK_SIZE,
490         .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
491         .cra_type               =       &crypto_blkcipher_type,
492         .cra_module             =       THIS_MODULE,
493         .cra_list               =       LIST_HEAD_INIT(cbc_aes_alg.cra_list),
494         .cra_init               =       fallback_init_blk,
495         .cra_exit               =       fallback_exit_blk,
496         .cra_u                  =       {
497                 .blkcipher = {
498                         .min_keysize            =       AES_MIN_KEY_SIZE,
499                         .max_keysize            =       AES_MAX_KEY_SIZE,
500                         .ivsize                 =       AES_BLOCK_SIZE,
501                         .setkey                 =       cbc_aes_set_key,
502                         .encrypt                =       cbc_aes_encrypt,
503                         .decrypt                =       cbc_aes_decrypt,
504                 }
505         }
506 };
507
508 static int __init aes_init(void)
509 {
510         int ret;
511
512         if (crypt_s390_func_available(KM_AES_128_ENCRYPT))
513                 keylen_flag |= AES_KEYLEN_128;
514         if (crypt_s390_func_available(KM_AES_192_ENCRYPT))
515                 keylen_flag |= AES_KEYLEN_192;
516         if (crypt_s390_func_available(KM_AES_256_ENCRYPT))
517                 keylen_flag |= AES_KEYLEN_256;
518
519         if (!keylen_flag)
520                 return -EOPNOTSUPP;
521
522         /* z9 109 and z9 BC/EC only support 128 bit key length */
523         if (keylen_flag == AES_KEYLEN_128)
524                 printk(KERN_INFO
525                        "aes_s390: hardware acceleration only available for"
526                        "128 bit keys\n");
527
528         ret = crypto_register_alg(&aes_alg);
529         if (ret)
530                 goto aes_err;
531
532         ret = crypto_register_alg(&ecb_aes_alg);
533         if (ret)
534                 goto ecb_aes_err;
535
536         ret = crypto_register_alg(&cbc_aes_alg);
537         if (ret)
538                 goto cbc_aes_err;
539
540 out:
541         return ret;
542
543 cbc_aes_err:
544         crypto_unregister_alg(&ecb_aes_alg);
545 ecb_aes_err:
546         crypto_unregister_alg(&aes_alg);
547 aes_err:
548         goto out;
549 }
550
551 static void __exit aes_fini(void)
552 {
553         crypto_unregister_alg(&cbc_aes_alg);
554         crypto_unregister_alg(&ecb_aes_alg);
555         crypto_unregister_alg(&aes_alg);
556 }
557
558 module_init(aes_init);
559 module_exit(aes_fini);
560
561 MODULE_ALIAS("aes");
562
563 MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");
564 MODULE_LICENSE("GPL");