Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/crypto-2.6

diff --git a/arch/s390/crypto/Makefile b/arch/s390/crypto/Makefile
index 6a1157f..1cf81d7 100644 (file)
--- a/arch/s390/crypto/Makefile
+++ b/arch/s390/crypto/Makefile
@@ -5,6 +5,6 @@
 obj-$(CONFIG_CRYPTO_SHA1_S390) += sha1_s390.o sha_common.o
 obj-$(CONFIG_CRYPTO_SHA256_S390) += sha256_s390.o sha_common.o
 obj-$(CONFIG_CRYPTO_SHA512_S390) += sha512_s390.o sha_common.o
-obj-$(CONFIG_CRYPTO_DES_S390) += des_s390.o des_check_key.o
+obj-$(CONFIG_CRYPTO_DES_S390) += des_s390.o
 obj-$(CONFIG_CRYPTO_AES_S390) += aes_s390.o
 obj-$(CONFIG_S390_PRNG) += prng.o

diff --git a/arch/s390/crypto/crypto_des.h b/arch/s390/crypto/crypto_des.h
index c964b64..6210457 100644 (file)
--- a/arch/s390/crypto/crypto_des.h
+++ b/arch/s390/crypto/crypto_des.h
@@ -15,4 +15,4 @@
 
 extern int crypto_des_check_key(const u8*, unsigned int, u32*);
 
-#endif //__CRYPTO_DES_H__
+#endif /*__CRYPTO_DES_H__*/

diff --git a/arch/s390/crypto/des_s390.c b/arch/s390/crypto/des_s390.c
index 2bc479a..cc54201 100644 (file)
--- a/arch/s390/crypto/des_s390.c
+++ b/arch/s390/crypto/des_s390.c
@@ -14,32 +14,21 @@
  *
  */
 
-#include <crypto/algapi.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/crypto.h>
+#include <crypto/algapi.h>
+#include <crypto/des.h>
 
 #include "crypt_s390.h"
-#include "crypto_des.h"
-
-#define DES_BLOCK_SIZE 8
-#define DES_KEY_SIZE 8
-
-#define DES3_128_KEY_SIZE      (2 * DES_KEY_SIZE)
-#define DES3_128_BLOCK_SIZE    DES_BLOCK_SIZE
 
 #define DES3_192_KEY_SIZE      (3 * DES_KEY_SIZE)
-#define DES3_192_BLOCK_SIZE    DES_BLOCK_SIZE
 
 struct crypt_s390_des_ctx {
        u8 iv[DES_BLOCK_SIZE];
        u8 key[DES_KEY_SIZE];
 };
 
