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(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(&epdrv->list);
78 list_add_tail(&epdrv->list, &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(&epdrv->list, &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(&dev->devres_head);
136 list_add_tail(&dev->devres_head,
137 &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(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(&pd->dev, &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(&pd->dev, &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, 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, "%s.%d",
267 match->name,
268 match->id);
269 else
270 match->dev.init_name =
271 kasprintf(GFP_KERNEL, "%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, i, 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(&pd->dev.devres_head);
338 memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head));
339 }
340 }
341
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.