[deliverable/linux.git] / drivers / char / hw_random / nomadik-rng.c

/*
 * Nomadik RNG support
 *  Copyright 2009 Alessandro Rubini
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/amba/bus.h>
#include <linux/hw_random.h>
#include <linux/io.h>
#include <linux/clk.h>
#include <linux/err.h>

static struct clk *rng_clk;

static int nmk_rng_read(struct hwrng *rng, void *data, size_t max, bool wait)
{
	void __iomem *base = (void __iomem *)rng->priv;

	/*
	 * The register is 32 bits and gives 16 random bits (low half).
	 * A subsequent read will delay the core for 400ns, so we just read
	 * once and accept the very unlikely very small delay, even if wait==0.
	 */
	*(u16 *)data = __raw_readl(base + 8) & 0xffff;
	return 2;
}

/* we have at most one RNG per machine, granted */
static struct hwrng nmk_rng = {
	.name		= "nomadik",
	.read		= nmk_rng_read,
};

static int nmk_rng_probe(struct amba_device *dev, const struct amba_id *id)
{
	void __iomem *base;
	int ret;

	rng_clk = devm_clk_get(&dev->dev, NULL);
	if (IS_ERR(rng_clk)) {
		dev_err(&dev->dev, "could not get rng clock\n");
		ret = PTR_ERR(rng_clk);
		return ret;
	}

	clk_prepare_enable(rng_clk);

	ret = amba_request_regions(dev, dev->dev.init_name);
	if (ret)
		goto out_clk;
	ret = -ENOMEM;
	base = devm_ioremap(&dev->dev, dev->res.start,
			    resource_size(&dev->res));
	if (!base)
		goto out_release;
	nmk_rng.priv = (unsigned long)base;
	ret = hwrng_register(&nmk_rng);
	if (ret)
		goto out_release;
	return 0;

out_release:
	amba_release_regions(dev);
out_clk:
	clk_disable(rng_clk);
	return ret;
}

static int nmk_rng_remove(struct amba_device *dev)
{
	hwrng_unregister(&nmk_rng);
	amba_release_regions(dev);
	clk_disable(rng_clk);
	return 0;
}

static struct amba_id nmk_rng_ids[] = {
	{
		.id	= 0x000805e1,
		.mask	= 0x000fffff, /* top bits are rev and cfg: accept all */
	},
	{0, 0},
};

MODULE_DEVICE_TABLE(amba, nmk_rng_ids);

static struct amba_driver nmk_rng_driver = {
	.drv = {
		.owner = THIS_MODULE,
		.name = "rng",
		},
	.probe = nmk_rng_probe,
	.remove = nmk_rng_remove,
	.id_table = nmk_rng_ids,
};

module_amba_driver(nmk_rng_driver);

MODULE_LICENSE("GPL");
Commit	Line	Data
bc85b25e AR	1	/*
	2	* Nomadik RNG support
	3	* Copyright 2009 Alessandro Rubini
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*/
	10
	11	#include <linux/kernel.h>
	12	#include <linux/module.h>
bc85b25e AR	13	#include <linux/device.h>
	14	#include <linux/amba/bus.h>
	15	#include <linux/hw_random.h>
	16	#include <linux/io.h>
1944cc89 SK	17	#include <linux/clk.h>
	18	#include <linux/err.h>
	19
	20	static struct clk *rng_clk;
bc85b25e AR	21
	22	static int nmk_rng_read(struct hwrng rng, void data, size_t max, bool wait)
	23	{
	24	void __iomem base = (void __iomem )rng->priv;
	25
	26	/*
	27	* The register is 32 bits and gives 16 random bits (low half).
	28	* A subsequent read will delay the core for 400ns, so we just read
	29	* once and accept the very unlikely very small delay, even if wait==0.
	30	*/
	31	(u16 )data = __raw_readl(base + 8) & 0xffff;
	32	return 2;
	33	}
	34
	35	/* we have at most one RNG per machine, granted */
	36	static struct hwrng nmk_rng = {
	37	.name = "nomadik",
	38	.read = nmk_rng_read,
	39	};
	40
aa25afad	41	static int nmk_rng_probe(struct amba_device dev, const struct amba_id id)
bc85b25e AR	42	{
	43	void __iomem *base;
	44	int ret;
	45
1655c240	46	rng_clk = devm_clk_get(&dev->dev, NULL);
1944cc89 SK	47	if (IS_ERR(rng_clk)) {
	48	dev_err(&dev->dev, "could not get rng clock\n");
	49	ret = PTR_ERR(rng_clk);
	50	return ret;
	51	}
	52
beca35d0	53	clk_prepare_enable(rng_clk);
1944cc89	54
bc85b25e AR	55	ret = amba_request_regions(dev, dev->dev.init_name);
bc85b25e AR	56	if (ret)
2725ae17	57	goto out_clk;
bc85b25e	58	ret = -ENOMEM;
1655c240 JH	59	base = devm_ioremap(&dev->dev, dev->res.start,
1655c240 JH	60	resource_size(&dev->res));
bc85b25e AR	61	if (!base)
	62	goto out_release;
	63	nmk_rng.priv = (unsigned long)base;
	64	ret = hwrng_register(&nmk_rng);
	65	if (ret)
1655c240	66	goto out_release;
bc85b25e AR	67	return 0;
bc85b25e AR	68
bc85b25e AR	69	out_release:
bc85b25e AR	70	amba_release_regions(dev);
2725ae17	71	out_clk:
1944cc89	72	clk_disable(rng_clk);
bc85b25e AR	73	return ret;
	74	}
	75
	76	static int nmk_rng_remove(struct amba_device *dev)
	77	{
bc85b25e	78	hwrng_unregister(&nmk_rng);
bc85b25e	79	amba_release_regions(dev);
1944cc89	80	clk_disable(rng_clk);
bc85b25e AR	81	return 0;
	82	}
	83
	84	static struct amba_id nmk_rng_ids[] = {
	85	{
	86	.id = 0x000805e1,
	87	.mask = 0x000fffff, /* top bits are rev and cfg: accept all */
	88	},
	89	{0, 0},
	90	};
	91
4e3f3d53 DM	92	MODULE_DEVICE_TABLE(amba, nmk_rng_ids);
4e3f3d53 DM	93
bc85b25e AR	94	static struct amba_driver nmk_rng_driver = {
	95	.drv = {
	96	.owner = THIS_MODULE,
	97	.name = "rng",
	98	},
	99	.probe = nmk_rng_probe,
	100	.remove = nmk_rng_remove,
	101	.id_table = nmk_rng_ids,
	102	};
	103
9e5ed094	104	module_amba_driver(nmk_rng_driver);
bc85b25e AR	105
bc85b25e AR	106	MODULE_LICENSE("GPL");