1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * Allwinner sunXi SoCs Security ID support. |
4 | * |
5 | * Copyright (c) 2013 Oliver Schinagl <oliver@schinagl.nl> |
6 | * Copyright (C) 2014 Maxime Ripard <maxime.ripard@free-electrons.com> |
7 | */ |
8 | |
9 | #include <linux/device.h> |
10 | #include <linux/io.h> |
11 | #include <linux/iopoll.h> |
12 | #include <linux/module.h> |
13 | #include <linux/nvmem-provider.h> |
14 | #include <linux/of.h> |
15 | #include <linux/platform_device.h> |
16 | #include <linux/slab.h> |
17 | #include <linux/random.h> |
18 | |
19 | /* Registers and special values for doing register-based SID readout on H3 */ |
20 | #define SUN8I_SID_PRCTL 0x40 |
21 | #define SUN8I_SID_RDKEY 0x60 |
22 | |
23 | #define SUN8I_SID_OFFSET_MASK 0x1FF |
24 | #define SUN8I_SID_OFFSET_SHIFT 16 |
25 | #define SUN8I_SID_OP_LOCK (0xAC << 8) |
26 | #define SUN8I_SID_READ BIT(1) |
27 | |
28 | struct sunxi_sid_cfg { |
29 | u32 value_offset; |
30 | u32 size; |
31 | bool need_register_readout; |
32 | }; |
33 | |
34 | struct sunxi_sid { |
35 | void __iomem *base; |
36 | u32 value_offset; |
37 | }; |
38 | |
39 | static int sunxi_sid_read(void *context, unsigned int offset, |
40 | void *val, size_t bytes) |
41 | { |
42 | struct sunxi_sid *sid = context; |
43 | u32 word; |
44 | |
45 | /* .stride = 4 so offset is guaranteed to be aligned */ |
46 | __ioread32_copy(to: val, from: sid->base + sid->value_offset + offset, count: bytes / 4); |
47 | |
48 | val += round_down(bytes, 4); |
49 | offset += round_down(bytes, 4); |
50 | bytes = bytes % 4; |
51 | |
52 | if (!bytes) |
53 | return 0; |
54 | |
55 | /* Handle any trailing bytes */ |
56 | word = readl_relaxed(sid->base + sid->value_offset + offset); |
57 | memcpy(val, &word, bytes); |
58 | |
59 | return 0; |
60 | } |
61 | |
62 | static int sun8i_sid_register_readout(const struct sunxi_sid *sid, |
63 | const unsigned int offset, |
64 | u32 *out) |
65 | { |
66 | u32 reg_val; |
67 | int ret; |
68 | |
69 | /* Set word, lock access, and set read command */ |
70 | reg_val = (offset & SUN8I_SID_OFFSET_MASK) |
71 | << SUN8I_SID_OFFSET_SHIFT; |
72 | reg_val |= SUN8I_SID_OP_LOCK | SUN8I_SID_READ; |
73 | writel(val: reg_val, addr: sid->base + SUN8I_SID_PRCTL); |
74 | |
75 | ret = readl_poll_timeout(sid->base + SUN8I_SID_PRCTL, reg_val, |
76 | !(reg_val & SUN8I_SID_READ), 100, 250000); |
77 | if (ret) |
78 | return ret; |
79 | |
80 | if (out) |
81 | *out = readl(addr: sid->base + SUN8I_SID_RDKEY); |
82 | |
83 | writel(val: 0, addr: sid->base + SUN8I_SID_PRCTL); |
84 | |
85 | return 0; |
86 | } |
87 | |
88 | /* |
89 | * On Allwinner H3, the value on the 0x200 offset of the SID controller seems |
90 | * to be not reliable at all. |
91 | * Read by the registers instead. |
92 | */ |
93 | static int sun8i_sid_read_by_reg(void *context, unsigned int offset, |
94 | void *val, size_t bytes) |
95 | { |
96 | struct sunxi_sid *sid = context; |
97 | u32 word; |
98 | int ret; |
99 | |
100 | /* .stride = 4 so offset is guaranteed to be aligned */ |
101 | while (bytes >= 4) { |
102 | ret = sun8i_sid_register_readout(sid, offset, out: val); |
103 | if (ret) |
104 | return ret; |
105 | |
106 | val += 4; |
107 | offset += 4; |
108 | bytes -= 4; |
109 | } |
110 | |
111 | if (!bytes) |
112 | return 0; |
113 | |
114 | /* Handle any trailing bytes */ |
115 | ret = sun8i_sid_register_readout(sid, offset, out: &word); |
116 | if (ret) |
117 | return ret; |
118 | |
119 | memcpy(val, &word, bytes); |
120 | |
121 | return 0; |
122 | } |
123 | |
124 | static int sunxi_sid_probe(struct platform_device *pdev) |
125 | { |
126 | struct device *dev = &pdev->dev; |
127 | struct nvmem_config *nvmem_cfg; |
128 | struct nvmem_device *nvmem; |
129 | struct sunxi_sid *sid; |
130 | int size; |
131 | char *randomness; |
132 | const struct sunxi_sid_cfg *cfg; |
133 | |
134 | sid = devm_kzalloc(dev, size: sizeof(*sid), GFP_KERNEL); |
135 | if (!sid) |
136 | return -ENOMEM; |
137 | |
138 | cfg = of_device_get_match_data(dev); |
139 | if (!cfg) |
140 | return -EINVAL; |
141 | sid->value_offset = cfg->value_offset; |
142 | |
143 | sid->base = devm_platform_ioremap_resource(pdev, index: 0); |
144 | if (IS_ERR(ptr: sid->base)) |
145 | return PTR_ERR(ptr: sid->base); |
146 | |
147 | size = cfg->size; |
148 | |
149 | nvmem_cfg = devm_kzalloc(dev, size: sizeof(*nvmem_cfg), GFP_KERNEL); |
150 | if (!nvmem_cfg) |
151 | return -ENOMEM; |
152 | |
153 | nvmem_cfg->dev = dev; |
154 | nvmem_cfg->name = "sunxi-sid" ; |
155 | nvmem_cfg->type = NVMEM_TYPE_OTP; |
156 | nvmem_cfg->add_legacy_fixed_of_cells = true; |
157 | nvmem_cfg->read_only = true; |
158 | nvmem_cfg->size = cfg->size; |
159 | nvmem_cfg->word_size = 1; |
160 | nvmem_cfg->stride = 4; |
161 | nvmem_cfg->priv = sid; |
162 | if (cfg->need_register_readout) |
163 | nvmem_cfg->reg_read = sun8i_sid_read_by_reg; |
164 | else |
165 | nvmem_cfg->reg_read = sunxi_sid_read; |
166 | |
167 | nvmem = devm_nvmem_register(dev, cfg: nvmem_cfg); |
168 | if (IS_ERR(ptr: nvmem)) |
169 | return PTR_ERR(ptr: nvmem); |
170 | |
171 | randomness = kzalloc(size, GFP_KERNEL); |
172 | if (!randomness) |
173 | return -ENOMEM; |
174 | |
175 | nvmem_cfg->reg_read(sid, 0, randomness, size); |
176 | add_device_randomness(buf: randomness, len: size); |
177 | kfree(objp: randomness); |
178 | |
179 | platform_set_drvdata(pdev, data: nvmem); |
180 | |
181 | return 0; |
182 | } |
183 | |
184 | static const struct sunxi_sid_cfg sun4i_a10_cfg = { |
185 | .size = 0x10, |
186 | }; |
187 | |
188 | static const struct sunxi_sid_cfg sun7i_a20_cfg = { |
189 | .size = 0x200, |
190 | }; |
191 | |
192 | static const struct sunxi_sid_cfg sun8i_h3_cfg = { |
193 | .value_offset = 0x200, |
194 | .size = 0x100, |
195 | .need_register_readout = true, |
196 | }; |
197 | |
198 | static const struct sunxi_sid_cfg sun50i_a64_cfg = { |
199 | .value_offset = 0x200, |
200 | .size = 0x100, |
201 | }; |
202 | |
203 | static const struct sunxi_sid_cfg sun50i_h6_cfg = { |
204 | .value_offset = 0x200, |
205 | .size = 0x200, |
206 | }; |
207 | |
208 | static const struct of_device_id sunxi_sid_of_match[] = { |
209 | { .compatible = "allwinner,sun4i-a10-sid" , .data = &sun4i_a10_cfg }, |
210 | { .compatible = "allwinner,sun7i-a20-sid" , .data = &sun7i_a20_cfg }, |
211 | { .compatible = "allwinner,sun8i-a83t-sid" , .data = &sun50i_a64_cfg }, |
212 | { .compatible = "allwinner,sun8i-h3-sid" , .data = &sun8i_h3_cfg }, |
213 | { .compatible = "allwinner,sun20i-d1-sid" , .data = &sun50i_a64_cfg }, |
214 | { .compatible = "allwinner,sun50i-a64-sid" , .data = &sun50i_a64_cfg }, |
215 | { .compatible = "allwinner,sun50i-h5-sid" , .data = &sun50i_a64_cfg }, |
216 | { .compatible = "allwinner,sun50i-h6-sid" , .data = &sun50i_h6_cfg }, |
217 | {/* sentinel */}, |
218 | }; |
219 | MODULE_DEVICE_TABLE(of, sunxi_sid_of_match); |
220 | |
221 | static struct platform_driver sunxi_sid_driver = { |
222 | .probe = sunxi_sid_probe, |
223 | .driver = { |
224 | .name = "eeprom-sunxi-sid" , |
225 | .of_match_table = sunxi_sid_of_match, |
226 | }, |
227 | }; |
228 | module_platform_driver(sunxi_sid_driver); |
229 | |
230 | MODULE_AUTHOR("Oliver Schinagl <oliver@schinagl.nl>" ); |
231 | MODULE_DESCRIPTION("Allwinner sunxi security id driver" ); |
232 | MODULE_LICENSE("GPL" ); |
233 | |