-struct crypt_s390_des3_128_ctx {
-       u8 iv[DES_BLOCK_SIZE];
-       u8 key[DES3_128_KEY_SIZE];
-};
-
 struct crypt_s390_des3_192_ctx {
        u8 iv[DES_BLOCK_SIZE];
        u8 key[DES3_192_KEY_SIZE];
@@ -50,13 +39,16 @@ static int des_setkey(struct crypto_tfm *tfm, const u8 *key,
 {
        struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm);
        u32 *flags = &tfm->crt_flags;
-       int ret;
+       u32 tmp[DES_EXPKEY_WORDS];
 
-       /* test if key is valid (not a weak key) */
-       ret = crypto_des_check_key(key, keylen, flags);
-       if (ret == 0)
-               memcpy(dctx->key, key, keylen);
-       return ret;
+       /* check for weak keys */
+       if (!des_ekey(tmp, key) && (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
+               *flags |= CRYPTO_TFM_RES_WEAK_KEY;
+               return -EINVAL;
+       }
+
+       memcpy(dctx->key, key, keylen);
+       return 0;
 }
 
 static void des_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
@@ -237,165 +229,6 @@ static struct crypto_alg cbc_des_alg = {
  *   complementation keys.  Any weakness is obviated by the use of
  *   multiple keys.
  *
- *   However, if the two  independent 64-bit keys are equal,
- *   then the DES3 operation is simply the same as DES.
- *   Implementers MUST reject keys that exhibit this property.
- *
- */
-static int des3_128_setkey(struct crypto_tfm *tfm, const u8 *key,
-                          unsigned int keylen)
-{
-       int i, ret;
-       struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm);
-       const u8 *temp_key = key;
-       u32 *flags = &tfm->crt_flags;
-
-       if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE)) &&
-           (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
-               *flags |= CRYPTO_TFM_RES_WEAK_KEY;
-               return -EINVAL;
-       }
-       for (i = 0; i < 2; i++, temp_key += DES_KEY_SIZE) {
-               ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags);
-               if (ret < 0)
-                       return ret;
-       }
-       memcpy(dctx->key, key, keylen);
-       return 0;
-}
-
-static void des3_128_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
-{
-       struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm);
-
-       crypt_s390_km(KM_TDEA_128_ENCRYPT, dctx->key, dst, (void*)src,
-                     DES3_128_BLOCK_SIZE);
-}
-
-static void des3_128_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
-{
-       struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm);
-
-       crypt_s390_km(KM_TDEA_128_DECRYPT, dctx->key, dst, (void*)src,
-                     DES3_128_BLOCK_SIZE);
-}
-
-static struct crypto_alg des3_128_alg = {
-       .cra_name               =       "des3_ede128",
-       .cra_driver_name        =       "des3_ede128-s390",
-       .cra_priority           =       CRYPT_S390_PRIORITY,
-       .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
-       .cra_blocksize          =       DES3_128_BLOCK_SIZE,
-       .cra_ctxsize            =       sizeof(struct crypt_s390_des3_128_ctx),
-       .cra_module             =       THIS_MODULE,
-       .cra_list               =       LIST_HEAD_INIT(des3_128_alg.cra_list),
-       .cra_u                  =       {
-               .cipher = {
-                       .cia_min_keysize        =       DES3_128_KEY_SIZE,
-                       .cia_max_keysize        =       DES3_128_KEY_SIZE,
-                       .cia_setkey             =       des3_128_setkey,
-                       .cia_encrypt            =       des3_128_encrypt,
-                       .cia_decrypt            =       des3_128_decrypt,
-               }
-       }
-};
-
-static int ecb_des3_128_encrypt(struct blkcipher_desc *desc,
-                               struct scatterlist *dst,
-                               struct scatterlist *src, unsigned int nbytes)
-{
-       struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
-       struct blkcipher_walk walk;
-
-       blkcipher_walk_init(&walk, dst, src, nbytes);
-       return ecb_desall_crypt(desc, KM_TDEA_128_ENCRYPT, sctx->key, &walk);
-}
-
-static int ecb_des3_128_decrypt(struct blkcipher_desc *desc,
-                               struct scatterlist *dst,
-                               struct scatterlist *src, unsigned int nbytes)
-{
-       struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
-       struct blkcipher_walk walk;
-
-       blkcipher_walk_init(&walk, dst, src, nbytes);
-       return ecb_desall_crypt(desc, KM_TDEA_128_DECRYPT, sctx->key, &walk);
-}
-
-static struct crypto_alg ecb_des3_128_alg = {
-       .cra_name               =       "ecb(des3_ede128)",
-       .cra_driver_name        =       "ecb-des3_ede128-s390",
-       .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
-       .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
-       .cra_blocksize          =       DES3_128_BLOCK_SIZE,
-       .cra_ctxsize            =       sizeof(struct crypt_s390_des3_128_ctx),
-       .cra_type               =       &crypto_blkcipher_type,
-       .cra_module             =       THIS_MODULE,
-       .cra_list               =       LIST_HEAD_INIT(
-                                               ecb_des3_128_alg.cra_list),
-       .cra_u                  =       {
-               .blkcipher = {
-                       .min_keysize            =       DES3_128_KEY_SIZE,
-                       .max_keysize            =       DES3_128_KEY_SIZE,
-                       .setkey                 =       des3_128_setkey,
-                       .encrypt                =       ecb_des3_128_encrypt,
-                       .decrypt                =       ecb_des3_128_decrypt,
-               }
-       }
-};
-
-static int cbc_des3_128_encrypt(struct blkcipher_desc *desc,
-                               struct scatterlist *dst,
-                               struct scatterlist *src, unsigned int nbytes)
-{
-       struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
-       struct blkcipher_walk walk;
-
-       blkcipher_walk_init(&walk, dst, src, nbytes);
-       return cbc_desall_crypt(desc, KMC_TDEA_128_ENCRYPT, sctx->iv, &walk);
-}
-
-static int cbc_des3_128_decrypt(struct blkcipher_desc *desc,
-                               struct scatterlist *dst,
-                               struct scatterlist *src, unsigned int nbytes)
-{
-       struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
-       struct blkcipher_walk walk;
-
-       blkcipher_walk_init(&walk, dst, src, nbytes);
-       return cbc_desall_crypt(desc, KMC_TDEA_128_DECRYPT, sctx->iv, &walk);
-}
-
-static struct crypto_alg cbc_des3_128_alg = {
-       .cra_name               =       "cbc(des3_ede128)",
-       .cra_driver_name        =       "cbc-des3_ede128-s390",
-       .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
-       .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
-       .cra_blocksize          =       DES3_128_BLOCK_SIZE,
-       .cra_ctxsize            =       sizeof(struct crypt_s390_des3_128_ctx),
-       .cra_type               =       &crypto_blkcipher_type,
-       .cra_module             =       THIS_MODULE,
-       .cra_list               =       LIST_HEAD_INIT(
-                                               cbc_des3_128_alg.cra_list),
-       .cra_u                  =       {
-               .blkcipher = {
-                       .min_keysize            =       DES3_128_KEY_SIZE,
-                       .max_keysize            =       DES3_128_KEY_SIZE,
-                       .ivsize                 =       DES3_128_BLOCK_SIZE,
-                       .setkey                 =       des3_128_setkey,
-                       .encrypt                =       cbc_des3_128_encrypt,
-                       .decrypt                =       cbc_des3_128_decrypt,
-               }
-       }
-};
-
-/*
- * RFC2451:
- *
- *   For DES-EDE3, there is no known need to reject weak or
- *   complementation keys.  Any weakness is obviated by the use of
- *   multiple keys.
- *
  *   However, if the first two or last two independent 64-bit keys are
  *   equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the
  *   same as DES.  Implementers MUST reject keys that exhibit this
@@ -405,9 +238,7 @@ static struct crypto_alg cbc_des3_128_alg = {
 static int des3_192_setkey(struct crypto_tfm *tfm, const u8 *key,
                           unsigned int keylen)
 {
-       int i, ret;
        struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm);
-       const u8 *temp_key = key;
        u32 *flags = &tfm->crt_flags;
 
        if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) &&
@@ -417,11 +248,6 @@ static int des3_192_setkey(struct crypto_tfm *tfm, const u8 *key,
                *flags |= CRYPTO_TFM_RES_WEAK_KEY;
                return -EINVAL;
        }
-       for (i = 0; i < 3; i++, temp_key += DES_KEY_SIZE) {
-               ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags);
-               if (ret < 0)
-                       return ret;
-       }
        memcpy(dctx->key, key, keylen);
        return 0;
 }
@@ -431,7 +257,7 @@ static void des3_192_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
        struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm);
 
        crypt_s390_km(KM_TDEA_192_ENCRYPT, dctx->key, dst, (void*)src,
-                     DES3_192_BLOCK_SIZE);
+                     DES_BLOCK_SIZE);
 }
 
 static void des3_192_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
@@ -439,7 +265,7 @@ static void des3_192_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
        struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm);
 
        crypt_s390_km(KM_TDEA_192_DECRYPT, dctx->key, dst, (void*)src,
-                     DES3_192_BLOCK_SIZE);
+                     DES_BLOCK_SIZE);
 }
 
 static struct crypto_alg des3_192_alg = {
@@ -447,7 +273,7 @@ static struct crypto_alg des3_192_alg = {
        .cra_driver_name        =       "des3_ede-s390",
        .cra_priority           =       CRYPT_S390_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
-       .cra_blocksize          =       DES3_192_BLOCK_SIZE,
+       .cra_blocksize          =       DES_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_192_ctx),
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(des3_192_alg.cra_list),
@@ -489,7 +315,7 @@ static struct crypto_alg ecb_des3_192_alg = {
        .cra_driver_name        =       "ecb-des3_ede-s390",
        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
-       .cra_blocksize          =       DES3_192_BLOCK_SIZE,
+       .cra_blocksize          =       DES_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_192_ctx),
        .cra_type               =       &crypto_blkcipher_type,
        .cra_module             =       THIS_MODULE,
@@ -533,7 +359,7 @@ static struct crypto_alg cbc_des3_192_alg = {
        .cra_driver_name        =       "cbc-des3_ede-s390",
        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
-       .cra_blocksize          =       DES3_192_BLOCK_SIZE,
+       .cra_blocksize          =       DES_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_192_ctx),
        .cra_type               =       &crypto_blkcipher_type,
        .cra_module             =       THIS_MODULE,
@@ -543,7 +369,7 @@ static struct crypto_alg cbc_des3_192_alg = {
                .blkcipher = {
                        .min_keysize            =       DES3_192_KEY_SIZE,
                        .max_keysize            =       DES3_192_KEY_SIZE,
-                       .ivsize                 =       DES3_192_BLOCK_SIZE,
+                       .ivsize                 =       DES_BLOCK_SIZE,
                        .setkey                 =       des3_192_setkey,
                        .encrypt                =       cbc_des3_192_encrypt,
                        .decrypt                =       cbc_des3_192_decrypt,
@@ -553,10 +379,9 @@ static struct crypto_alg cbc_des3_192_alg = {
 
 static int des_s390_init(void)
 {
-       int ret = 0;
+       int ret;
 
        if (!crypt_s390_func_available(KM_DEA_ENCRYPT) ||
-           !crypt_s390_func_available(KM_TDEA_128_ENCRYPT) ||
            !crypt_s390_func_available(KM_TDEA_192_ENCRYPT))
                return -EOPNOTSUPP;
 
@@ -569,17 +394,6 @@ static int des_s390_init(void)
        ret = crypto_register_alg(&cbc_des_alg);
        if (ret)
                goto cbc_des_err;
-
-       ret = crypto_register_alg(&des3_128_alg);
-       if (ret)
-               goto des3_128_err;
-       ret = crypto_register_alg(&ecb_des3_128_alg);
-       if (ret)
-               goto ecb_des3_128_err;
-       ret = crypto_register_alg(&cbc_des3_128_alg);
-       if (ret)
-               goto cbc_des3_128_err;
-
        ret = crypto_register_alg(&des3_192_alg);
        if (ret)
                goto des3_192_err;
@@ -589,7 +403,6 @@ static int des_s390_init(void)
        ret = crypto_register_alg(&cbc_des3_192_alg);
        if (ret)
                goto cbc_des3_192_err;
-
 out:
        return ret;
 
@@ -598,12 +411,6 @@ cbc_des3_192_err:
 ecb_des3_192_err:
        crypto_unregister_alg(&des3_192_alg);
 des3_192_err:
-       crypto_unregister_alg(&cbc_des3_128_alg);
-cbc_des3_128_err:
-       crypto_unregister_alg(&ecb_des3_128_alg);
-ecb_des3_128_err:
-       crypto_unregister_alg(&des3_128_alg);
-des3_128_err:
        crypto_unregister_alg(&cbc_des_alg);
 cbc_des_err:
        crypto_unregister_alg(&ecb_des_alg);
@@ -613,21 +420,18 @@ des_err:
        goto out;
 }
 
-static void __exit des_s390_fini(void)
+static void __exit des_s390_exit(void)
 {
        crypto_unregister_alg(&cbc_des3_192_alg);
        crypto_unregister_alg(&ecb_des3_192_alg);
        crypto_unregister_alg(&des3_192_alg);
-       crypto_unregister_alg(&cbc_des3_128_alg);
-       crypto_unregister_alg(&ecb_des3_128_alg);
-       crypto_unregister_alg(&des3_128_alg);
        crypto_unregister_alg(&cbc_des_alg);
        crypto_unregister_alg(&ecb_des_alg);
        crypto_unregister_alg(&des_alg);
 }
 
 module_init(des_s390_init);
-module_exit(des_s390_fini);
+module_exit(des_s390_exit);
 
 MODULE_ALIAS("des");
 MODULE_ALIAS("des3_ede");

diff --git a/crypto/authenc.c b/crypto/authenc.c
index b9884ee..a5a22cf 100644 (file)
--- a/crypto/authenc.c
+++ b/crypto/authenc.c
@@ -616,7 +616,7 @@ static struct crypto_instance *crypto_authenc_alloc(struct rtattr **tb)
        auth = ahash_attr_alg(tb[1], CRYPTO_ALG_TYPE_HASH,
                               CRYPTO_ALG_TYPE_AHASH_MASK);
        if (IS_ERR(auth))
-               return ERR_PTR(PTR_ERR(auth));
+               return ERR_CAST(auth);
 
        auth_base = &auth->base;
 

diff --git a/crypto/ctr.c b/crypto/ctr.c
index 6c3bfab..4ca7222 100644 (file)
--- a/crypto/ctr.c
+++ b/crypto/ctr.c
@@ -185,7 +185,7 @@ static struct crypto_instance *crypto_ctr_alloc(struct rtattr **tb)
        alg = crypto_attr_alg(tb[1], CRYPTO_ALG_TYPE_CIPHER,
                                  CRYPTO_ALG_TYPE_MASK);
        if (IS_ERR(alg))
-               return ERR_PTR(PTR_ERR(alg));
+               return ERR_CAST(alg);
 
        /* Block size must be >= 4 bytes. */
        err = -EINVAL;

