?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: hv: mousevsc: Change the allocation flags to reflect interrupt context
[zen-stable.git] / arch / s390 / crypto / des_s390.c
bloba52bfd124d86e009184c8326a9e1b03bfeedf76e
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");