crypto: stm32 - Fix sparse warnings

This patch fixes most of the sparse endianness warnings in stm32.
The patch itself doesn't change anything apart from markings,
but there is some questionable code in stm32_cryp_check_ctr_counter.

That function operates on the counters as if they're in CPU order,
however, they're then written out as big-endian.  This looks like
a genuine bug.  Therefore I've left that warning alone until
someone can confirm that this really does work as intended on
little-endian.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/drivers/crypto/stm32/stm32-crc32.c b/drivers/crypto/stm32/stm32-crc32.c
index 5fb706b683097cdbae6380527fc2060cd2028a2d..783a64f3f63575b93dbe4e62b373ff9ea2319311 100644 (file)
--- a/drivers/crypto/stm32/stm32-crc32.c
+++ b/drivers/crypto/stm32/stm32-crc32.c
@@ -218,9 +218,8 @@ static int stm32_crc_update(struct shash_desc *desc, const u8 *d8,
                return burst_update(desc, d8, length);
 
        /* Digest first bytes not 32bit aligned at first pass in the loop */
-       size = min(length,
-                  burst_sz + (unsigned int)d8 - ALIGN_DOWN((unsigned int)d8,
-                                                           sizeof(u32)));
+       size = min_t(size_t, length, burst_sz + (size_t)d8 -
+                                    ALIGN_DOWN((size_t)d8, sizeof(u32)));
        for (rem_sz = length, cur = d8; rem_sz;
             rem_sz -= size, cur += size, size = min(rem_sz, burst_sz)) {
                ret = burst_update(desc, cur, size);

diff --git a/drivers/crypto/stm32/stm32-cryp.c b/drivers/crypto/stm32/stm32-cryp.c
index d347a1d6e351dc794a4418155fced86e8f3a39f7..2670c30332fad9f3638d831607c9790f2966562a 100644 (file)
--- a/drivers/crypto/stm32/stm32-cryp.c
+++ b/drivers/crypto/stm32/stm32-cryp.c
@@ -118,7 +118,7 @@ struct stm32_cryp_ctx {
        struct crypto_engine_ctx enginectx;
        struct stm32_cryp       *cryp;
        int                     keylen;
-       u32                     key[AES_KEYSIZE_256 / sizeof(u32)];
+       __be32                  key[AES_KEYSIZE_256 / sizeof(u32)];
        unsigned long           flags;
 };
 
@@ -380,24 +380,24 @@ static int stm32_cryp_copy_sgs(struct stm32_cryp *cryp)
        return 0;
 }
 
-static void stm32_cryp_hw_write_iv(struct stm32_cryp *cryp, u32 *iv)
+static void stm32_cryp_hw_write_iv(struct stm32_cryp *cryp, __be32 *iv)
 {
        if (!iv)
                return;
 
-       stm32_cryp_write(cryp, CRYP_IV0LR, cpu_to_be32(*iv++));
-       stm32_cryp_write(cryp, CRYP_IV0RR, cpu_to_be32(*iv++));
+       stm32_cryp_write(cryp, CRYP_IV0LR, be32_to_cpu(*iv++));
+       stm32_cryp_write(cryp, CRYP_IV0RR, be32_to_cpu(*iv++));
 
        if (is_aes(cryp)) {
-               stm32_cryp_write(cryp, CRYP_IV1LR, cpu_to_be32(*iv++));
-               stm32_cryp_write(cryp, CRYP_IV1RR, cpu_to_be32(*iv++));
+               stm32_cryp_write(cryp, CRYP_IV1LR, be32_to_cpu(*iv++));
+               stm32_cryp_write(cryp, CRYP_IV1RR, be32_to_cpu(*iv++));
        }
 }
 
 static void stm32_cryp_get_iv(struct stm32_cryp *cryp)
 {
        struct skcipher_request *req = cryp->req;
-       u32 *tmp = (void *)req->iv;
+       __be32 *tmp = (void *)req->iv;
 
        if (!tmp)
                return;
@@ -417,13 +417,13 @@ static void stm32_cryp_hw_write_key(struct stm32_cryp *c)
        int r_id;
 
        if (is_des(c)) {
-               stm32_cryp_write(c, CRYP_K1LR, cpu_to_be32(c->ctx->key[0]));
-               stm32_cryp_write(c, CRYP_K1RR, cpu_to_be32(c->ctx->key[1]));
+               stm32_cryp_write(c, CRYP_K1LR, be32_to_cpu(c->ctx->key[0]));
+               stm32_cryp_write(c, CRYP_K1RR, be32_to_cpu(c->ctx->key[1]));
        } else {
                r_id = CRYP_K3RR;
                for (i = c->ctx->keylen / sizeof(u32); i > 0; i--, r_id -= 4)
                        stm32_cryp_write(c, r_id,
-                                        cpu_to_be32(c->ctx->key[i - 1]));
+                                        be32_to_cpu(c->ctx->key[i - 1]));
        }
 }
 