diff --git a/crypto/xts.c b/crypto/xts.c
index d87b0f3..555ecaa 100644 (file)
--- a/crypto/xts.c
+++ b/crypto/xts.c
@@ -224,7 +224,7 @@ static struct crypto_instance *alloc(struct rtattr **tb)
        alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER,
                                  CRYPTO_ALG_TYPE_MASK);
        if (IS_ERR(alg))
-               return ERR_PTR(PTR_ERR(alg));
+               return ERR_CAST(alg);
 
        inst = crypto_alloc_instance("xts", alg);
        if (IS_ERR(inst))

diff --git a/drivers/crypto/mv_cesa.c b/drivers/crypto/mv_cesa.c
index e095422..7d279e5 100644 (file)
--- a/drivers/crypto/mv_cesa.c
+++ b/drivers/crypto/mv_cesa.c
@@ -1055,20 +1055,20 @@ static int mv_probe(struct platform_device *pdev)
        cp->queue_th = kthread_run(queue_manag, cp, "mv_crypto");
        if (IS_ERR(cp->queue_th)) {
                ret = PTR_ERR(cp->queue_th);
-               goto err_thread;
+               goto err_unmap_sram;
        }
 
        ret = request_irq(irq, crypto_int, IRQF_DISABLED, dev_name(&pdev->dev),
                        cp);
        if (ret)
