SSL histb-rng.c

// 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/mod_devicetable.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>");