@@ -469,7 +469,7 @@ static unsigned int stm32_cryp_get_input_text_len(struct stm32_cryp *cryp)
 static int stm32_cryp_gcm_init(struct stm32_cryp *cryp, u32 cfg)
 {
        int ret;
-       u32 iv[4];
+       __be32 iv[4];
 
        /* Phase 1 : init */
        memcpy(iv, cryp->areq->iv, 12);
@@ -491,6 +491,7 @@ static int stm32_cryp_ccm_init(struct stm32_cryp *cryp, u32 cfg)
 {
        int ret;
        u8 iv[AES_BLOCK_SIZE], b0[AES_BLOCK_SIZE];
+       __be32 *bd;
        u32 *d;
        unsigned int i, textlen;
 
@@ -498,7 +499,7 @@ static int stm32_cryp_ccm_init(struct stm32_cryp *cryp, u32 cfg)
        memcpy(iv, cryp->areq->iv, AES_BLOCK_SIZE);
        memset(iv + AES_BLOCK_SIZE - 1 - iv[0], 0, iv[0] + 1);
        iv[AES_BLOCK_SIZE - 1] = 1;
-       stm32_cryp_hw_write_iv(cryp, (u32 *)iv);
+       stm32_cryp_hw_write_iv(cryp, (__be32 *)iv);
 
        /* Build B0 */
        memcpy(b0, iv, AES_BLOCK_SIZE);
@@ -518,11 +519,14 @@ static int stm32_cryp_ccm_init(struct stm32_cryp *cryp, u32 cfg)
 
        /* Write B0 */
        d = (u32 *)b0;
+       bd = (__be32 *)b0;
 
        for (i = 0; i < AES_BLOCK_32; i++) {
+               u32 xd = d[i];
+
                if (!cryp->caps->padding_wa)
-                       *d = cpu_to_be32(*d);
-               stm32_cryp_write(cryp, CRYP_DIN, *d++);
+                       xd = be32_to_cpu(bd[i]);
+               stm32_cryp_write(cryp, CRYP_DIN, xd);
        }
 
        /* Wait for end of processing */
@@ -617,7 +621,7 @@ static int stm32_cryp_hw_init(struct stm32_cryp *cryp)
        case CR_TDES_CBC:
        case CR_AES_CBC:
        case CR_AES_CTR:
-               stm32_cryp_hw_write_iv(cryp, (u32 *)cryp->req->iv);
+               stm32_cryp_hw_write_iv(cryp, (__be32 *)cryp->req->iv);
                break;
 
        default:
@@ -1120,7 +1124,7 @@ static int stm32_cryp_read_auth_tag(struct stm32_cryp *cryp)
                /* GCM: write aad and payload size (in bits) */
                size_bit = cryp->areq->assoclen * 8;
                if (cryp->caps->swap_final)
-                       size_bit = cpu_to_be32(size_bit);
+                       size_bit = (__force u32)cpu_to_be32(size_bit);
 
                stm32_cryp_write(cryp, CRYP_DIN, 0);
                stm32_cryp_write(cryp, CRYP_DIN, size_bit);
@@ -1129,7 +1133,7 @@ static int stm32_cryp_read_auth_tag(struct stm32_cryp *cryp)
                                cryp->areq->cryptlen - AES_BLOCK_SIZE;
                size_bit *= 8;
                if (cryp->caps->swap_final)
-                       size_bit = cpu_to_be32(size_bit);
+                       size_bit = (__force u32)cpu_to_be32(size_bit);
 
                stm32_cryp_write(cryp, CRYP_DIN, 0);
                stm32_cryp_write(cryp, CRYP_DIN, size_bit);
@@ -1137,14 +1141,19 @@ static int stm32_cryp_read_auth_tag(struct stm32_cryp *cryp)
                /* CCM: write CTR0 */
                u8 iv[AES_BLOCK_SIZE];
                u32 *iv32 = (u32 *)iv;
+               __be32 *biv;
+
+               biv = (void *)iv;
 
                memcpy(iv, cryp->areq->iv, AES_BLOCK_SIZE);
                memset(iv + AES_BLOCK_SIZE - 1 - iv[0], 0, iv[0] + 1);
 
                for (i = 0; i < AES_BLOCK_32; i++) {
+                       u32 xiv = iv32[i];
+
                        if (!cryp->caps->padding_wa)
-                               *iv32 = cpu_to_be32(*iv32);
-                       stm32_cryp_write(cryp, CRYP_DIN, *iv32++);
+                               xiv = be32_to_cpu(biv[i]);
+                       stm32_cryp_write(cryp, CRYP_DIN, xiv);
                }
        }
 

diff --git a/drivers/crypto/stm32/stm32-hash.c b/drivers/crypto/stm32/stm32-hash.c
index 092eaabda238f4dcb3c319bc497e47aab5e4ef64..e84330f247d9e2e746eef05efcda3fd03c6f1be8 100644 (file)
--- a/drivers/crypto/stm32/stm32-hash.c
+++ b/drivers/crypto/stm32/stm32-hash.c
@@ -749,7 +749,7 @@ static int stm32_hash_final_req(struct stm32_hash_dev *hdev)
 static void stm32_hash_copy_hash(struct ahash_request *req)
 {
        struct stm32_hash_request_ctx *rctx = ahash_request_ctx(req);
-       u32 *hash = (u32 *)rctx->digest;
+       __be32 *hash = (void *)rctx->digest;
        unsigned int i, hashsize;
 
        switch (rctx->flags & HASH_FLAGS_ALGO_MASK) {
@@ -770,7 +770,7 @@ static void stm32_hash_copy_hash(struct ahash_request *req)
        }
 
        for (i = 0; i < hashsize / sizeof(u32); i++)
-               hash[i] = be32_to_cpu(stm32_hash_read(rctx->hdev,
+               hash[i] = cpu_to_be32(stm32_hash_read(rctx->hdev,
                                                      HASH_HREG(i)));
 }