Merge tag 'u-boot-nand-20230417' of https://source.denx.de/u-boot/custodians/u-boot...

[platform/kernel/u-boot.git] / common / hash.c

diff --git a/common/hash.c b/common/hash.c
index 6277fe6..9a52d60 100644 (file)
--- a/common/hash.c
+++ b/common/hash.c
@@ -24,7 +24,9 @@
 #include <u-boot/crc.h>
 #else
 #include "mkimage.h"
+#include <linux/compiler_attributes.h>
 #include <time.h>
+#include <linux/kconfig.h>
 #endif /* !USE_HOSTCC*/
 
 #include <hash.h>
@@ -41,8 +43,7 @@ DECLARE_GLOBAL_DATA_PTR;
 
 static void reloc_update(void);
 
-#if defined(CONFIG_SHA1) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
-static int hash_init_sha1(struct hash_algo *algo, void **ctxp)
+static int __maybe_unused hash_init_sha1(struct hash_algo *algo, void **ctxp)
 {
        sha1_context *ctx = malloc(sizeof(sha1_context));
        sha1_starts(ctx);
@@ -50,15 +51,16 @@ static int hash_init_sha1(struct hash_algo *algo, void **ctxp)
        return 0;
 }
 
-static int hash_update_sha1(struct hash_algo *algo, void *ctx, const void *buf,
-                           unsigned int size, int is_last)
+static int __maybe_unused hash_update_sha1(struct hash_algo *algo, void *ctx,
+                                          const void *buf, unsigned int size,
+                                          int is_last)
 {
        sha1_update((sha1_context *)ctx, buf, size);
        return 0;
 }
 
