Merge branch 'for-2.6.40/splice' of git://git.kernel.dk/linux-2.6-block
[pandora-kernel.git] / arch / s390 / crypto / des_s390.c
1 /*
2  * Cryptographic API.
3  *
4  * s390 implementation of the DES Cipher Algorithm.
5  *
6  * Copyright IBM Corp. 2003,2011
7  * Author(s): Thomas Spatzier
8  *            Jan Glauber (jan.glauber@de.ibm.com)
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  */
16
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/crypto.h>
20 #include <crypto/algapi.h>
21 #include <crypto/des.h>
22
23 #include "crypt_s390.h"
24
25 #define DES3_KEY_SIZE   (3 * DES_KEY_SIZE)
26
27 static u8 *ctrblk;
28
29 struct s390_des_ctx {
30         u8 iv[DES_BLOCK_SIZE];
31         u8 key[DES3_KEY_SIZE];
32 };
33
34 static int des_setkey(struct crypto_tfm *tfm, const u8 *key,
35                       unsigned int key_len)
36 {
37         struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
38         u32 *flags = &tfm->crt_flags;
39         u32 tmp[DES_EXPKEY_WORDS];
40
41         /* check for weak keys */
42         if (!des_ekey(tmp, key) && (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
43                 *flags |= CRYPTO_TFM_RES_WEAK_KEY;
44                 return -EINVAL;
45         }
46
47         memcpy(ctx->key, key, key_len);
48         return 0;
49 }
50
51 static void des_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
52 {
53         struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
54
55         crypt_s390_km(KM_DEA_ENCRYPT, ctx->key, out, in, DES_BLOCK_SIZE);
56 }
57
58 static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
59 {
60         struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
61
62         crypt_s390_km(KM_DEA_DECRYPT, ctx->key, out, in, DES_BLOCK_SIZE);
63 }
64
65 static struct crypto_alg des_alg = {
66         .cra_name               =       "des",
67         .cra_driver_name        =       "des-s390",
68         .cra_priority           =       CRYPT_S390_PRIORITY,
69         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
70         .cra_blocksize          =       DES_BLOCK_SIZE,
71         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
72         .cra_module             =       THIS_MODULE,
73         .cra_list               =       LIST_HEAD_INIT(des_alg.cra_list),
74         .cra_u                  =       {
75                 .cipher = {
76                         .cia_min_keysize        =       DES_KEY_SIZE,
77                         .cia_max_keysize        =       DES_KEY_SIZE,
78                         .cia_setkey             =       des_setkey,
79                         .cia_encrypt            =       des_encrypt,
80                         .cia_decrypt            =       des_decrypt,
81                 }
82         }
83 };
84
85 static int ecb_desall_crypt(struct blkcipher_desc *desc, long func,
86                             u8 *key, struct blkcipher_walk *walk)
87 {
88         int ret = blkcipher_walk_virt(desc, walk);
89         unsigned int nbytes;
90
91         while ((nbytes = walk->nbytes)) {
92                 /* only use complete blocks */
93                 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
94                 u8 *out = walk->dst.virt.addr;
95                 u8 *in = walk->src.virt.addr;
96
97                 ret = crypt_s390_km(func, key, out, in, n);
98                 BUG_ON((ret < 0) || (ret != n));
99
100                 nbytes &= DES_BLOCK_SIZE - 1;
101                 ret = blkcipher_walk_done(desc, walk, nbytes);
102         }
103
104         return ret;
105 }
106
107 static int cbc_desall_crypt(struct blkcipher_desc *desc, long func,
108                             u8 *iv, struct blkcipher_walk *walk)
109 {
110         int ret = blkcipher_walk_virt(desc, walk);
111         unsigned int nbytes = walk->nbytes;
112
113         if (!nbytes)
114                 goto out;
115
116         memcpy(iv, walk->iv, DES_BLOCK_SIZE);
117         do {
118                 /* only use complete blocks */
119                 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
120                 u8 *out = walk->dst.virt.addr;
121                 u8 *in = walk->src.virt.addr;
122
123                 ret = crypt_s390_kmc(func, iv, out, in, n);
124                 BUG_ON((ret < 0) || (ret != n));
125
126                 nbytes &= DES_BLOCK_SIZE - 1;
127                 ret = blkcipher_walk_done(desc, walk, nbytes);
128         } while ((nbytes = walk->nbytes));
129         memcpy(walk->iv, iv, DES_BLOCK_SIZE);
130
131 out:
132         return ret;
133 }
134
135 static int ecb_des_encrypt(struct blkcipher_desc *desc,
136                            struct scatterlist *dst, struct scatterlist *src,
137                            unsigned int nbytes)
138 {
139         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
140         struct blkcipher_walk walk;
141
142         blkcipher_walk_init(&walk, dst, src, nbytes);
143         return ecb_desall_crypt(desc, KM_DEA_ENCRYPT, ctx->key, &walk);
144 }
145
146 static int ecb_des_decrypt(struct blkcipher_desc *desc,
147                            struct scatterlist *dst, struct scatterlist *src,
148                            unsigned int nbytes)
149 {
150         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
151         struct blkcipher_walk walk;
152
153         blkcipher_walk_init(&walk, dst, src, nbytes);
154         return ecb_desall_crypt(desc, KM_DEA_DECRYPT, ctx->key, &walk);
155 }
156
157 static struct crypto_alg ecb_des_alg = {
158         .cra_name               =       "ecb(des)",
159         .cra_driver_name        =       "ecb-des-s390",
160         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
161         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
162         .cra_blocksize          =       DES_BLOCK_SIZE,
163         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
164         .cra_type               =       &crypto_blkcipher_type,
165         .cra_module             =       THIS_MODULE,
166         .cra_list               =       LIST_HEAD_INIT(ecb_des_alg.cra_list),
167         .cra_u                  =       {
168                 .blkcipher = {
169                         .min_keysize            =       DES_KEY_SIZE,
170                         .max_keysize            =       DES_KEY_SIZE,
171                         .setkey                 =       des_setkey,
172                         .encrypt                =       ecb_des_encrypt,
173                         .decrypt                =       ecb_des_decrypt,
174                 }
175         }
176 };
177
178 static int cbc_des_encrypt(struct blkcipher_desc *desc,
179                            struct scatterlist *dst, struct scatterlist *src,
180                            unsigned int nbytes)
181 {
182         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
183         struct blkcipher_walk walk;
184
185         blkcipher_walk_init(&walk, dst, src, nbytes);
186         return cbc_desall_crypt(desc, KMC_DEA_ENCRYPT, ctx->iv, &walk);
187 }
188
189 static int cbc_des_decrypt(struct blkcipher_desc *desc,
190                            struct scatterlist *dst, struct scatterlist *src,
191                            unsigned int nbytes)
192 {
193         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
194         struct blkcipher_walk walk;
195
196         blkcipher_walk_init(&walk, dst, src, nbytes);
197         return cbc_desall_crypt(desc, KMC_DEA_DECRYPT, ctx->iv, &walk);
198 }
199
200 static struct crypto_alg cbc_des_alg = {
201         .cra_name               =       "cbc(des)",
202         .cra_driver_name        =       "cbc-des-s390",
203         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
204         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
205         .cra_blocksize          =       DES_BLOCK_SIZE,
206         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
207         .cra_type               =       &crypto_blkcipher_type,
208         .cra_module             =       THIS_MODULE,
209         .cra_list               =       LIST_HEAD_INIT(cbc_des_alg.cra_list),
210         .cra_u                  =       {
211                 .blkcipher = {
212                         .min_keysize            =       DES_KEY_SIZE,
213                         .max_keysize            =       DES_KEY_SIZE,
214                         .ivsize                 =       DES_BLOCK_SIZE,
215                         .setkey                 =       des_setkey,
216                         .encrypt                =       cbc_des_encrypt,
217                         .decrypt                =       cbc_des_decrypt,
218                 }
219         }
220 };
221
222 /*
223  * RFC2451:
224  *
225  *   For DES-EDE3, there is no known need to reject weak or
226  *   complementation keys.  Any weakness is obviated by the use of
227  *   multiple keys.
228  *
229  *   However, if the first two or last two independent 64-bit keys are
230  *   equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the
231  *   same as DES.  Implementers MUST reject keys that exhibit this
232  *   property.
233  *
234  */
235 static int des3_setkey(struct crypto_tfm *tfm, const u8 *key,
236                        unsigned int key_len)
237 {
238         struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
239         u32 *flags = &tfm->crt_flags;
240
241         if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) &&
242             memcmp(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2],
243                    DES_KEY_SIZE)) &&
244             (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
245                 *flags |= CRYPTO_TFM_RES_WEAK_KEY;
246                 return -EINVAL;
247         }
248         memcpy(ctx->key, key, key_len);
249         return 0;
250 }
251
252 static void des3_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
253 {
254         struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
255
256         crypt_s390_km(KM_TDEA_192_ENCRYPT, ctx->key, dst, src, DES_BLOCK_SIZE);
257 }
258
259 static void des3_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
260 {
261         struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
262
263         crypt_s390_km(KM_TDEA_192_DECRYPT, ctx->key, dst, src, DES_BLOCK_SIZE);
264 }
265
266 static struct crypto_alg des3_alg = {
267         .cra_name               =       "des3_ede",
268         .cra_driver_name        =       "des3_ede-s390",
269         .cra_priority           =       CRYPT_S390_PRIORITY,
270         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
271         .cra_blocksize          =       DES_BLOCK_SIZE,
272         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
273         .cra_module             =       THIS_MODULE,
274         .cra_list               =       LIST_HEAD_INIT(des3_alg.cra_list),
275         .cra_u                  =       {
276                 .cipher = {
277                         .cia_min_keysize        =       DES3_KEY_SIZE,
278                         .cia_max_keysize        =       DES3_KEY_SIZE,
279                         .cia_setkey             =       des3_setkey,
280                         .cia_encrypt            =       des3_encrypt,
281                         .cia_decrypt            =       des3_decrypt,
282                 }
283         }
284 };
285
286 static int ecb_des3_encrypt(struct blkcipher_desc *desc,
287                             struct scatterlist *dst, struct scatterlist *src,
288                             unsigned int nbytes)
289 {
290         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
291         struct blkcipher_walk walk;
292
293         blkcipher_walk_init(&walk, dst, src, nbytes);
294         return ecb_desall_crypt(desc, KM_TDEA_192_ENCRYPT, ctx->key, &walk);
295 }
296
297 static int ecb_des3_decrypt(struct blkcipher_desc *desc,
298                             struct scatterlist *dst, struct scatterlist *src,
299                             unsigned int nbytes)
300 {
301         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
302         struct blkcipher_walk walk;
303
304         blkcipher_walk_init(&walk, dst, src, nbytes);
305         return ecb_desall_crypt(desc, KM_TDEA_192_DECRYPT, ctx->key, &walk);
306 }
307
308 static struct crypto_alg ecb_des3_alg = {
309         .cra_name               =       "ecb(des3_ede)",
310         .cra_driver_name        =       "ecb-des3_ede-s390",
311         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
312         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
313         .cra_blocksize          =       DES_BLOCK_SIZE,
314         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
315         .cra_type               =       &crypto_blkcipher_type,
316         .cra_module             =       THIS_MODULE,
317         .cra_list               =       LIST_HEAD_INIT(
318                                                 ecb_des3_alg.cra_list),
319         .cra_u                  =       {
320                 .blkcipher = {
321                         .min_keysize            =       DES3_KEY_SIZE,
322                         .max_keysize            =       DES3_KEY_SIZE,
323                         .setkey                 =       des3_setkey,
324                         .encrypt                =       ecb_des3_encrypt,
325                         .decrypt                =       ecb_des3_decrypt,
326                 }
327         }
328 };
329
330 static int cbc_des3_encrypt(struct blkcipher_desc *desc,
331                             struct scatterlist *dst, struct scatterlist *src,
332                             unsigned int nbytes)
333 {
334         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
335         struct blkcipher_walk walk;
336
337         blkcipher_walk_init(&walk, dst, src, nbytes);
338         return cbc_desall_crypt(desc, KMC_TDEA_192_ENCRYPT, ctx->iv, &walk);
339 }
340
341 static int cbc_des3_decrypt(struct blkcipher_desc *desc,
342                             struct scatterlist *dst, struct scatterlist *src,
343                             unsigned int nbytes)
344 {
345         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
346         struct blkcipher_walk walk;
347
348         blkcipher_walk_init(&walk, dst, src, nbytes);
349         return cbc_desall_crypt(desc, KMC_TDEA_192_DECRYPT, ctx->iv, &walk);
350 }
351
352 static struct crypto_alg cbc_des3_alg = {
353         .cra_name               =       "cbc(des3_ede)",
354         .cra_driver_name        =       "cbc-des3_ede-s390",
355         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
356         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
357         .cra_blocksize          =       DES_BLOCK_SIZE,
358         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
359         .cra_type               =       &crypto_blkcipher_type,
360         .cra_module             =       THIS_MODULE,
361         .cra_list               =       LIST_HEAD_INIT(
362                                                 cbc_des3_alg.cra_list),
363         .cra_u                  =       {
364                 .blkcipher = {
365                         .min_keysize            =       DES3_KEY_SIZE,
366                         .max_keysize            =       DES3_KEY_SIZE,
367                         .ivsize                 =       DES_BLOCK_SIZE,
368                         .setkey                 =       des3_setkey,
369                         .encrypt                =       cbc_des3_encrypt,
370                         .decrypt                =       cbc_des3_decrypt,
371                 }
372         }
373 };
374
375 static int ctr_desall_crypt(struct blkcipher_desc *desc, long func,
376                             struct s390_des_ctx *ctx, struct blkcipher_walk *walk)
377 {
378         int ret = blkcipher_walk_virt_block(desc, walk, DES_BLOCK_SIZE);
379         unsigned int i, n, nbytes;
380         u8 buf[DES_BLOCK_SIZE];
381         u8 *out, *in;
382
383         memcpy(ctrblk, walk->iv, DES_BLOCK_SIZE);
384         while ((nbytes = walk->nbytes) >= DES_BLOCK_SIZE) {
385                 out = walk->dst.virt.addr;
386                 in = walk->src.virt.addr;
387                 while (nbytes >= DES_BLOCK_SIZE) {
388                         /* align to block size, max. PAGE_SIZE */
389                         n = (nbytes > PAGE_SIZE) ? PAGE_SIZE :
390                                 nbytes & ~(DES_BLOCK_SIZE - 1);
391                         for (i = DES_BLOCK_SIZE; i < n; i += DES_BLOCK_SIZE) {
392                                 memcpy(ctrblk + i, ctrblk + i - DES_BLOCK_SIZE,
393                                        DES_BLOCK_SIZE);
394                                 crypto_inc(ctrblk + i, DES_BLOCK_SIZE);
395                         }
396                         ret = crypt_s390_kmctr(func, ctx->key, out, in, n, ctrblk);
397                         BUG_ON((ret < 0) || (ret != n));
398                         if (n > DES_BLOCK_SIZE)
399                                 memcpy(ctrblk, ctrblk + n - DES_BLOCK_SIZE,
400                                        DES_BLOCK_SIZE);
401                         crypto_inc(ctrblk, DES_BLOCK_SIZE);
402                         out += n;
403                         in += n;
404                         nbytes -= n;
405                 }
406                 ret = blkcipher_walk_done(desc, walk, nbytes);
407         }
408
409         /* final block may be < DES_BLOCK_SIZE, copy only nbytes */
410         if (nbytes) {
411                 out = walk->dst.virt.addr;
412                 in = walk->src.virt.addr;
413                 ret = crypt_s390_kmctr(func, ctx->key, buf, in,
414                                        DES_BLOCK_SIZE, ctrblk);
415                 BUG_ON(ret < 0 || ret != DES_BLOCK_SIZE);
416                 memcpy(out, buf, nbytes);
417                 crypto_inc(ctrblk, DES_BLOCK_SIZE);
418                 ret = blkcipher_walk_done(desc, walk, 0);
419         }
420         memcpy(walk->iv, ctrblk, DES_BLOCK_SIZE);
421         return ret;
422 }
423
424 static int ctr_des_encrypt(struct blkcipher_desc *desc,
425                            struct scatterlist *dst, struct scatterlist *src,
426                            unsigned int nbytes)
427 {
428         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
429         struct blkcipher_walk walk;
430
431         blkcipher_walk_init(&walk, dst, src, nbytes);
432         return ctr_desall_crypt(desc, KMCTR_DEA_ENCRYPT, ctx, &walk);
433 }
434
435 static int ctr_des_decrypt(struct blkcipher_desc *desc,
436                            struct scatterlist *dst, struct scatterlist *src,
437                            unsigned int nbytes)
438 {
439         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
440         struct blkcipher_walk walk;
441
442         blkcipher_walk_init(&walk, dst, src, nbytes);
443         return ctr_desall_crypt(desc, KMCTR_DEA_DECRYPT, ctx, &walk);
444 }
445
446 static struct crypto_alg ctr_des_alg = {
447         .cra_name               =       "ctr(des)",
448         .cra_driver_name        =       "ctr-des-s390",
449         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
450         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
451         .cra_blocksize          =       1,
452         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
453         .cra_type               =       &crypto_blkcipher_type,
454         .cra_module             =       THIS_MODULE,
455         .cra_list               =       LIST_HEAD_INIT(ctr_des_alg.cra_list),
456         .cra_u                  =       {
457                 .blkcipher = {
458                         .min_keysize            =       DES_KEY_SIZE,
459                         .max_keysize            =       DES_KEY_SIZE,
460                         .ivsize                 =       DES_BLOCK_SIZE,
461                         .setkey                 =       des_setkey,
462                         .encrypt                =       ctr_des_encrypt,
463                         .decrypt                =       ctr_des_decrypt,
464                 }
465         }
466 };
467
468 static int ctr_des3_encrypt(struct blkcipher_desc *desc,
469                             struct scatterlist *dst, struct scatterlist *src,
470                             unsigned int nbytes)
471 {
472         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
473         struct blkcipher_walk walk;
474
475         blkcipher_walk_init(&walk, dst, src, nbytes);
476         return ctr_desall_crypt(desc, KMCTR_TDEA_192_ENCRYPT, ctx, &walk);
477 }
478
479 static int ctr_des3_decrypt(struct blkcipher_desc *desc,
480                             struct scatterlist *dst, struct scatterlist *src,
481                             unsigned int nbytes)
482 {
483         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
484         struct blkcipher_walk walk;
485
486         blkcipher_walk_init(&walk, dst, src, nbytes);
487         return ctr_desall_crypt(desc, KMCTR_TDEA_192_DECRYPT, ctx, &walk);
488 }
489
490 static struct crypto_alg ctr_des3_alg = {
491         .cra_name               =       "ctr(des3_ede)",
492         .cra_driver_name        =       "ctr-des3_ede-s390",
493         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
494         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
495         .cra_blocksize          =       1,
496         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
497         .cra_type               =       &crypto_blkcipher_type,
498         .cra_module             =       THIS_MODULE,
499         .cra_list               =       LIST_HEAD_INIT(ctr_des3_alg.cra_list),
500         .cra_u                  =       {
501                 .blkcipher = {
502                         .min_keysize            =       DES3_KEY_SIZE,
503                         .max_keysize            =       DES3_KEY_SIZE,
504                         .ivsize                 =       DES_BLOCK_SIZE,
505                         .setkey                 =       des3_setkey,
506                         .encrypt                =       ctr_des3_encrypt,
507                         .decrypt                =       ctr_des3_decrypt,
508                 }
509         }
510 };
511
512 static int __init des_s390_init(void)
513 {
514         int ret;
515
516         if (!crypt_s390_func_available(KM_DEA_ENCRYPT, CRYPT_S390_MSA) ||
517             !crypt_s390_func_available(KM_TDEA_192_ENCRYPT, CRYPT_S390_MSA))
518                 return -EOPNOTSUPP;
519
520         ret = crypto_register_alg(&des_alg);
521         if (ret)
522                 goto des_err;
523         ret = crypto_register_alg(&ecb_des_alg);
524         if (ret)
525                 goto ecb_des_err;
526         ret = crypto_register_alg(&cbc_des_alg);
527         if (ret)
528                 goto cbc_des_err;
529         ret = crypto_register_alg(&des3_alg);
530         if (ret)
531                 goto des3_err;
532         ret = crypto_register_alg(&ecb_des3_alg);
533         if (ret)
534                 goto ecb_des3_err;
535         ret = crypto_register_alg(&cbc_des3_alg);
536         if (ret)
537                 goto cbc_des3_err;
538
539         if (crypt_s390_func_available(KMCTR_DEA_ENCRYPT,
540                         CRYPT_S390_MSA | CRYPT_S390_MSA4) &&
541             crypt_s390_func_available(KMCTR_TDEA_192_ENCRYPT,
542                         CRYPT_S390_MSA | CRYPT_S390_MSA4)) {
543                 ret = crypto_register_alg(&ctr_des_alg);
544                 if (ret)
545                         goto ctr_des_err;
546                 ret = crypto_register_alg(&ctr_des3_alg);
547                 if (ret)
548                         goto ctr_des3_err;
549                 ctrblk = (u8 *) __get_free_page(GFP_KERNEL);
550                 if (!ctrblk) {
551                         ret = -ENOMEM;
552                         goto ctr_mem_err;
553                 }
554         }
555 out:
556         return ret;
557
558 ctr_mem_err:
559         crypto_unregister_alg(&ctr_des3_alg);
560 ctr_des3_err:
561         crypto_unregister_alg(&ctr_des_alg);
562 ctr_des_err:
563         crypto_unregister_alg(&cbc_des3_alg);
564 cbc_des3_err:
565         crypto_unregister_alg(&ecb_des3_alg);
566 ecb_des3_err:
567         crypto_unregister_alg(&des3_alg);
568 des3_err:
569         crypto_unregister_alg(&cbc_des_alg);
570 cbc_des_err:
571         crypto_unregister_alg(&ecb_des_alg);
572 ecb_des_err:
573         crypto_unregister_alg(&des_alg);
574 des_err:
575         goto out;
576 }
577
578 static void __exit des_s390_exit(void)
579 {
580         if (ctrblk) {
581                 crypto_unregister_alg(&ctr_des_alg);
582                 crypto_unregister_alg(&ctr_des3_alg);
583                 free_page((unsigned long) ctrblk);
584         }
585         crypto_unregister_alg(&cbc_des3_alg);
586         crypto_unregister_alg(&ecb_des3_alg);
587         crypto_unregister_alg(&des3_alg);
588         crypto_unregister_alg(&cbc_des_alg);
589         crypto_unregister_alg(&ecb_des_alg);
590         crypto_unregister_alg(&des_alg);
591 }
592
593 module_init(des_s390_init);
594 module_exit(des_s390_exit);
595
596 MODULE_ALIAS("des");
597 MODULE_ALIAS("des3_ede");
598
599 MODULE_LICENSE("GPL");
600 MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms");