hwrng: timeriomem - Improve performance for sub-jiffie update periods

 */

#include <linux/completion.h>

#include <linux/delay.h>

#include <linux/hrtimer.h>

#include <linux/hw_random.h>

#include <linux/io.h>

#include <linux/jiffies.h>

#include <linux/ktime.h>

#include <linux/module.h>

#include <linux/of.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/time.h>

#include <linux/timeriomem-rng.h>

#include <linux/timer.h>

struct timeriomem_rng_private {

	void __iomem		*io_base;

	unsigned int		expires;

	unsigned int		period;

	ktime_t			period;

	unsigned int		present:1;

	struct timer_list	timer;

	struct hrtimer		timer;

	struct completion	completion;

	struct hwrng		rng_ops;

{

	struct timeriomem_rng_private *priv =

		container_of(hwrng, struct timeriomem_rng_private, rng_ops);

	unsigned long cur;

	s32 delay;

	int retval = 0;

	int period_us = ktime_to_us(priv->period);

	/* The RNG provides 32-bit per read.  Ensure there is enough space. */

	/*

	 * The RNG provides 32-bits per read.  Ensure there is enough space for

	 * at minimum one read.

	 */

	if (max < sizeof(u32))

		return 0;

	wait_for_completion(&priv->completion);

	do {

		/*

		 * After the first read, all additional reads will need to wait

		 * for the RNG to generate new data.  Since the period can have

		 * a wide range of values (1us to 1s have been observed), allow

		 * for 1% tolerance in the sleep time rather than a fixed value.

		 */

		if (retval > 0)

			usleep_range(period_us,

					period_us + min(1, period_us / 100));

		*(u32 *)data = readl(priv->io_base);

		retval += sizeof(u32);

		data += sizeof(u32);

		max -= sizeof(u32);

	} while (wait && max > sizeof(u32));

	/*

	 * Block any new callers until the RNG has had time to generate new

	 * data.

	 */

	cur = jiffies;

	delay = cur - priv->expires;

	delay = priv->period - (delay % priv->period);

	priv->expires = cur + delay;

	priv->present = 0;

	reinit_completion(&priv->completion);

	mod_timer(&priv->timer, priv->expires);

	hrtimer_forward_now(&priv->timer, priv->period);

	hrtimer_restart(&priv->timer);

	return 4;

	return retval;

}

static void timeriomem_rng_trigger(unsigned long data)

static enum hrtimer_restart timeriomem_rng_trigger(struct hrtimer *timer)

{

	struct timeriomem_rng_private *priv

			= (struct timeriomem_rng_private *)data;

		= container_of(timer, struct timeriomem_rng_private, timer);

	priv->present = 1;

	complete(&priv->completion);

	return HRTIMER_NORESTART;

}

static int timeriomem_rng_probe(struct platform_device *pdev)

		period = pdata->period;

	}

	priv->period = usecs_to_jiffies(period);

	if (priv->period < 1) {

		dev_err(&pdev->dev, "period is less than one jiffy\n");

		return -EINVAL;

	}

	priv->expires	= jiffies;

	priv->present	= 1;

	priv->period = ns_to_ktime(period * NSEC_PER_USEC);

	init_completion(&priv->completion);

	complete(&priv->completion);

	setup_timer(&priv->timer, timeriomem_rng_trigger, (unsigned long)priv);

	hrtimer_init(&priv->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);

	priv->timer.function = timeriomem_rng_trigger;

	priv->rng_ops.name = dev_name(&pdev->dev);

	priv->rng_ops.read = timeriomem_rng_read;

	priv->io_base = devm_ioremap_resource(&pdev->dev, res);

	if (IS_ERR(priv->io_base)) {

		err = PTR_ERR(priv->io_base);

		goto out_timer;

		return PTR_ERR(priv->io_base);

	}

	/* Assume random data is already available. */

	priv->present = 1;

	complete(&priv->completion);

	err = hwrng_register(&priv->rng_ops);

	if (err) {

		dev_err(&pdev->dev, "problem registering\n");

		goto out_timer;

		return err;

	}

	dev_info(&pdev->dev, "32bits from 0x%p @ %dus\n",

			priv->io_base, period);

	return 0;

out_timer:

	del_timer_sync(&priv->timer);

	return err;

}

static int timeriomem_rng_remove(struct platform_device *pdev)

	struct timeriomem_rng_private *priv = platform_get_drvdata(pdev);

	hwrng_unregister(&priv->rng_ops);

	del_timer_sync(&priv->timer);

	hrtimer_cancel(&priv->timer);

	return 0;

}