crypto: atmel-sha - redefine SHA_FLAGS_SHA* flags to match SHA_MR_ALGO_SHA*

This patch modifies the SHA_FLAGS_SHA* flags: those algo flags are now
organized as values of a single bitfield instead of individual bits.
This allows to reduce the number of bits needed to encode all possible
values. Also the new values match the SHA_MR_ALGO_SHA* values hence
the algorithm bitfield of the SHA_MR register could simply be set with:

mr = (mr & ~SHA_FLAGS_ALGO_MASK) | (ctx->flags & SHA_FLAGS_ALGO_MASK)

Signed-off-by: Cyrille Pitchen <cyrille.pitchen@atmel.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

1 files changed, 32 insertions, 13 deletions

diff --git a/drivers/crypto/atmel-sha.c b/drivers/crypto/atmel-sha.c
index 643d79a05dda..b29a4e5bc404 100644
--- a/drivers/crypto/atmel-sha.c
+++ b/drivers/crypto/atmel-sha.c
@@ -51,14 +51,16 @@
 #define SHA_FLAGS_CPU                   BIT(5)
 #define SHA_FLAGS_DMA_READY             BIT(6)
 
+/* bits[10:8] are reserved. */
+#define SHA_FLAGS_ALGO_MASK     SHA_MR_ALGO_MASK
+#define SHA_FLAGS_SHA1          SHA_MR_ALGO_SHA1
+#define SHA_FLAGS_SHA256        SHA_MR_ALGO_SHA256
+#define SHA_FLAGS_SHA384        SHA_MR_ALGO_SHA384
+#define SHA_FLAGS_SHA512        SHA_MR_ALGO_SHA512
+#define SHA_FLAGS_SHA224        SHA_MR_ALGO_SHA224
+
 #define SHA_FLAGS_FINUP         BIT(16)
 #define SHA_FLAGS_SG            BIT(17)
-#define SHA_FLAGS_ALGO_MASK     GENMASK(22, 18)
-#define SHA_FLAGS_SHA1          BIT(18)
-#define SHA_FLAGS_SHA224        BIT(19)
-#define SHA_FLAGS_SHA256        BIT(20)
-#define SHA_FLAGS_SHA384        BIT(21)
-#define SHA_FLAGS_SHA512        BIT(22)
 #define SHA_FLAGS_ERROR         BIT(23)
 #define SHA_FLAGS_PAD           BIT(24)
 #define SHA_FLAGS_RESTORE       BIT(25)
@@ -264,7 +266,9 @@ static void atmel_sha_fill_padding(struct atmel_sha_reqctx *ctx, int length)
         bits[1] = cpu_to_be64(size[0] << 3);
         bits[0] = cpu_to_be64(size[1] << 3 | size[0] >> 61);
 
-        if (ctx->flags & (SHA_FLAGS_SHA384 | SHA_FLAGS_SHA512)) {
+        switch (ctx->flags & SHA_FLAGS_ALGO_MASK) {
+        case SHA_FLAGS_SHA384:
+        case SHA_FLAGS_SHA512:
                 index = ctx->bufcnt & 0x7f;
                 padlen = (index < 112) ? (112 - index) : ((128+112) - index);
                 *(ctx->buffer + ctx->bufcnt) = 0x80;
@@ -272,7 +276,9 @@ static void atmel_sha_fill_padding(struct atmel_sha_reqctx *ctx, int length)
                 memcpy(ctx->buffer + ctx->bufcnt + padlen, bits, 16);
                 ctx->bufcnt += padlen + 16;
                 ctx->flags |= SHA_FLAGS_PAD;
-        } else {
+                break;
+
+        default:
                 index = ctx->bufcnt & 0x3f;
                 padlen = (index < 56) ? (56 - index) : ((64+56) - index);
                 *(ctx->buffer + ctx->bufcnt) = 0x80;
@@ -280,6 +286,7 @@ static void atmel_sha_fill_padding(struct atmel_sha_reqctx *ctx, int length)
                 memcpy(ctx->buffer + ctx->bufcnt + padlen, &bits[1], 8);
                 ctx->bufcnt += padlen + 8;
                 ctx->flags |= SHA_FLAGS_PAD;
+                break;
         }
 }
 
@@ -828,16 +835,28 @@ static void atmel_sha_copy_ready_hash(struct ahash_request *req)
         if (!req->result)
                 return;
 
-        if (ctx->flags & SHA_FLAGS_SHA1)
+        switch (ctx->flags & SHA_FLAGS_ALGO_MASK) {
+        default:
+        case SHA_FLAGS_SHA1:
                 memcpy(req->result, ctx->digest, SHA1_DIGEST_SIZE);
-        else if (ctx->flags & SHA_FLAGS_SHA224)
+                break;
+
+        case SHA_FLAGS_SHA224:
                 memcpy(req->result, ctx->digest, SHA224_DIGEST_SIZE);
-        else if (ctx->flags & SHA_FLAGS_SHA256)
+                break;
+
+        case SHA_FLAGS_SHA256:
                 memcpy(req->result, ctx->digest, SHA256_DIGEST_SIZE);
-        else if (ctx->flags & SHA_FLAGS_SHA384)
+                break;
+
+        case SHA_FLAGS_SHA384:
                 memcpy(req->result, ctx->digest, SHA384_DIGEST_SIZE);
-        else
+                break;
+
+        case SHA_FLAGS_SHA512:
                 memcpy(req->result, ctx->digest, SHA512_DIGEST_SIZE);
+                break;
+        }
 }
 
 static int atmel_sha_finish(struct ahash_request *req)