1 | // SPDX--License-Identifier: GPL-2.0 |
2 | |
3 | #include <asm/platform_early.h> |
4 | #include <linux/mod_devicetable.h> |
5 | #include <linux/pm.h> |
6 | |
7 | static __initdata LIST_HEAD(sh_early_platform_driver_list); |
8 | static __initdata LIST_HEAD(sh_early_platform_device_list); |
9 | |
10 | static const struct platform_device_id * |
11 | platform_match_id(const struct platform_device_id *id, |
12 | struct platform_device *pdev) |
13 | { |
14 | while (id->name[0]) { |
15 | if (strcmp(pdev->name, id->name) == 0) { |
16 | pdev->id_entry = id; |
17 | return id; |
18 | } |
19 | id++; |
20 | } |
21 | return NULL; |
22 | } |
23 | |
24 | static int platform_match(struct device *dev, struct device_driver *drv) |
25 | { |
26 | struct platform_device *pdev = to_platform_device(dev); |
27 | struct platform_driver *pdrv = to_platform_driver(drv); |
28 | |
29 | /* When driver_override is set, only bind to the matching driver */ |
30 | if (pdev->driver_override) |
31 | return !strcmp(pdev->driver_override, drv->name); |
32 | |
33 | /* Then try to match against the id table */ |
34 | if (pdrv->id_table) |
35 | return platform_match_id(id: pdrv->id_table, pdev) != NULL; |
36 | |
37 | /* fall-back to driver name match */ |
38 | return (strcmp(pdev->name, drv->name) == 0); |
39 | } |
40 | |
41 | #ifdef CONFIG_PM |
42 | static void device_pm_init_common(struct device *dev) |
43 | { |
44 | if (!dev->power.early_init) { |
45 | spin_lock_init(&dev->power.lock); |
46 | dev->power.qos = NULL; |
47 | dev->power.early_init = true; |
48 | } |
49 | } |
50 | |
51 | static void pm_runtime_early_init(struct device *dev) |
52 | { |
53 | dev->power.disable_depth = 1; |
54 | device_pm_init_common(dev); |
55 | } |
56 | #else |
57 | static void pm_runtime_early_init(struct device *dev) {} |
58 | #endif |
59 | |
60 | /** |
61 | * sh_early_platform_driver_register - register early platform driver |
62 | * @epdrv: sh_early_platform driver structure |
63 | * @buf: string passed from early_param() |
64 | * |
65 | * Helper function for sh_early_platform_init() / sh_early_platform_init_buffer() |
66 | */ |
67 | int __init sh_early_platform_driver_register(struct sh_early_platform_driver *epdrv, |
68 | char *buf) |
69 | { |
70 | char *tmp; |
71 | int n; |
72 | |
73 | /* Simply add the driver to the end of the global list. |
74 | * Drivers will by default be put on the list in compiled-in order. |
75 | */ |
76 | if (!epdrv->list.next) { |
77 | INIT_LIST_HEAD(list: &epdrv->list); |
78 | list_add_tail(new: &epdrv->list, head: &sh_early_platform_driver_list); |
79 | } |
80 | |
81 | /* If the user has specified device then make sure the driver |
82 | * gets prioritized. The driver of the last device specified on |
83 | * command line will be put first on the list. |
84 | */ |
85 | n = strlen(epdrv->pdrv->driver.name); |
86 | if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) { |
87 | list_move(list: &epdrv->list, head: &sh_early_platform_driver_list); |
88 | |
89 | /* Allow passing parameters after device name */ |
90 | if (buf[n] == '\0' || buf[n] == ',') |
91 | epdrv->requested_id = -1; |
92 | else { |
93 | epdrv->requested_id = simple_strtoul(&buf[n + 1], |
94 | &tmp, 10); |
95 | |
96 | if (buf[n] != '.' || (tmp == &buf[n + 1])) { |
97 | epdrv->requested_id = EARLY_PLATFORM_ID_ERROR; |
98 | n = 0; |
99 | } else |
100 | n += strcspn(&buf[n + 1], "," ) + 1; |
101 | } |
102 | |
103 | if (buf[n] == ',') |
104 | n++; |
105 | |
106 | if (epdrv->bufsize) { |
107 | memcpy(epdrv->buffer, &buf[n], |
108 | min_t(int, epdrv->bufsize, strlen(&buf[n]) + 1)); |
109 | epdrv->buffer[epdrv->bufsize - 1] = '\0'; |
110 | } |
111 | } |
112 | |
113 | return 0; |
114 | } |
115 | |
116 | /** |
117 | * sh_early_platform_add_devices - adds a number of early platform devices |
118 | * @devs: array of early platform devices to add |
119 | * @num: number of early platform devices in array |
120 | * |
121 | * Used by early architecture code to register early platform devices and |
122 | * their platform data. |
123 | */ |
124 | void __init sh_early_platform_add_devices(struct platform_device **devs, int num) |
125 | { |
126 | struct device *dev; |
127 | int i; |
128 | |
129 | /* simply add the devices to list */ |
130 | for (i = 0; i < num; i++) { |
131 | dev = &devs[i]->dev; |
132 | |
133 | if (!dev->devres_head.next) { |
134 | pm_runtime_early_init(dev); |
135 | INIT_LIST_HEAD(list: &dev->devres_head); |
136 | list_add_tail(new: &dev->devres_head, |
137 | head: &sh_early_platform_device_list); |
138 | } |
139 | } |
140 | } |
141 | |
142 | /** |
143 | * sh_early_platform_driver_register_all - register early platform drivers |
144 | * @class_str: string to identify early platform driver class |
145 | * |
146 | * Used by architecture code to register all early platform drivers |
147 | * for a certain class. If omitted then only early platform drivers |
148 | * with matching kernel command line class parameters will be registered. |
149 | */ |
150 | void __init sh_early_platform_driver_register_all(char *class_str) |
151 | { |
152 | /* The "class_str" parameter may or may not be present on the kernel |
153 | * command line. If it is present then there may be more than one |
154 | * matching parameter. |
155 | * |
156 | * Since we register our early platform drivers using early_param() |
157 | * we need to make sure that they also get registered in the case |
158 | * when the parameter is missing from the kernel command line. |
159 | * |
160 | * We use parse_early_options() to make sure the early_param() gets |
161 | * called at least once. The early_param() may be called more than |
162 | * once since the name of the preferred device may be specified on |
163 | * the kernel command line. sh_early_platform_driver_register() handles |
164 | * this case for us. |
165 | */ |
166 | parse_early_options(cmdline: class_str); |
167 | } |
168 | |
169 | /** |
170 | * sh_early_platform_match - find early platform device matching driver |
171 | * @epdrv: early platform driver structure |
172 | * @id: id to match against |
173 | */ |
174 | static struct platform_device * __init |
175 | sh_early_platform_match(struct sh_early_platform_driver *epdrv, int id) |
176 | { |
177 | struct platform_device *pd; |
178 | |
179 | list_for_each_entry(pd, &sh_early_platform_device_list, dev.devres_head) |
180 | if (platform_match(dev: &pd->dev, drv: &epdrv->pdrv->driver)) |
181 | if (pd->id == id) |
182 | return pd; |
183 | |
184 | return NULL; |
185 | } |
186 | |
187 | /** |
188 | * sh_early_platform_left - check if early platform driver has matching devices |
189 | * @epdrv: early platform driver structure |
190 | * @id: return true if id or above exists |
191 | */ |
192 | static int __init sh_early_platform_left(struct sh_early_platform_driver *epdrv, |
193 | int id) |
194 | { |
195 | struct platform_device *pd; |
196 | |
197 | list_for_each_entry(pd, &sh_early_platform_device_list, dev.devres_head) |
198 | if (platform_match(dev: &pd->dev, drv: &epdrv->pdrv->driver)) |
199 | if (pd->id >= id) |
200 | return 1; |
201 | |
202 | return 0; |
203 | } |
204 | |
205 | /** |
206 | * sh_early_platform_driver_probe_id - probe drivers matching class_str and id |
207 | * @class_str: string to identify early platform driver class |
208 | * @id: id to match against |
209 | * @nr_probe: number of platform devices to successfully probe before exiting |
210 | */ |
211 | static int __init sh_early_platform_driver_probe_id(char *class_str, |
212 | int id, |
213 | int nr_probe) |
214 | { |
215 | struct sh_early_platform_driver *epdrv; |
216 | struct platform_device *match; |
217 | int match_id; |
218 | int n = 0; |
219 | int left = 0; |
220 | |
221 | list_for_each_entry(epdrv, &sh_early_platform_driver_list, list) { |
222 | /* only use drivers matching our class_str */ |
223 | if (strcmp(class_str, epdrv->class_str)) |
224 | continue; |
225 | |
226 | if (id == -2) { |
227 | match_id = epdrv->requested_id; |
228 | left = 1; |
229 | |
230 | } else { |
231 | match_id = id; |
232 | left += sh_early_platform_left(epdrv, id); |
233 | |
234 | /* skip requested id */ |
235 | switch (epdrv->requested_id) { |
236 | case EARLY_PLATFORM_ID_ERROR: |
237 | case EARLY_PLATFORM_ID_UNSET: |
238 | break; |
239 | default: |
240 | if (epdrv->requested_id == id) |
241 | match_id = EARLY_PLATFORM_ID_UNSET; |
242 | } |
243 | } |
244 | |
245 | switch (match_id) { |
246 | case EARLY_PLATFORM_ID_ERROR: |
247 | pr_warn("%s: unable to parse %s parameter\n" , |
248 | class_str, epdrv->pdrv->driver.name); |
249 | fallthrough; |
250 | case EARLY_PLATFORM_ID_UNSET: |
251 | match = NULL; |
252 | break; |
253 | default: |
254 | match = sh_early_platform_match(epdrv, id: match_id); |
255 | } |
256 | |
257 | if (match) { |
258 | /* |
259 | * Set up a sensible init_name to enable |
260 | * dev_name() and others to be used before the |
261 | * rest of the driver core is initialized. |
262 | */ |
263 | if (!match->dev.init_name && slab_is_available()) { |
264 | if (match->id != -1) |
265 | match->dev.init_name = |
266 | kasprintf(GFP_KERNEL, fmt: "%s.%d" , |
267 | match->name, |
268 | match->id); |
269 | else |
270 | match->dev.init_name = |
271 | kasprintf(GFP_KERNEL, fmt: "%s" , |
272 | match->name); |
273 | |
274 | if (!match->dev.init_name) |
275 | return -ENOMEM; |
276 | } |
277 | |
278 | if (epdrv->pdrv->probe(match)) |
279 | pr_warn("%s: unable to probe %s early.\n" , |
280 | class_str, match->name); |
281 | else |
282 | n++; |
283 | } |
284 | |
285 | if (n >= nr_probe) |
286 | break; |
287 | } |
288 | |
289 | if (left) |
290 | return n; |
291 | else |
292 | return -ENODEV; |
293 | } |
294 | |
295 | /** |
296 | * sh_early_platform_driver_probe - probe a class of registered drivers |
297 | * @class_str: string to identify early platform driver class |
298 | * @nr_probe: number of platform devices to successfully probe before exiting |
299 | * @user_only: only probe user specified early platform devices |
300 | * |
301 | * Used by architecture code to probe registered early platform drivers |
302 | * within a certain class. For probe to happen a registered early platform |
303 | * device matching a registered early platform driver is needed. |
304 | */ |
305 | int __init sh_early_platform_driver_probe(char *class_str, |
306 | int nr_probe, |
307 | int user_only) |
308 | { |
309 | int k, n, i; |
310 | |
311 | n = 0; |
312 | for (i = -2; n < nr_probe; i++) { |
313 | k = sh_early_platform_driver_probe_id(class_str, id: i, nr_probe: nr_probe - n); |
314 | |
315 | if (k < 0) |
316 | break; |
317 | |
318 | n += k; |
319 | |
320 | if (user_only) |
321 | break; |
322 | } |
323 | |
324 | return n; |
325 | } |
326 | |
327 | /** |
328 | * early_platform_cleanup - clean up early platform code |
329 | */ |
330 | void __init early_platform_cleanup(void) |
331 | { |
332 | struct platform_device *pd, *pd2; |
333 | |
334 | /* clean up the devres list used to chain devices */ |
335 | list_for_each_entry_safe(pd, pd2, &sh_early_platform_device_list, |
336 | dev.devres_head) { |
337 | list_del(entry: &pd->dev.devres_head); |
338 | memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head)); |
339 | } |
340 | } |
341 | |