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