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 *
platform_match_id(const struct platform_device_id * id,struct platform_device * pdev)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 
platform_match(struct device * dev,struct device_driver * drv)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
device_pm_init_common(struct device * dev)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 
pm_runtime_early_init(struct device * dev)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
pm_runtime_early_init(struct device * dev)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  */
sh_early_platform_driver_register(struct sh_early_platform_driver * epdrv,char * buf)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  */
sh_early_platform_add_devices(struct platform_device ** devs,int num)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  */
sh_early_platform_driver_register_all(char * class_str)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
sh_early_platform_match(struct sh_early_platform_driver * epdrv,int id)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  */
sh_early_platform_left(struct sh_early_platform_driver * epdrv,int id)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  */
sh_early_platform_driver_probe_id(char * class_str,int id,int nr_probe)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  */
sh_early_platform_driver_probe(char * class_str,int nr_probe,int user_only)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  */
early_platform_cleanup(void)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