dm: hash: Add new UCLASS_HASH support

Add UCLASS_HASH for hash driver development. Thus the
hash drivers (SW or HW-accelerated) can be developed
in the DM-based fashion.

Signed-off-by: Chia-Wei Wang <chiawei_wang@aspeedtech.com>

diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
index 1ea116b..0082177 100644 (file)
--- a/drivers/crypto/Kconfig
+++ b/drivers/crypto/Kconfig
@@ -1,5 +1,7 @@
 menu "Hardware crypto devices"
 
+source drivers/crypto/hash/Kconfig
+
 source drivers/crypto/fsl/Kconfig
 
 endmenu

diff --git a/drivers/crypto/Makefile b/drivers/crypto/Makefile
index efbd1d3..4a12b56 100644 (file)
--- a/drivers/crypto/Makefile
+++ b/drivers/crypto/Makefile
@@ -6,3 +6,4 @@
 obj-$(CONFIG_EXYNOS_ACE_SHA)   += ace_sha.o
 obj-y += rsa_mod_exp/
 obj-y += fsl/
+obj-y += hash/

diff --git a/drivers/crypto/hash/Kconfig b/drivers/crypto/hash/Kconfig
new file mode 100644 (file)
index 0000000..e226144
--- /dev/null
+++ b/drivers/crypto/hash/Kconfig
@@ -0,0 +1,5 @@
+config DM_HASH
+       bool "Enable Driver Model for Hash"
+       depends on DM
+       help
+         If you want to use driver model for Hash, say Y.

diff --git a/drivers/crypto/hash/Makefile b/drivers/crypto/hash/Makefile
new file mode 100644 (file)
index 0000000..83acf3d
--- /dev/null
+++ b/drivers/crypto/hash/Makefile
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0+
+#
+# Copyright (c) 2021 ASPEED Technology Inc.
+
+obj-$(CONFIG_DM_HASH) += hash-uclass.o

diff --git a/drivers/crypto/hash/hash-uclass.c b/drivers/crypto/hash/hash-uclass.c
new file mode 100644 (file)
index 0000000..446eb9e
--- /dev/null
+++ b/drivers/crypto/hash/hash-uclass.c
@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (c) 2021 ASPEED Technology Inc.
+ * Author: ChiaWei Wang <chiawei_wang@aspeedtech.com>
+ */
+
+#define LOG_CATEGORY UCLASS_HASH
+
+#include <common.h>
+#include <dm.h>
+#include <asm/global_data.h>
+#include <u-boot/hash.h>
+#include <errno.h>
+#include <fdtdec.h>
+#include <malloc.h>
+#include <asm/io.h>
+#include <linux/list.h>
+
+struct hash_info {
+       char *name;
+       uint32_t digest_size;
+};
+
+static const struct hash_info hash_info[HASH_ALGO_NUM] = {
+       [HASH_ALGO_CRC16_CCITT] = { "crc16-ccitt", 2 },
+       [HASH_ALGO_CRC32] = { "crc32", 4 },
+       [HASH_ALGO_MD5] = { "md5", 16 },
+       [HASH_ALGO_SHA1] = { "sha1", 20 },
+       [HASH_ALGO_SHA256] = { "sha256", 32 },
+       [HASH_ALGO_SHA384] = { "sha384", 48 },
+       [HASH_ALGO_SHA512] = { "sha512", 64},
+};
+
+enum HASH_ALGO hash_algo_lookup_by_name(const char *name)
+{
+       int i;
+
+       if (!name)
+               return HASH_ALGO_INVALID;
+
+       for (i = 0; i < HASH_ALGO_NUM; ++i)
+               if (!strcmp(name, hash_info[i].name))
+                       return i;
+
+       return HASH_ALGO_INVALID;
+}
+
+ssize_t hash_algo_digest_size(enum HASH_ALGO algo)
+{
+       if (algo >= HASH_ALGO_NUM)
+               return -EINVAL;
+
+       return hash_info[algo].digest_size;
+}
+
+const char *hash_algo_name(enum HASH_ALGO algo)
+{
+       if (algo >= HASH_ALGO_NUM)
+               return NULL;
+
+       return hash_info[algo].name;
+}
+
+int hash_digest(struct udevice *dev, enum HASH_ALGO algo,
+               const void *ibuf, const uint32_t ilen,
+               void *obuf)
+{
+       struct hash_ops *ops = (struct hash_ops *)device_get_ops(dev);
+
+       if (!ops->hash_digest)
+               return -ENOSYS;
+
+       return ops->hash_digest(dev, algo, ibuf, ilen, obuf);
+}
+
+int hash_digest_wd(struct udevice *dev, enum HASH_ALGO algo,
+                  const void *ibuf, const uint32_t ilen,
+                  void *obuf, uint32_t chunk_sz)
+{
+       struct hash_ops *ops = (struct hash_ops *)device_get_ops(dev);
+
+       if (!ops->hash_digest_wd)
+               return -ENOSYS;
+
+       return ops->hash_digest_wd(dev, algo, ibuf, ilen, obuf, chunk_sz);
+}
+
+int hash_init(struct udevice *dev, enum HASH_ALGO algo, void **ctxp)
+{
+       struct hash_ops *ops = (struct hash_ops *)device_get_ops(dev);
+
+       if (!ops->hash_init)
+               return -ENOSYS;
+
+       return ops->hash_init(dev, algo, ctxp);
+}
+
+int hash_update(struct udevice *dev, void *ctx, const void *ibuf, const uint32_t ilen)
+{
+       struct hash_ops *ops = (struct hash_ops *)device_get_ops(dev);
+
+       if (!ops->hash_update)
+               return -ENOSYS;
+
+       return ops->hash_update(dev, ctx, ibuf, ilen);
+}
+
+int hash_finish(struct udevice *dev, void *ctx, void *obuf)
+{
+       struct hash_ops *ops = (struct hash_ops *)device_get_ops(dev);
+
+       if (!ops->hash_finish)
+               return -ENOSYS;
+
+       return ops->hash_finish(dev, ctx, obuf);
+}
+
+UCLASS_DRIVER(hash) = {
+       .id     = UCLASS_HASH,
+       .name   = "hash",
+};

diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h
index e7edd40..3768432 100644 (file)
--- a/include/dm/uclass-id.h
+++ b/include/dm/uclass-id.h
@@ -54,6 +54,7 @@ enum uclass_id {
        UCLASS_FIRMWARE,        /* Firmware */
        UCLASS_FS_FIRMWARE_LOADER,              /* Generic loader */
        UCLASS_GPIO,            /* Bank of general-purpose I/O pins */
+       UCLASS_HASH,            /* Hash device */
        UCLASS_HWSPINLOCK,      /* Hardware semaphores */
        UCLASS_I2C,             /* I2C bus */
        UCLASS_I2C_EEPROM,      /* I2C EEPROM device */

diff --git a/include/u-boot/hash.h b/include/u-boot/hash.h
new file mode 100644 (file)
index 0000000..f9d47a9
--- /dev/null
+++ b/include/u-boot/hash.h
@@ -0,0 +1,61 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * Copyright (c) 2021 ASPEED Technology Inc.
+ */
+#ifndef _UBOOT_HASH_H
+#define _UBOOT_HASH_H
+
+enum HASH_ALGO {
+       HASH_ALGO_CRC16_CCITT,
+       HASH_ALGO_CRC32,
+       HASH_ALGO_MD5,
+       HASH_ALGO_SHA1,
+       HASH_ALGO_SHA256,
+       HASH_ALGO_SHA384,
+       HASH_ALGO_SHA512,
+
+       HASH_ALGO_NUM,
+
+       HASH_ALGO_INVALID = 0xffffffff,
+};
+
+/* general APIs for hash algo information */
+enum HASH_ALGO hash_algo_lookup_by_name(const char *name);
+ssize_t hash_algo_digest_size(enum HASH_ALGO algo);
+const char *hash_algo_name(enum HASH_ALGO algo);
+
+/* device-dependent APIs */
+int hash_digest(struct udevice *dev, enum HASH_ALGO algo,
+               const void *ibuf, const uint32_t ilen,
+               void *obuf);
+int hash_digest_wd(struct udevice *dev, enum HASH_ALGO algo,
+                  const void *ibuf, const uint32_t ilen,
+                  void *obuf, uint32_t chunk_sz);
+int hash_init(struct udevice *dev, enum HASH_ALGO algo, void **ctxp);
+int hash_update(struct udevice *dev, void *ctx, const void *ibuf, const uint32_t ilen);
+int hash_finish(struct udevice *dev, void *ctx, void *obuf);
+
+/*
+ * struct hash_ops - Driver model for Hash operations
+ *
+ * The uclass interface is implemented by all hash devices
+ * which use driver model.
+ */
+struct hash_ops {
+       /* progressive operations */
+       int (*hash_init)(struct udevice *dev, enum HASH_ALGO algo, void **ctxp);
+       int (*hash_update)(struct udevice *dev, void *ctx, const void *ibuf, const uint32_t ilen);
+       int (*hash_finish)(struct udevice *dev, void *ctx, void *obuf);
+
+       /* all-in-one operation */
+       int (*hash_digest)(struct udevice *dev, enum HASH_ALGO algo,
+                          const void *ibuf, const uint32_t ilen,
+                          void *obuf);
+
+       /* all-in-one operation with watchdog triggering every chunk_sz */
+       int (*hash_digest_wd)(struct udevice *dev, enum HASH_ALGO algo,
+                             const void *ibuf, const uint32_t ilen,
+                             void *obuf, uint32_t chunk_sz);
+};
+
+#endif