-static int hash_finish_sha1(struct hash_algo *algo, void *ctx, void *dest_buf,
-                           int size)
+static int __maybe_unused hash_finish_sha1(struct hash_algo *algo, void *ctx,
+                                          void *dest_buf, int size)
 {
        if (size < algo->digest_size)
                return -1;
@@ -67,10 +69,8 @@ static int hash_finish_sha1(struct hash_algo *algo, void *ctx, void *dest_buf,
        free(ctx);
        return 0;
 }
-#endif
 
-#if defined(CONFIG_SHA256) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
-static int hash_init_sha256(struct hash_algo *algo, void **ctxp)
+static int __maybe_unused hash_init_sha256(struct hash_algo *algo, void **ctxp)
 {
        sha256_context *ctx = malloc(sizeof(sha256_context));
        sha256_starts(ctx);
@@ -78,15 +78,16 @@ static int hash_init_sha256(struct hash_algo *algo, void **ctxp)
        return 0;
 }
 
-static int hash_update_sha256(struct hash_algo *algo, void *ctx,
-                             const void *buf, unsigned int size, int is_last)
+static int __maybe_unused hash_update_sha256(struct hash_algo *algo, void *ctx,
+                                            const void *buf, uint size,
+                                            int is_last)
 {
        sha256_update((sha256_context *)ctx, buf, size);
        return 0;
 }
 
-static int hash_finish_sha256(struct hash_algo *algo, void *ctx, void
-                             *dest_buf, int size)
+static int __maybe_unused hash_finish_sha256(struct hash_algo *algo, void *ctx,
+                                            void *dest_buf, int size)
 {
        if (size < algo->digest_size)
                return -1;
@@ -95,10 +96,8 @@ static int hash_finish_sha256(struct hash_algo *algo, void *ctx, void
        free(ctx);
        return 0;
 }
-#endif
 
-#if defined(CONFIG_SHA384) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
-static int hash_init_sha384(struct hash_algo *algo, void **ctxp)
+static int __maybe_unused hash_init_sha384(struct hash_algo *algo, void **ctxp)
 {
        sha512_context *ctx = malloc(sizeof(sha512_context));
        sha384_starts(ctx);
@@ -106,15 +105,16 @@ static int hash_init_sha384(struct hash_algo *algo, void **ctxp)
        return 0;
 }
 
-static int hash_update_sha384(struct hash_algo *algo, void *ctx,
-                             const void *buf, unsigned int size, int is_last)
+static int __maybe_unused hash_update_sha384(struct hash_algo *algo, void *ctx,
+                                            const void *buf, uint size,
+                                            int is_last)
 {
        sha384_update((sha512_context *)ctx, buf, size);
        return 0;
 }
 
-static int hash_finish_sha384(struct hash_algo *algo, void *ctx, void
-                             *dest_buf, int size)
+static int __maybe_unused hash_finish_sha384(struct hash_algo *algo, void *ctx,
+                                            void *dest_buf, int size)
 {
        if (size < algo->digest_size)
                return -1;
@@ -123,10 +123,8 @@ static int hash_finish_sha384(struct hash_algo *algo, void *ctx, void
        free(ctx);
        return 0;
 }
-#endif
 
-#if defined(CONFIG_SHA512) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
-static int hash_init_sha512(struct hash_algo *algo, void **ctxp)
+static int __maybe_unused hash_init_sha512(struct hash_algo *algo, void **ctxp)
 {
        sha512_context *ctx = malloc(sizeof(sha512_context));
        sha512_starts(ctx);
@@ -134,15 +132,16 @@ static int hash_init_sha512(struct hash_algo *algo, void **ctxp)
        return 0;
 }
 
-static int hash_update_sha512(struct hash_algo *algo, void *ctx,
-                             const void *buf, unsigned int size, int is_last)
+static int __maybe_unused hash_update_sha512(struct hash_algo *algo, void *ctx,
+                                            const void *buf, uint size,
+                                            int is_last)
 {
        sha512_update((sha512_context *)ctx, buf, size);
        return 0;
 }
 
-static int hash_finish_sha512(struct hash_algo *algo, void *ctx, void
-                             *dest_buf, int size)
+static int __maybe_unused hash_finish_sha512(struct hash_algo *algo, void *ctx,
+                                            void *dest_buf, int size)
 {
        if (size < algo->digest_size)
                return -1;
@@ -151,8 +150,6 @@ static int hash_finish_sha512(struct hash_algo *algo, void *ctx, void
        free(ctx);
        return 0;
 }
-#endif
-
 
 static int hash_init_crc16_ccitt(struct hash_algo *algo, void **ctxp)
 {
@@ -181,7 +178,7 @@ static int hash_finish_crc16_ccitt(struct hash_algo *algo, void *ctx,
        return 0;
 }
 
-static int hash_init_crc32(struct hash_algo *algo, void **ctxp)
+static int __maybe_unused hash_init_crc32(struct hash_algo *algo, void **ctxp)
 {
        uint32_t *ctx = malloc(sizeof(uint32_t));
        *ctx = 0;
@@ -189,15 +186,16 @@ static int hash_init_crc32(struct hash_algo *algo, void **ctxp)
        return 0;
 }
 
-static int hash_update_crc32(struct hash_algo *algo, void *ctx,
-                            const void *buf, unsigned int size, int is_last)
+static int __maybe_unused hash_update_crc32(struct hash_algo *algo, void *ctx,
+                                           const void *buf, unsigned int size,
+                                           int is_last)
 {
        *((uint32_t *)ctx) = crc32(*((uint32_t *)ctx), buf, size);
        return 0;
 }
 
-static int hash_finish_crc32(struct hash_algo *algo, void *ctx, void *dest_buf,
-                            int size)
+static int __maybe_unused hash_finish_crc32(struct hash_algo *algo, void *ctx,
+                                           void *dest_buf, int size)
 {
        if (size < algo->digest_size)
                return -1;
@@ -207,18 +205,13 @@ static int hash_finish_crc32(struct hash_algo *algo, void *ctx, void *dest_buf,
        return 0;
 }
 
-#ifdef USE_HOSTCC
-# define I_WANT_MD5    1
-#else
-# define I_WANT_MD5    CONFIG_IS_ENABLED(MD5)
-#endif
 /*
  * These are the hash algorithms we support.  If we have hardware acceleration
  * is enable we will use that, otherwise a software version of the algorithm.
  * Note that algorithm names must be in lower case.
  */
 static struct hash_algo hash_algo[] = {
-#if I_WANT_MD5
+#if CONFIG_IS_ENABLED(MD5)
        {
                .name           = "md5",
                .digest_size    = MD5_SUM_LEN,
@@ -226,17 +219,17 @@ static struct hash_algo hash_algo[] = {
                .hash_func_ws   = md5_wd,
        },
 #endif
-#ifdef CONFIG_SHA1
+#if CONFIG_IS_ENABLED(SHA1)
        {
-               .name           = "sha1",
+               .name           = "sha1",
                .digest_size    = SHA1_SUM_LEN,
                .chunk_size     = CHUNKSZ_SHA1,
-#ifdef CONFIG_SHA_HW_ACCEL
+#if CONFIG_IS_ENABLED(SHA_HW_ACCEL)
                .hash_func_ws   = hw_sha1,
 #else
                .hash_func_ws   = sha1_csum_wd,
 #endif
-#ifdef CONFIG_SHA_PROG_HW_ACCEL
+#if CONFIG_IS_ENABLED(SHA_PROG_HW_ACCEL)
                .hash_init      = hw_sha_init,
                .hash_update    = hw_sha_update,
                .hash_finish    = hw_sha_finish,
@@ -247,17 +240,17 @@ static struct hash_algo hash_algo[] = {
 #endif
        },
 #endif
-#ifdef CONFIG_SHA256
+#if CONFIG_IS_ENABLED(SHA256)
        {
                .name           = "sha256",
                .digest_size    = SHA256_SUM_LEN,
                .chunk_size     = CHUNKSZ_SHA256,
-#ifdef CONFIG_SHA_HW_ACCEL
+#if CONFIG_IS_ENABLED(SHA_HW_ACCEL)
                .hash_func_ws   = hw_sha256,
 #else
                .hash_func_ws   = sha256_csum_wd,
 #endif
-#ifdef CONFIG_SHA_PROG_HW_ACCEL
+#if CONFIG_IS_ENABLED(SHA_PROG_HW_ACCEL)
                .hash_init      = hw_sha_init,
                .hash_update    = hw_sha_update,
                .hash_finish    = hw_sha_finish,
@@ -268,17 +261,17 @@ static struct hash_algo hash_algo[] = {
 #endif
        },
 #endif
-#ifdef CONFIG_SHA384
+#if CONFIG_IS_ENABLED(SHA384)
        {
                .name           = "sha384",
                .digest_size    = SHA384_SUM_LEN,
                .chunk_size     = CHUNKSZ_SHA384,
-#ifdef CONFIG_SHA512_HW_ACCEL
+#if CONFIG_IS_ENABLED(SHA512_HW_ACCEL)
                .hash_func_ws   = hw_sha384,
 #else
                .hash_func_ws   = sha384_csum_wd,
 #endif
-#if defined(CONFIG_SHA512_HW_ACCEL) && defined(CONFIG_SHA_PROG_HW_ACCEL)
+#if CONFIG_IS_ENABLED(SHA512_HW_ACCEL) && CONFIG_IS_ENABLED(SHA_PROG_HW_ACCEL)
                .hash_init      = hw_sha_init,
                .hash_update    = hw_sha_update,
                .hash_finish    = hw_sha_finish,
@@ -289,17 +282,17 @@ static struct hash_algo hash_algo[] = {
 #endif
        },
 #endif
-#ifdef CONFIG_SHA512
+#if CONFIG_IS_ENABLED(SHA512)
        {
                .name           = "sha512",
                .digest_size    = SHA512_SUM_LEN,
                .chunk_size     = CHUNKSZ_SHA512,
-#ifdef CONFIG_SHA512_HW_ACCEL
+#if CONFIG_IS_ENABLED(SHA512_HW_ACCEL)
                .hash_func_ws   = hw_sha512,
 #else
                .hash_func_ws   = sha512_csum_wd,
 #endif
-#if defined(CONFIG_SHA512_HW_ACCEL) && defined(CONFIG_SHA_PROG_HW_ACCEL)
+#if CONFIG_IS_ENABLED(SHA512_HW_ACCEL) && CONFIG_IS_ENABLED(SHA_PROG_HW_ACCEL)
                .hash_init      = hw_sha_init,
                .hash_update    = hw_sha_update,
                .hash_finish    = hw_sha_finish,
@@ -319,6 +312,7 @@ static struct hash_algo hash_algo[] = {
                .hash_update    = hash_update_crc16_ccitt,
                .hash_finish    = hash_finish_crc16_ccitt,
        },
+#if CONFIG_IS_ENABLED(CRC32)
        {
                .name           = "crc32",
                .digest_size    = 4,
@@ -328,12 +322,13 @@ static struct hash_algo hash_algo[] = {
                .hash_update    = hash_update_crc32,
                .hash_finish    = hash_finish_crc32,
        },
+#endif
 };
 
 /* Try to minimize code size for boards that don't want much hashing */
-#if defined(CONFIG_SHA256) || defined(CONFIG_CMD_SHA1SUM) || \
-       defined(CONFIG_CRC32_VERIFY) || defined(CONFIG_CMD_HASH) || \
-       defined(CONFIG_SHA384) || defined(CONFIG_SHA512)
+#if CONFIG_IS_ENABLED(SHA256) || IS_ENABLED(CONFIG_CMD_SHA1SUM) || \
+       CONFIG_IS_ENABLED(CRC32_VERIFY) || IS_ENABLED(CONFIG_CMD_HASH) || \
+       CONFIG_IS_ENABLED(SHA384) || CONFIG_IS_ENABLED(SHA512)
 #define multi_hash()   1
 #else
 #define multi_hash()   0
@@ -438,7 +433,8 @@ int hash_block(const char *algo_name, const void *data, unsigned int len,
        return 0;
 }
 
-#if defined(CONFIG_CMD_HASH) || defined(CONFIG_CMD_SHA1SUM) || defined(CONFIG_CMD_CRC32)
+#if !defined(CONFIG_SPL_BUILD) && (defined(CONFIG_CMD_HASH) || \
+       defined(CONFIG_CMD_SHA1SUM) || defined(CONFIG_CMD_CRC32))
 /**
  * store_result: Store the resulting sum to an address or variable
  *
@@ -504,7 +500,7 @@ static void store_result(struct hash_algo *algo, const uint8_t *sum,
  * @allow_env_vars:    non-zero to permit storing the result to an environment
  *                     variable. If 0 then verify_str is assumed to be an
  *                     address, and the * prefix is not expected.
- * @return 0 if ok, non-zero on error
+ * Return: 0 if ok, non-zero on error
  */
 static int parse_verify_sum(struct hash_algo *algo, char *verify_str,
                            uint8_t *vsum, int allow_env_vars)