1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * ST Random Number Generator Driver ST's Platforms |
4 | * |
5 | * Author: Pankaj Dev: <pankaj.dev@st.com> |
6 | * Lee Jones <lee.jones@linaro.org> |
7 | * |
8 | * Copyright (C) 2015 STMicroelectronics (R&D) Limited |
9 | */ |
10 | |
11 | #include <linux/clk.h> |
12 | #include <linux/delay.h> |
13 | #include <linux/hw_random.h> |
14 | #include <linux/io.h> |
15 | #include <linux/kernel.h> |
16 | #include <linux/module.h> |
17 | #include <linux/of.h> |
18 | #include <linux/platform_device.h> |
19 | #include <linux/slab.h> |
20 | |
21 | /* Registers */ |
22 | #define ST_RNG_STATUS_REG 0x20 |
23 | #define ST_RNG_DATA_REG 0x24 |
24 | |
25 | /* Registers fields */ |
26 | #define ST_RNG_STATUS_BAD_SEQUENCE BIT(0) |
27 | #define ST_RNG_STATUS_BAD_ALTERNANCE BIT(1) |
28 | #define ST_RNG_STATUS_FIFO_FULL BIT(5) |
29 | |
30 | #define ST_RNG_SAMPLE_SIZE 2 /* 2 Byte (16bit) samples */ |
31 | #define ST_RNG_FIFO_DEPTH 4 |
32 | #define ST_RNG_FIFO_SIZE (ST_RNG_FIFO_DEPTH * ST_RNG_SAMPLE_SIZE) |
33 | |
34 | /* |
35 | * Samples are documented to be available every 0.667us, so in theory |
36 | * the 4 sample deep FIFO should take 2.668us to fill. However, during |
37 | * thorough testing, it became apparent that filling the FIFO actually |
38 | * takes closer to 12us. We then multiply by 2 in order to account for |
39 | * the lack of udelay()'s reliability, suggested by Russell King. |
40 | */ |
41 | #define ST_RNG_FILL_FIFO_TIMEOUT (12 * 2) |
42 | |
43 | struct st_rng_data { |
44 | void __iomem *base; |
45 | struct hwrng ops; |
46 | }; |
47 | |
48 | static int st_rng_read(struct hwrng *rng, void *data, size_t max, bool wait) |
49 | { |
50 | struct st_rng_data *ddata = (struct st_rng_data *)rng->priv; |
51 | u32 status; |
52 | int i; |
53 | |
54 | /* Wait until FIFO is full - max 4uS*/ |
55 | for (i = 0; i < ST_RNG_FILL_FIFO_TIMEOUT; i++) { |
56 | status = readl_relaxed(ddata->base + ST_RNG_STATUS_REG); |
57 | if (status & ST_RNG_STATUS_FIFO_FULL) |
58 | break; |
59 | udelay(1); |
60 | } |
61 | |
62 | if (i == ST_RNG_FILL_FIFO_TIMEOUT) |
63 | return 0; |
64 | |
65 | for (i = 0; i < ST_RNG_FIFO_SIZE && i < max; i += 2) |
66 | *(u16 *)(data + i) = |
67 | readl_relaxed(ddata->base + ST_RNG_DATA_REG); |
68 | |
69 | return i; /* No of bytes read */ |
70 | } |
71 | |
72 | static int st_rng_probe(struct platform_device *pdev) |
73 | { |
74 | struct st_rng_data *ddata; |
75 | struct clk *clk; |
76 | void __iomem *base; |
77 | int ret; |
78 | |
79 | ddata = devm_kzalloc(dev: &pdev->dev, size: sizeof(*ddata), GFP_KERNEL); |
80 | if (!ddata) |
81 | return -ENOMEM; |
82 | |
83 | base = devm_platform_ioremap_resource(pdev, index: 0); |
84 | if (IS_ERR(ptr: base)) |
85 | return PTR_ERR(ptr: base); |
86 | |
87 | clk = devm_clk_get_enabled(dev: &pdev->dev, NULL); |
88 | if (IS_ERR(ptr: clk)) |
89 | return PTR_ERR(ptr: clk); |
90 | |
91 | ddata->ops.priv = (unsigned long)ddata; |
92 | ddata->ops.read = st_rng_read; |
93 | ddata->ops.name = pdev->name; |
94 | ddata->base = base; |
95 | |
96 | ret = devm_hwrng_register(dev: &pdev->dev, rng: &ddata->ops); |
97 | if (ret) { |
98 | dev_err(&pdev->dev, "Failed to register HW RNG\n" ); |
99 | return ret; |
100 | } |
101 | |
102 | dev_info(&pdev->dev, "Successfully registered HW RNG\n" ); |
103 | |
104 | return 0; |
105 | } |
106 | |
107 | static const struct of_device_id st_rng_match[] __maybe_unused = { |
108 | { .compatible = "st,rng" }, |
109 | {}, |
110 | }; |
111 | MODULE_DEVICE_TABLE(of, st_rng_match); |
112 | |
113 | static struct platform_driver st_rng_driver = { |
114 | .driver = { |
115 | .name = "st-hwrandom" , |
116 | .of_match_table = of_match_ptr(st_rng_match), |
117 | }, |
118 | .probe = st_rng_probe, |
119 | }; |
120 | |
121 | module_platform_driver(st_rng_driver); |
122 | |
123 | MODULE_AUTHOR("Pankaj Dev <pankaj.dev@st.com>" ); |
124 | MODULE_DESCRIPTION("ST Microelectronics HW Random Number Generator" ); |
125 | MODULE_LICENSE("GPL v2" ); |
126 | |