-               goto err_unmap_sram;
+               goto err_thread;
 
        writel(SEC_INT_ACCEL0_DONE, cpg->reg + SEC_ACCEL_INT_MASK);
        writel(SEC_CFG_STOP_DIG_ERR, cpg->reg + SEC_ACCEL_CFG);
 
        ret = crypto_register_alg(&mv_aes_alg_ecb);
        if (ret)
-               goto err_reg;
+               goto err_irq;
 
        ret = crypto_register_alg(&mv_aes_alg_cbc);
        if (ret)
@@ -1091,9 +1091,9 @@ static int mv_probe(struct platform_device *pdev)
        return 0;
 err_unreg_ecb:
        crypto_unregister_alg(&mv_aes_alg_ecb);
-err_thread:
+err_irq:
        free_irq(irq, cp);
-err_reg:
+err_thread:
        kthread_stop(cp->queue_th);
 err_unmap_sram:
        iounmap(cp->sram);

diff --git a/drivers/crypto/omap-sham.c b/drivers/crypto/omap-sham.c
index 8b03433..7d14856 100644 (file)
--- a/drivers/crypto/omap-sham.c
+++ b/drivers/crypto/omap-sham.c
@@ -15,7 +15,6 @@
 
 #define pr_fmt(fmt) "%s: " fmt, __func__
 
-#include <linux/version.h>
 #include <linux/err.h>
 #include <linux/device.h>
 #include <linux/module.h>