| // SPDX-License-Identifier: GPL-2.0-or-later OR MIT | |
| /* | |
| * Copyright (c) 2023 David Yang | |
| */ | |
| #include <linux/err.h> | |
| #include <linux/hw_random.h> | |
| #include <linux/io.h> | |
| #include <linux/iopoll.h> | |
| #include <linux/kernel.h> | |
| #include <linux/module.h> | |
| #include <linux/platform_device.h> | |
| #define RNG_CTRL 0x0 | |
| #define RNG_SOURCE GENMASK(1, 0) | |
| #define DROP_ENABLE BIT(5) | |
| #define POST_PROCESS_ENABLE BIT(7) | |
| #define POST_PROCESS_DEPTH GENMASK(15, 8) | |
| #define RNG_NUMBER 0x4 | |
| #define RNG_STAT 0x8 | |
| #define DATA_COUNT GENMASK(2, 0) /* max 4 */ | |
| struct histb_rng_priv { | |
| struct hwrng rng; | |
| void __iomem *base; | |
| }; | |
| /* | |
| * Observed: | |
| * depth = 1 -> ~1ms | |
| * depth = 255 -> ~16ms | |
| */ | |
| static int histb_rng_wait(void __iomem *base) | |
| { | |
| u32 val; | |
| return readl_relaxed_poll_timeout(base + RNG_STAT, val, | |
| val & DATA_COUNT, 1000, 30 * 1000); | |
| } | |
| static void histb_rng_init(void __iomem *base, unsigned int depth) | |
| { | |
| u32 val; | |
| val = readl_relaxed(base + RNG_CTRL); | |
| val &= ~RNG_SOURCE; | |
| val |= 2; | |
| val &= ~POST_PROCESS_DEPTH; | |
| val |= min(depth, 0xffu) << 8; | |
| val |= POST_PROCESS_ENABLE; | |
| val |= DROP_ENABLE; | |
| writel_relaxed(val, base + RNG_CTRL); | |
| } | |
| static int histb_rng_read(struct hwrng *rng, void *data, size_t max, bool wait) | |
| { | |
| struct histb_rng_priv *priv = container_of(rng, typeof(*priv), rng); | |
| void __iomem *base = priv->base; | |
| for (int i = 0; i < max; i += sizeof(u32)) { | |
| if (!(readl_relaxed(base + RNG_STAT) & DATA_COUNT)) { | |
| if (!wait) | |
| return i; | |
| if (histb_rng_wait(base)) { | |
| pr_err("failed to generate random number, generated %d\n", | |
| i); | |
| return i ? i : -ETIMEDOUT; | |
| } | |
| } | |
| *(u32 *) (data + i) = readl_relaxed(base + RNG_NUMBER); | |
| } | |
| return max; | |
| } | |
| static unsigned int histb_rng_get_depth(void __iomem *base) | |
| { | |
| return (readl_relaxed(base + RNG_CTRL) & POST_PROCESS_DEPTH) >> 8; | |
| } | |
| static ssize_t | |
| depth_show(struct device *dev, struct device_attribute *attr, char *buf) | |
| { | |
| struct histb_rng_priv *priv = dev_get_drvdata(dev); | |
| void __iomem *base = priv->base; | |
| return sprintf(buf, "%u\n", histb_rng_get_depth(base)); | |
| } | |
| static ssize_t | |
| depth_store(struct device *dev, struct device_attribute *attr, | |
| const char *buf, size_t count) | |
| { | |
| struct histb_rng_priv *priv = dev_get_drvdata(dev); | |
| void __iomem *base = priv->base; | |
| unsigned int depth; | |
| if (kstrtouint(buf, 0, &depth)) | |
| return -ERANGE; | |
| histb_rng_init(base, depth); | |
| return count; | |
| } | |
| static DEVICE_ATTR_RW(depth); | |
| static struct attribute *histb_rng_attrs[] = { | |
| &dev_attr_depth.attr, | |
| NULL, | |
| }; | |
| ATTRIBUTE_GROUPS(histb_rng); | |
| static int histb_rng_probe(struct platform_device *pdev) | |
| { | |
| struct device *dev = &pdev->dev; | |
| struct histb_rng_priv *priv; | |
| void __iomem *base; | |
| int ret; | |
| priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); | |
| if (!priv) | |
| return -ENOMEM; | |
| base = devm_platform_ioremap_resource(pdev, 0); | |
| if (IS_ERR(base)) | |
| return PTR_ERR(base); | |
| histb_rng_init(base, 144); | |
| if (histb_rng_wait(base)) { | |
| dev_err(dev, "cannot bring up device\n"); | |
| return -ENODEV; | |
| } | |
| priv->base = base; | |
| priv->rng.name = pdev->name; | |
| priv->rng.read = histb_rng_read; | |
| ret = devm_hwrng_register(dev, &priv->rng); | |
| if (ret) { | |
| dev_err(dev, "failed to register hwrng: %d\n", ret); | |
| return ret; | |
| } | |
| platform_set_drvdata(pdev, priv); | |
| dev_set_drvdata(dev, priv); | |
| return 0; | |
| } | |
| static const struct of_device_id histb_rng_of_match[] = { | |
| { .compatible = "hisilicon,histb-rng", }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(of, histb_rng_of_match); | |
| static struct platform_driver histb_rng_driver = { | |
| .probe = histb_rng_probe, | |
| .driver = { | |
| .name = "histb-rng", | |
| .of_match_table = histb_rng_of_match, | |
| .dev_groups = histb_rng_groups, | |
| }, | |
| }; | |
| module_platform_driver(histb_rng_driver); | |
| MODULE_DESCRIPTION("Hisilicon STB random number generator driver"); | |
| MODULE_LICENSE("Dual MIT/GPL"); | |
| MODULE_AUTHOR("David Yang <mmyangfl@gmail.com>"); |