Thomas Gleixner | d2912cb | 2019-06-04 10:11:33 +0200 | [diff] [blame^] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 2 | /* |
| 3 | * drivers/char/hw_random/timeriomem-rng.c |
| 4 | * |
| 5 | * Copyright (C) 2009 Alexander Clouter <alex@digriz.org.uk> |
| 6 | * |
| 7 | * Derived from drivers/char/hw_random/omap-rng.c |
| 8 | * Copyright 2005 (c) MontaVista Software, Inc. |
| 9 | * Author: Deepak Saxena <dsaxena@plexity.net> |
| 10 | * |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 11 | * Overview: |
| 12 | * This driver is useful for platforms that have an IO range that provides |
| 13 | * periodic random data from a single IO memory address. All the platform |
| 14 | * has to do is provide the address and 'wait time' that new data becomes |
| 15 | * available. |
| 16 | * |
| 17 | * TODO: add support for reading sizes other than 32bits and masking |
| 18 | */ |
| 19 | |
Rick Altherr | 7acd4de | 2017-04-05 16:20:58 -0700 | [diff] [blame] | 20 | #include <linux/completion.h> |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 21 | #include <linux/delay.h> |
| 22 | #include <linux/hrtimer.h> |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 23 | #include <linux/hw_random.h> |
| 24 | #include <linux/io.h> |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 25 | #include <linux/ktime.h> |
Rick Altherr | 7acd4de | 2017-04-05 16:20:58 -0700 | [diff] [blame] | 26 | #include <linux/module.h> |
| 27 | #include <linux/of.h> |
| 28 | #include <linux/platform_device.h> |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 29 | #include <linux/slab.h> |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 30 | #include <linux/time.h> |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 31 | #include <linux/timeriomem-rng.h> |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 32 | |
Rick Altherr | 5ab693e | 2017-04-05 16:20:59 -0700 | [diff] [blame] | 33 | struct timeriomem_rng_private { |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 34 | void __iomem *io_base; |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 35 | ktime_t period; |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 36 | unsigned int present:1; |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 37 | |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 38 | struct hrtimer timer; |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 39 | struct completion completion; |
| 40 | |
Rick Altherr | 5ab693e | 2017-04-05 16:20:59 -0700 | [diff] [blame] | 41 | struct hwrng rng_ops; |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 42 | }; |
| 43 | |
Rick Altherr | 7acd4de | 2017-04-05 16:20:58 -0700 | [diff] [blame] | 44 | static int timeriomem_rng_read(struct hwrng *hwrng, void *data, |
| 45 | size_t max, bool wait) |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 46 | { |
Rick Altherr | 5ab693e | 2017-04-05 16:20:59 -0700 | [diff] [blame] | 47 | struct timeriomem_rng_private *priv = |
| 48 | container_of(hwrng, struct timeriomem_rng_private, rng_ops); |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 49 | int retval = 0; |
| 50 | int period_us = ktime_to_us(priv->period); |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 51 | |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 52 | /* |
Rick Altherr | 7acd4de | 2017-04-05 16:20:58 -0700 | [diff] [blame] | 53 | * There may not have been enough time for new data to be generated |
| 54 | * since the last request. If the caller doesn't want to wait, let them |
| 55 | * bail out. Otherwise, wait for the completion. If the new data has |
| 56 | * already been generated, the completion should already be available. |
| 57 | */ |
| 58 | if (!wait && !priv->present) |
| 59 | return 0; |
| 60 | |
| 61 | wait_for_completion(&priv->completion); |
| 62 | |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 63 | do { |
| 64 | /* |
| 65 | * After the first read, all additional reads will need to wait |
| 66 | * for the RNG to generate new data. Since the period can have |
| 67 | * a wide range of values (1us to 1s have been observed), allow |
| 68 | * for 1% tolerance in the sleep time rather than a fixed value. |
| 69 | */ |
| 70 | if (retval > 0) |
| 71 | usleep_range(period_us, |
| 72 | period_us + min(1, period_us / 100)); |
| 73 | |
| 74 | *(u32 *)data = readl(priv->io_base); |
| 75 | retval += sizeof(u32); |
| 76 | data += sizeof(u32); |
| 77 | max -= sizeof(u32); |
| 78 | } while (wait && max > sizeof(u32)); |
Rick Altherr | 7acd4de | 2017-04-05 16:20:58 -0700 | [diff] [blame] | 79 | |
| 80 | /* |
| 81 | * Block any new callers until the RNG has had time to generate new |
| 82 | * data. |
| 83 | */ |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 84 | priv->present = 0; |
Wolfram Sang | 16735d0 | 2013-11-14 14:32:02 -0800 | [diff] [blame] | 85 | reinit_completion(&priv->completion); |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 86 | hrtimer_forward_now(&priv->timer, priv->period); |
| 87 | hrtimer_restart(&priv->timer); |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 88 | |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 89 | return retval; |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 90 | } |
| 91 | |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 92 | static enum hrtimer_restart timeriomem_rng_trigger(struct hrtimer *timer) |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 93 | { |
Rick Altherr | 5ab693e | 2017-04-05 16:20:59 -0700 | [diff] [blame] | 94 | struct timeriomem_rng_private *priv |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 95 | = container_of(timer, struct timeriomem_rng_private, timer); |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 96 | |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 97 | priv->present = 1; |
| 98 | complete(&priv->completion); |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 99 | |
| 100 | return HRTIMER_NORESTART; |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 101 | } |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 102 | |
Greg Kroah-Hartman | bcd2982 | 2012-12-21 15:12:08 -0800 | [diff] [blame] | 103 | static int timeriomem_rng_probe(struct platform_device *pdev) |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 104 | { |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 105 | struct timeriomem_rng_data *pdata = pdev->dev.platform_data; |
Rick Altherr | 5ab693e | 2017-04-05 16:20:59 -0700 | [diff] [blame] | 106 | struct timeriomem_rng_private *priv; |
Alexander Clouter | 08ced85 | 2009-06-03 19:28:03 +1000 | [diff] [blame] | 107 | struct resource *res; |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 108 | int err = 0; |
| 109 | int period; |
| 110 | |
Alexander Clouter | b149a30 | 2013-03-31 17:34:51 +0100 | [diff] [blame] | 111 | if (!pdev->dev.of_node && !pdata) { |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 112 | dev_err(&pdev->dev, "timeriomem_rng_data is missing\n"); |
| 113 | return -EINVAL; |
| 114 | } |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 115 | |
Alexander Clouter | 3341323 | 2009-03-27 12:59:54 +0800 | [diff] [blame] | 116 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
Alexander Clouter | 3341323 | 2009-03-27 12:59:54 +0800 | [diff] [blame] | 117 | if (!res) |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 118 | return -ENXIO; |
Alexander Clouter | 3341323 | 2009-03-27 12:59:54 +0800 | [diff] [blame] | 119 | |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 120 | if (res->start % 4 != 0 || resource_size(res) != 4) { |
| 121 | dev_err(&pdev->dev, |
| 122 | "address must be four bytes wide and aligned\n"); |
| 123 | return -EINVAL; |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 124 | } |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 125 | |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 126 | /* Allocate memory for the device structure (and zero it) */ |
Jingoo Han | 93b7f9c | 2014-02-27 14:07:52 +0900 | [diff] [blame] | 127 | priv = devm_kzalloc(&pdev->dev, |
Rick Altherr | 5ab693e | 2017-04-05 16:20:59 -0700 | [diff] [blame] | 128 | sizeof(struct timeriomem_rng_private), GFP_KERNEL); |
Jingoo Han | 7bad94a | 2014-04-29 17:16:42 +0900 | [diff] [blame] | 129 | if (!priv) |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 130 | return -ENOMEM; |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 131 | |
| 132 | platform_set_drvdata(pdev, priv); |
| 133 | |
Alexander Clouter | b149a30 | 2013-03-31 17:34:51 +0100 | [diff] [blame] | 134 | if (pdev->dev.of_node) { |
| 135 | int i; |
| 136 | |
| 137 | if (!of_property_read_u32(pdev->dev.of_node, |
| 138 | "period", &i)) |
| 139 | period = i; |
| 140 | else { |
| 141 | dev_err(&pdev->dev, "missing period\n"); |
Jingoo Han | 93b7f9c | 2014-02-27 14:07:52 +0900 | [diff] [blame] | 142 | return -EINVAL; |
Alexander Clouter | b149a30 | 2013-03-31 17:34:51 +0100 | [diff] [blame] | 143 | } |
Rick Altherr | 284e763 | 2017-05-22 14:12:24 -0700 | [diff] [blame] | 144 | |
| 145 | if (!of_property_read_u32(pdev->dev.of_node, |
| 146 | "quality", &i)) |
| 147 | priv->rng_ops.quality = i; |
| 148 | else |
| 149 | priv->rng_ops.quality = 0; |
Jingoo Han | 93b7f9c | 2014-02-27 14:07:52 +0900 | [diff] [blame] | 150 | } else { |
Alexander Clouter | b149a30 | 2013-03-31 17:34:51 +0100 | [diff] [blame] | 151 | period = pdata->period; |
Rick Altherr | 284e763 | 2017-05-22 14:12:24 -0700 | [diff] [blame] | 152 | priv->rng_ops.quality = pdata->quality; |
Jingoo Han | 93b7f9c | 2014-02-27 14:07:52 +0900 | [diff] [blame] | 153 | } |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 154 | |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 155 | priv->period = ns_to_ktime(period * NSEC_PER_USEC); |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 156 | init_completion(&priv->completion); |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 157 | hrtimer_init(&priv->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS); |
| 158 | priv->timer.function = timeriomem_rng_trigger; |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 159 | |
Rick Altherr | 5ab693e | 2017-04-05 16:20:59 -0700 | [diff] [blame] | 160 | priv->rng_ops.name = dev_name(&pdev->dev); |
| 161 | priv->rng_ops.read = timeriomem_rng_read; |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 162 | |
Jingoo Han | 93b7f9c | 2014-02-27 14:07:52 +0900 | [diff] [blame] | 163 | priv->io_base = devm_ioremap_resource(&pdev->dev, res); |
| 164 | if (IS_ERR(priv->io_base)) { |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 165 | return PTR_ERR(priv->io_base); |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 166 | } |
| 167 | |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 168 | /* Assume random data is already available. */ |
| 169 | priv->present = 1; |
| 170 | complete(&priv->completion); |
| 171 | |
Rick Altherr | 5ab693e | 2017-04-05 16:20:59 -0700 | [diff] [blame] | 172 | err = hwrng_register(&priv->rng_ops); |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 173 | if (err) { |
| 174 | dev_err(&pdev->dev, "problem registering\n"); |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 175 | return err; |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 176 | } |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 177 | |
| 178 | dev_info(&pdev->dev, "32bits from 0x%p @ %dus\n", |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 179 | priv->io_base, period); |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 180 | |
| 181 | return 0; |
| 182 | } |
| 183 | |
Bill Pemberton | 39af33f | 2012-11-19 13:26:26 -0500 | [diff] [blame] | 184 | static int timeriomem_rng_remove(struct platform_device *pdev) |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 185 | { |
Rick Altherr | 5ab693e | 2017-04-05 16:20:59 -0700 | [diff] [blame] | 186 | struct timeriomem_rng_private *priv = platform_get_drvdata(pdev); |
Alexander Clouter | 1907da7 | 2013-03-31 17:34:50 +0100 | [diff] [blame] | 187 | |
Rick Altherr | 5ab693e | 2017-04-05 16:20:59 -0700 | [diff] [blame] | 188 | hwrng_unregister(&priv->rng_ops); |
Rick Altherr | ca3bff7 | 2017-04-05 16:21:00 -0700 | [diff] [blame] | 189 | hrtimer_cancel(&priv->timer); |
Alexander Clouter | 3341323 | 2009-03-27 12:59:54 +0800 | [diff] [blame] | 190 | |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 191 | return 0; |
| 192 | } |
| 193 | |
Alexander Clouter | b149a30 | 2013-03-31 17:34:51 +0100 | [diff] [blame] | 194 | static const struct of_device_id timeriomem_rng_match[] = { |
| 195 | { .compatible = "timeriomem_rng" }, |
| 196 | {}, |
| 197 | }; |
| 198 | MODULE_DEVICE_TABLE(of, timeriomem_rng_match); |
| 199 | |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 200 | static struct platform_driver timeriomem_rng_driver = { |
| 201 | .driver = { |
| 202 | .name = "timeriomem_rng", |
Alexander Clouter | b149a30 | 2013-03-31 17:34:51 +0100 | [diff] [blame] | 203 | .of_match_table = timeriomem_rng_match, |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 204 | }, |
| 205 | .probe = timeriomem_rng_probe, |
Greg Kroah-Hartman | bcd2982 | 2012-12-21 15:12:08 -0800 | [diff] [blame] | 206 | .remove = timeriomem_rng_remove, |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 207 | }; |
| 208 | |
Axel Lin | b21cb32 | 2011-11-26 21:11:06 +0800 | [diff] [blame] | 209 | module_platform_driver(timeriomem_rng_driver); |
Alexander Clouter | 9c3c133 | 2009-02-22 12:03:56 +0800 | [diff] [blame] | 210 | |
| 211 | MODULE_LICENSE("GPL"); |
| 212 | MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>"); |
| 213 | MODULE_DESCRIPTION("Timer IOMEM H/W RNG driver"); |