drivers/char/hw_random/bcm74110-rng.c

Source file repositories/reference/linux-study-clean/drivers/char/hw_random/bcm74110-rng.c

File Facts

System
Linux kernel
Corpus path
drivers/char/hw_random/bcm74110-rng.c
Extension
.c
Size
3160 bytes
Lines
126
Domain
Driver Families
Bucket
drivers/char
Inferred role
Driver Families: implementation source
Status
source implementation candidate

Why This File Exists

Repeatable hardware-adapter layer. Deep compatibility for every driver is out of scope; this atlas records patterns, probe lifecycles, bus glue, IRQ/DMA usage, and links back to core abstractions.

Dependency Surface

Detected Declarations

Annotated Snippet

struct bcm74110_priv {
	void __iomem *base;
};

static inline int bcm74110_rng_fifo_count(void __iomem *mem)
{
	return readl_relaxed(mem) & HOST_FIFO_COUNT_MASK;
}

static int bcm74110_rng_read(struct hwrng *rng, void *buf, size_t max,
			bool wait)
{
	struct bcm74110_priv *priv = (struct bcm74110_priv *)rng->priv;
	void __iomem *fc_addr = priv->base + HOST_FIFO_COUNT;
	void __iomem *fd_addr = priv->base + HOST_FIFO_DATA;
	unsigned underrun_count = 0;
	u32 max_words = max / sizeof(u32);
	u32 num_words;
	unsigned i;

	/*
	 * We need to check how many words are available in the RNG FIFO. If
	 * there aren't any, we need to wait for some to become available.
	 */
	while ((num_words = bcm74110_rng_fifo_count(fc_addr)) == 0) {
		if (!wait)
			return 0;
		/*
		 * As a precaution, limit how long we wait. If the FIFO doesn't
		 * refill within the allotted time, return 0 (=no data) to the
		 * caller.
		 */
		if (likely(underrun_count < FIFO_DELAY_MAX_COUNT))
			usleep_range(FIFO_DELAY_MIN_US, FIFO_DELAY_MAX_US);
		else
			return 0;
		underrun_count++;
	}
	if (num_words > max_words)
		num_words = max_words;

	/* Bail early if we run out of random numbers unexpectedly */
	for (i = 0; i < num_words && bcm74110_rng_fifo_count(fc_addr) > 0; i++)
		((u32 *)buf)[i] = readl_relaxed(fd_addr);

	return i * sizeof(u32);
}

static struct hwrng bcm74110_hwrng = {
	.read = bcm74110_rng_read,
};

static int bcm74110_rng_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct bcm74110_priv *priv;
	int rc;

	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	bcm74110_hwrng.name = pdev->name;
	bcm74110_hwrng.priv = (unsigned long)priv;

	priv->base = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(priv->base))
		return PTR_ERR(priv->base);

	rc = devm_hwrng_register(dev, &bcm74110_hwrng);
	if (rc)
		dev_err(dev, "hwrng registration failed (%d)\n", rc);
	else
		dev_info(dev, "hwrng registered\n");

	return rc;
}

static const struct of_device_id bcm74110_rng_match[] = {
	{ .compatible	= "brcm,bcm74110-rng", },
	{},
};
MODULE_DEVICE_TABLE(of, bcm74110_rng_match);

static struct platform_driver bcm74110_rng_driver = {
	.driver = {
		.name = KBUILD_MODNAME,
		.of_match_table = bcm74110_rng_match,
	},
	.probe	= bcm74110_rng_probe,

Annotation

Implementation Notes