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