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