Patched in Tegra support.

8 files changed, 45 insertions, 52 deletions

diff --git a/arch/s390/crypto/aes_s390.c b/arch/s390/crypto/aes_s390.c
index b4dbade8ca2..a9ce135893f 100644
--- a/arch/s390/crypto/aes_s390.c
+++ b/arch/s390/crypto/aes_s390.c
@@ -4,7 +4,7 @@
  * s390 implementation of the AES Cipher Algorithm.
  *
  * s390 Version:
- *   Copyright IBM Corp. 2005, 2007
+ *   Copyright IBM Corp. 2005,2007
  *   Author(s): Jan Glauber (jang@de.ibm.com)
  *              Sebastian Siewior (sebastian@breakpoint.cc> SW-Fallback
  *
@@ -216,6 +216,7 @@ static struct crypto_alg aes_alg = {
         .cra_blocksize          =       AES_BLOCK_SIZE,
         .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(aes_alg.cra_list),
         .cra_init               =       fallback_init_cip,
         .cra_exit               =       fallback_exit_cip,
         .cra_u                  =       {
@@ -325,8 +326,7 @@ static int ecb_aes_crypt(struct blkcipher_desc *desc, long func, void *param,
                 u8 *in = walk->src.virt.addr;
 
                 ret = crypt_s390_km(func, param, out, in, n);
-                if (ret < 0 || ret != n)
-                        return -EIO;
+                BUG_ON((ret < 0) || (ret != n));
 
                 nbytes &= AES_BLOCK_SIZE - 1;
                 ret = blkcipher_walk_done(desc, walk, nbytes);
@@ -398,6 +398,7 @@ static struct crypto_alg ecb_aes_alg = {
         .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
         .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(ecb_aes_alg.cra_list),
         .cra_init               =       fallback_init_blk,
         .cra_exit               =       fallback_exit_blk,
         .cra_u                  =       {
@@ -458,8 +459,7 @@ static int cbc_aes_crypt(struct blkcipher_desc *desc, long func, void *param,
                 u8 *in = walk->src.virt.addr;
 
                 ret = crypt_s390_kmc(func, param, out, in, n);
-                if (ret < 0 || ret != n)
-                        return -EIO;
+                BUG_ON((ret < 0) || (ret != n));
 
                 nbytes &= AES_BLOCK_SIZE - 1;
                 ret = blkcipher_walk_done(desc, walk, nbytes);
@@ -508,6 +508,7 @@ static struct crypto_alg cbc_aes_alg = {
         .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
         .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(cbc_aes_alg.cra_list),
         .cra_init               =       fallback_init_blk,
         .cra_exit               =       fallback_exit_blk,
         .cra_u                  =       {
@@ -627,8 +628,7 @@ static int xts_aes_crypt(struct blkcipher_desc *desc, long func,
         memcpy(xts_ctx->pcc.tweak, walk->iv, sizeof(xts_ctx->pcc.tweak));
         param = xts_ctx->pcc.key + offset;
         ret = crypt_s390_pcc(func, param);
-        if (ret < 0)
-                return -EIO;
+        BUG_ON(ret < 0);
 
         memcpy(xts_ctx->xts_param, xts_ctx->pcc.xts, 16);
         param = xts_ctx->key + offset;
@@ -639,8 +639,7 @@ static int xts_aes_crypt(struct blkcipher_desc *desc, long func,
                 in = walk->src.virt.addr;
 
                 ret = crypt_s390_km(func, param, out, in, n);
-                if (ret < 0 || ret != n)
-                        return -EIO;
+                BUG_ON(ret < 0 || ret != n);
 
                 nbytes &= AES_BLOCK_SIZE - 1;
                 ret = blkcipher_walk_done(desc, walk, nbytes);
@@ -711,6 +710,7 @@ static struct crypto_alg xts_aes_alg = {
         .cra_ctxsize            =       sizeof(struct s390_xts_ctx),
         .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(xts_aes_alg.cra_list),
         .cra_init               =       xts_fallback_init,
         .cra_exit               =       xts_fallback_exit,
         .cra_u                  =       {
@@ -773,8 +773,7 @@ static int ctr_aes_crypt(struct blkcipher_desc *desc, long func,
                                 crypto_inc(ctrblk + i, AES_BLOCK_SIZE);
                         }
                         ret = crypt_s390_kmctr(func, sctx->key, out, in, n, ctrblk);
-                        if (ret < 0 || ret != n)
-                                return -EIO;
+                        BUG_ON(ret < 0 || ret != n);
                         if (n > AES_BLOCK_SIZE)
                                 memcpy(ctrblk, ctrblk + n - AES_BLOCK_SIZE,
                                        AES_BLOCK_SIZE);
@@ -793,8 +792,7 @@ static int ctr_aes_crypt(struct blkcipher_desc *desc, long func,
                 in = walk->src.virt.addr;
                 ret = crypt_s390_kmctr(func, sctx->key, buf, in,
                                        AES_BLOCK_SIZE, ctrblk);
-                if (ret < 0 || ret != AES_BLOCK_SIZE)
-                        return -EIO;
+                BUG_ON(ret < 0 || ret != AES_BLOCK_SIZE);
                 memcpy(out, buf, nbytes);
                 crypto_inc(ctrblk, AES_BLOCK_SIZE);
                 ret = blkcipher_walk_done(desc, walk, 0);
@@ -834,6 +832,7 @@ static struct crypto_alg ctr_aes_alg = {
         .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
         .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(ctr_aes_alg.cra_list),
         .cra_u                  =       {
                 .blkcipher = {
                         .min_keysize            =       AES_MIN_KEY_SIZE,
diff --git a/arch/s390/crypto/crypt_s390.h b/arch/s390/crypto/crypt_s390.h
index 6c5cc6da711..49676771bd6 100644
--- a/arch/s390/crypto/crypt_s390.h
+++ b/arch/s390/crypto/crypt_s390.h
@@ -3,7 +3,7 @@
  *
  * Support for s390 cryptographic instructions.
  *
- *   Copyright IBM Corp. 2003, 2007
+ *   Copyright IBM Corp. 2003,2007
  *   Author(s): Thomas Spatzier
  *              Jan Glauber (jan.glauber@de.ibm.com)
  *
@@ -17,7 +17,6 @@
 #define _CRYPTO_ARCH_S390_CRYPT_S390_H
 
 #include <asm/errno.h>
-#include <asm/facility.h>
 
 #define CRYPT_S390_OP_MASK 0xFF00
 #define CRYPT_S390_FUNC_MASK 0x00FF
@@ -369,12 +368,9 @@ static inline int crypt_s390_func_available(int func,
 
         if (facility_mask & CRYPT_S390_MSA && !test_facility(17))
                 return 0;
-
-        if (facility_mask & CRYPT_S390_MSA3 &&
-            (!test_facility(2) || !test_facility(76)))
+        if (facility_mask & CRYPT_S390_MSA3 && !test_facility(76))
                 return 0;
-        if (facility_mask & CRYPT_S390_MSA4 &&
-            (!test_facility(2) || !test_facility(77)))
+        if (facility_mask & CRYPT_S390_MSA4 && !test_facility(77))
                 return 0;
 
         switch (func & CRYPT_S390_OP_MASK) {
diff --git a/arch/s390/crypto/des_s390.c b/arch/s390/crypto/des_s390.c
index bcca01c9989..a52bfd124d8 100644
--- a/arch/s390/crypto/des_s390.c
+++ b/arch/s390/crypto/des_s390.c
@@ -3,7 +3,7 @@
  *
  * s390 implementation of the DES Cipher Algorithm.
  *
- * Copyright IBM Corp. 2003, 2011
+ * Copyright IBM Corp. 2003,2011
  * Author(s): Thomas Spatzier
  *            Jan Glauber (jan.glauber@de.ibm.com)
  *
@@ -70,6 +70,7 @@ static struct crypto_alg des_alg = {
         .cra_blocksize          =       DES_BLOCK_SIZE,
         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(des_alg.cra_list),
         .cra_u                  =       {
                 .cipher = {
                         .cia_min_keysize        =       DES_KEY_SIZE,
@@ -94,8 +95,7 @@ static int ecb_desall_crypt(struct blkcipher_desc *desc, long func,
                 u8 *in = walk->src.virt.addr;
 
                 ret = crypt_s390_km(func, key, out, in, n);
-                if (ret < 0 || ret != n)
-                        return -EIO;
+                BUG_ON((ret < 0) || (ret != n));
 
                 nbytes &= DES_BLOCK_SIZE - 1;
                 ret = blkcipher_walk_done(desc, walk, nbytes);
@@ -121,8 +121,7 @@ static int cbc_desall_crypt(struct blkcipher_desc *desc, long func,
                 u8 *in = walk->src.virt.addr;
 
                 ret = crypt_s390_kmc(func, iv, out, in, n);
-                if (ret < 0 || ret != n)
-                        return -EIO;
+                BUG_ON((ret < 0) || (ret != n));
 
                 nbytes &= DES_BLOCK_SIZE - 1;
                 ret = blkcipher_walk_done(desc, walk, nbytes);
@@ -164,6 +163,7 @@ static struct crypto_alg ecb_des_alg = {
         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
         .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(ecb_des_alg.cra_list),
         .cra_u                  =       {
                 .blkcipher = {
                         .min_keysize            =       DES_KEY_SIZE,
@@ -206,6 +206,7 @@ static struct crypto_alg cbc_des_alg = {
         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
         .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(cbc_des_alg.cra_list),
         .cra_u                  =       {
                 .blkcipher = {
                         .min_keysize            =       DES_KEY_SIZE,
@@ -270,6 +271,7 @@ static struct crypto_alg des3_alg = {
         .cra_blocksize          =       DES_BLOCK_SIZE,
         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(des3_alg.cra_list),
         .cra_u                  =       {
                 .cipher = {
                         .cia_min_keysize        =       DES3_KEY_SIZE,
@@ -312,6 +314,8 @@ static struct crypto_alg ecb_des3_alg = {
         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
         .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(
+                                                ecb_des3_alg.cra_list),
         .cra_u                  =       {
                 .blkcipher = {
                         .min_keysize            =       DES3_KEY_SIZE,
@@ -354,6 +358,8 @@ static struct crypto_alg cbc_des3_alg = {
         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
         .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(
+                                                cbc_des3_alg.cra_list),
         .cra_u                  =       {
                 .blkcipher = {
                         .min_keysize            =       DES3_KEY_SIZE,
@@ -388,8 +394,7 @@ static int ctr_desall_crypt(struct blkcipher_desc *desc, long func,
                                 crypto_inc(ctrblk + i, DES_BLOCK_SIZE);
                         }
                         ret = crypt_s390_kmctr(func, ctx->key, out, in, n, ctrblk);
-                        if (ret < 0 || ret != n)
-                                return -EIO;
+                        BUG_ON((ret < 0) || (ret != n));
                         if (n > DES_BLOCK_SIZE)
                                 memcpy(ctrblk, ctrblk + n - DES_BLOCK_SIZE,
                                        DES_BLOCK_SIZE);
@@ -407,8 +412,7 @@ static int ctr_desall_crypt(struct blkcipher_desc *desc, long func,
                 in = walk->src.virt.addr;
                 ret = crypt_s390_kmctr(func, ctx->key, buf, in,
                                        DES_BLOCK_SIZE, ctrblk);
-                if (ret < 0 || ret != DES_BLOCK_SIZE)
-                        return -EIO;
+                BUG_ON(ret < 0 || ret != DES_BLOCK_SIZE);
                 memcpy(out, buf, nbytes);
                 crypto_inc(ctrblk, DES_BLOCK_SIZE);
                 ret = blkcipher_walk_done(desc, walk, 0);
@@ -448,6 +452,7 @@ static struct crypto_alg ctr_des_alg = {
         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
         .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(ctr_des_alg.cra_list),
         .cra_u                  =       {
                 .blkcipher = {
                         .min_keysize            =       DES_KEY_SIZE,
@@ -491,6 +496,7 @@ static struct crypto_alg ctr_des3_alg = {
         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
         .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(ctr_des3_alg.cra_list),
         .cra_u                  =       {
                 .blkcipher = {
                         .min_keysize            =       DES3_KEY_SIZE,
diff --git a/arch/s390/crypto/ghash_s390.c b/arch/s390/crypto/ghash_s390.c
index d43485d142e..b1bd170f24b 100644
--- a/arch/s390/crypto/ghash_s390.c
+++ b/arch/s390/crypto/ghash_s390.c
@@ -72,16 +72,14 @@ static int ghash_update(struct shash_desc *desc,
                 if (!dctx->bytes) {
                         ret = crypt_s390_kimd(KIMD_GHASH, ctx, buf,
                                               GHASH_BLOCK_SIZE);
-                        if (ret != GHASH_BLOCK_SIZE)
-                                return -EIO;
+                        BUG_ON(ret != GHASH_BLOCK_SIZE);
                 }
         }
 
         n = srclen & ~(GHASH_BLOCK_SIZE - 1);
         if (n) {
                 ret = crypt_s390_kimd(KIMD_GHASH, ctx, src, n);
-                if (ret != n)
-                        return -EIO;
+                BUG_ON(ret != n);
                 src += n;
                 srclen -= n;
         }
@@ -94,7 +92,7 @@ static int ghash_update(struct shash_desc *desc,
         return 0;
 }
 
-static int ghash_flush(struct ghash_ctx *ctx, struct ghash_desc_ctx *dctx)
+static void ghash_flush(struct ghash_ctx *ctx, struct ghash_desc_ctx *dctx)
 {
         u8 *buf = dctx->buffer;
         int ret;
@@ -105,24 +103,21 @@ static int ghash_flush(struct ghash_ctx *ctx, struct ghash_desc_ctx *dctx)
                 memset(pos, 0, dctx->bytes);
 
                 ret = crypt_s390_kimd(KIMD_GHASH, ctx, buf, GHASH_BLOCK_SIZE);
-                if (ret != GHASH_BLOCK_SIZE)
-                        return -EIO;
+                BUG_ON(ret != GHASH_BLOCK_SIZE);
         }
 
         dctx->bytes = 0;
-        return 0;
 }
 
 static int ghash_final(struct shash_desc *desc, u8 *dst)
 {
         struct ghash_desc_ctx *dctx = shash_desc_ctx(desc);
         struct ghash_ctx *ctx = crypto_shash_ctx(desc->tfm);
-        int ret;
 
-        ret = ghash_flush(ctx, dctx);
-        if (!ret)
-                memcpy(dst, ctx->icv, GHASH_BLOCK_SIZE);
-        return ret;
+        ghash_flush(ctx, dctx);
+        memcpy(dst, ctx->icv, GHASH_BLOCK_SIZE);
+
+        return 0;
 }
 
 static struct shash_alg ghash_alg = {
@@ -140,6 +135,7 @@ static struct shash_alg ghash_alg = {
                 .cra_blocksize          = GHASH_BLOCK_SIZE,
                 .cra_ctxsize            = sizeof(struct ghash_ctx),
                 .cra_module             = THIS_MODULE,
+                .cra_list               = LIST_HEAD_INIT(ghash_alg.base.cra_list),
         },
 };
 
diff --git a/arch/s390/crypto/prng.c b/arch/s390/crypto/prng.c
index 94a35a4c1b4..0808fbf0f7d 100644
--- a/arch/s390/crypto/prng.c
+++ b/arch/s390/crypto/prng.c
@@ -1,5 +1,5 @@
 /*
- * Copyright IBM Corp. 2006, 2007
+ * Copyright IBM Corp. 2006,2007
  * Author(s): Jan Glauber <jan.glauber@de.ibm.com>
  * Driver for the s390 pseudo random number generator
  */
diff --git a/arch/s390/crypto/sha1_s390.c b/arch/s390/crypto/sha1_s390.c
index a1b3a9dc9d8..e9868c6e0a0 100644
--- a/arch/s390/crypto/sha1_s390.c
+++ b/arch/s390/crypto/sha1_s390.c
@@ -8,7 +8,7 @@
  * implementation written by Steve Reid.
  *
  * s390 Version:
- *   Copyright IBM Corp. 2003, 2007
+ *   Copyright IBM Corp. 2003,2007
  *   Author(s): Thomas Spatzier
  *              Jan Glauber (jan.glauber@de.ibm.com)
  *
diff --git a/arch/s390/crypto/sha256_s390.c b/arch/s390/crypto/sha256_s390.c
index 9b853809a49..0317a3547cb 100644
--- a/arch/s390/crypto/sha256_s390.c
+++ b/arch/s390/crypto/sha256_s390.c
@@ -4,7 +4,7 @@
  * s390 implementation of the SHA256 and SHA224 Secure Hash Algorithm.
  *
  * s390 Version:
- *   Copyright IBM Corp. 2005, 2011
+ *   Copyright IBM Corp. 2005,2011
  *   Author(s): Jan Glauber (jang@de.ibm.com)
  *
  * This program is free software; you can redistribute it and/or modify it
diff --git a/arch/s390/crypto/sha_common.c b/arch/s390/crypto/sha_common.c
index 8620b0ec9c4..48884f89ab9 100644
--- a/arch/s390/crypto/sha_common.c
+++ b/arch/s390/crypto/sha_common.c
@@ -14,7 +14,6 @@
  */
 
 #include <crypto/internal/hash.h>
-#include <linux/module.h>
 #include "sha.h"
 #include "crypt_s390.h"
 
@@ -36,8 +35,7 @@ int s390_sha_update(struct shash_desc *desc, const u8 *data, unsigned int len)
         if (index) {
                 memcpy(ctx->buf + index, data, bsize - index);
                 ret = crypt_s390_kimd(ctx->func, ctx->state, ctx->buf, bsize);
-                if (ret != bsize)
-                        return -EIO;
+                BUG_ON(ret != bsize);
                 data += bsize - index;
                 len -= bsize - index;
                 index = 0;
@@ -47,8 +45,7 @@ int s390_sha_update(struct shash_desc *desc, const u8 *data, unsigned int len)
         if (len >= bsize) {
                 ret = crypt_s390_kimd(ctx->func, ctx->state, data,
                                       len & ~(bsize - 1));
-                if (ret != (len & ~(bsize - 1)))
-                        return -EIO;
+                BUG_ON(ret != (len & ~(bsize - 1)));
                 data += ret;
                 len -= ret;
         }
@@ -90,8 +87,7 @@ int s390_sha_final(struct shash_desc *desc, u8 *out)
         memcpy(ctx->buf + end - 8, &bits, sizeof(bits));
 
         ret = crypt_s390_kimd(ctx->func, ctx->state, ctx->buf, end);
-        if (ret != end)
-                return -EIO;
+        BUG_ON(ret != end);
 
         /* copy digest to out */
         memcpy(out, ctx->state, crypto_shash_digestsize(desc->tfm));