Commit | Line | Data |
---|---|---|
4a4da53c LJ |
1 | /* |
2 | * ST Random Number Generator Driver ST's Platforms | |
3 | * | |
4 | * Author: Pankaj Dev: <pankaj.dev@st.com> | |
5 | * Lee Jones <lee.jones@linaro.org> | |
6 | * | |
7 | * Copyright (C) 2015 STMicroelectronics (R&D) Limited | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License version 2 as | |
11 | * published by the Free Software Foundation. | |
12 | */ | |
13 | ||
14 | #include <linux/clk.h> | |
15 | #include <linux/delay.h> | |
16 | #include <linux/hw_random.h> | |
17 | #include <linux/io.h> | |
18 | #include <linux/module.h> | |
19 | #include <linux/of.h> | |
20 | #include <linux/platform_device.h> | |
21 | #include <linux/slab.h> | |
22 | ||
23 | /* Registers */ | |
24 | #define ST_RNG_STATUS_REG 0x20 | |
25 | #define ST_RNG_DATA_REG 0x24 | |
26 | ||
27 | /* Registers fields */ | |
28 | #define ST_RNG_STATUS_BAD_SEQUENCE BIT(0) | |
29 | #define ST_RNG_STATUS_BAD_ALTERNANCE BIT(1) | |
30 | #define ST_RNG_STATUS_FIFO_FULL BIT(5) | |
31 | ||
4a4da53c | 32 | #define ST_RNG_SAMPLE_SIZE 2 /* 2 Byte (16bit) samples */ |
9ad92bdf LJ |
33 | #define ST_RNG_FIFO_DEPTH 4 |
34 | #define ST_RNG_FIFO_SIZE (ST_RNG_FIFO_DEPTH * ST_RNG_SAMPLE_SIZE) | |
4a4da53c | 35 | |
93d649bd LJ |
36 | /* |
37 | * Samples are documented to be available every 0.667us, so in theory | |
38 | * the 4 sample deep FIFO should take 2.668us to fill. However, during | |
39 | * thorough testing, it became apparent that filling the FIFO actually | |
40 | * takes closer to 12us. We then multiply by 2 in order to account for | |
41 | * the lack of udelay()'s reliability, suggested by Russell King. | |
42 | */ | |
43 | #define ST_RNG_FILL_FIFO_TIMEOUT (12 * 2) | |
4a4da53c LJ |
44 | |
45 | struct st_rng_data { | |
46 | void __iomem *base; | |
47 | struct clk *clk; | |
48 | struct hwrng ops; | |
49 | }; | |
50 | ||
51 | static int st_rng_read(struct hwrng *rng, void *data, size_t max, bool wait) | |
52 | { | |
53 | struct st_rng_data *ddata = (struct st_rng_data *)rng->priv; | |
54 | u32 status; | |
55 | int i; | |
56 | ||
57 | if (max < sizeof(u16)) | |
58 | return -EINVAL; | |
59 | ||
60 | /* Wait until FIFO is full - max 4uS*/ | |
61 | for (i = 0; i < ST_RNG_FILL_FIFO_TIMEOUT; i++) { | |
62 | status = readl_relaxed(ddata->base + ST_RNG_STATUS_REG); | |
63 | if (status & ST_RNG_STATUS_FIFO_FULL) | |
64 | break; | |
65 | udelay(1); | |
66 | } | |
67 | ||
68 | if (i == ST_RNG_FILL_FIFO_TIMEOUT) | |
69 | return 0; | |
70 | ||
71 | for (i = 0; i < ST_RNG_FIFO_SIZE && i < max; i += 2) | |
72 | *(u16 *)(data + i) = | |
73 | readl_relaxed(ddata->base + ST_RNG_DATA_REG); | |
74 | ||
75 | return i; /* No of bytes read */ | |
76 | } | |
77 | ||
78 | static int st_rng_probe(struct platform_device *pdev) | |
79 | { | |
80 | struct st_rng_data *ddata; | |
81 | struct resource *res; | |
82 | struct clk *clk; | |
83 | void __iomem *base; | |
84 | int ret; | |
85 | ||
86 | ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); | |
87 | if (!ddata) | |
88 | return -ENOMEM; | |
89 | ||
90 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
91 | base = devm_ioremap_resource(&pdev->dev, res); | |
92 | if (IS_ERR(base)) | |
93 | return PTR_ERR(base); | |
94 | ||
95 | clk = devm_clk_get(&pdev->dev, NULL); | |
96 | if (IS_ERR(clk)) | |
97 | return PTR_ERR(clk); | |
98 | ||
99 | ret = clk_prepare_enable(clk); | |
100 | if (ret) | |
101 | return ret; | |
102 | ||
103 | ddata->ops.priv = (unsigned long)ddata; | |
104 | ddata->ops.read = st_rng_read; | |
105 | ddata->ops.name = pdev->name; | |
106 | ddata->base = base; | |
107 | ddata->clk = clk; | |
108 | ||
109 | dev_set_drvdata(&pdev->dev, ddata); | |
110 | ||
111 | ret = hwrng_register(&ddata->ops); | |
112 | if (ret) { | |
113 | dev_err(&pdev->dev, "Failed to register HW RNG\n"); | |
114 | return ret; | |
115 | } | |
116 | ||
117 | dev_info(&pdev->dev, "Successfully registered HW RNG\n"); | |
118 | ||
119 | return 0; | |
120 | } | |
121 | ||
122 | static int st_rng_remove(struct platform_device *pdev) | |
123 | { | |
124 | struct st_rng_data *ddata = dev_get_drvdata(&pdev->dev); | |
125 | ||
126 | hwrng_unregister(&ddata->ops); | |
127 | ||
128 | clk_disable_unprepare(ddata->clk); | |
129 | ||
130 | return 0; | |
131 | } | |
132 | ||
133 | static const struct of_device_id st_rng_match[] = { | |
134 | { .compatible = "st,rng" }, | |
135 | {}, | |
136 | }; | |
137 | MODULE_DEVICE_TABLE(of, st_rng_match); | |
138 | ||
139 | static struct platform_driver st_rng_driver = { | |
140 | .driver = { | |
141 | .name = "st-hwrandom", | |
142 | .of_match_table = of_match_ptr(st_rng_match), | |
143 | }, | |
144 | .probe = st_rng_probe, | |
145 | .remove = st_rng_remove | |
146 | }; | |
147 | ||
148 | module_platform_driver(st_rng_driver); | |
149 | ||
150 | MODULE_AUTHOR("Pankaj Dev <pankaj.dev@st.com>"); | |
151 | MODULE_LICENSE("GPL v2"); |