]>
Commit | Line | Data |
---|---|---|
6494d708 SG |
1 | /* |
2 | * Copyright (c) 2013 Google, Inc | |
3 | * | |
4 | * (C) Copyright 2012 | |
5 | * Pavel Herrmann <morpheus.ibis@gmail.com> | |
6 | * | |
7 | * SPDX-License-Identifier: GPL-2.0+ | |
8 | */ | |
9 | ||
10 | #include <common.h> | |
11 | #include <errno.h> | |
12 | #include <malloc.h> | |
13 | #include <dm/device.h> | |
14 | #include <dm/device-internal.h> | |
15 | #include <dm/lists.h> | |
16 | #include <dm/uclass.h> | |
17 | #include <dm/uclass-internal.h> | |
18 | #include <dm/util.h> | |
19 | ||
20 | DECLARE_GLOBAL_DATA_PTR; | |
21 | ||
22 | struct uclass *uclass_find(enum uclass_id key) | |
23 | { | |
24 | struct uclass *uc; | |
25 | ||
c910e2e2 SG |
26 | if (!gd->dm_root) |
27 | return NULL; | |
6494d708 SG |
28 | /* |
29 | * TODO(sjg@chromium.org): Optimise this, perhaps moving the found | |
30 | * node to the start of the list, or creating a linear array mapping | |
31 | * id to node. | |
32 | */ | |
33 | list_for_each_entry(uc, &gd->uclass_root, sibling_node) { | |
34 | if (uc->uc_drv->id == key) | |
35 | return uc; | |
36 | } | |
37 | ||
38 | return NULL; | |
39 | } | |
40 | ||
41 | /** | |
42 | * uclass_add() - Create new uclass in list | |
43 | * @id: Id number to create | |
44 | * @ucp: Returns pointer to uclass, or NULL on error | |
45 | * @return 0 on success, -ve on error | |
46 | * | |
47 | * The new uclass is added to the list. There must be only one uclass for | |
48 | * each id. | |
49 | */ | |
50 | static int uclass_add(enum uclass_id id, struct uclass **ucp) | |
51 | { | |
52 | struct uclass_driver *uc_drv; | |
53 | struct uclass *uc; | |
54 | int ret; | |
55 | ||
56 | *ucp = NULL; | |
57 | uc_drv = lists_uclass_lookup(id); | |
58 | if (!uc_drv) { | |
643e6902 MY |
59 | debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n", |
60 | id); | |
3346c876 SG |
61 | /* |
62 | * Use a strange error to make this case easier to find. When | |
63 | * a uclass is not available it can prevent driver model from | |
64 | * starting up and this failure is otherwise hard to debug. | |
65 | */ | |
66 | return -EPFNOSUPPORT; | |
6494d708 | 67 | } |
6494d708 SG |
68 | uc = calloc(1, sizeof(*uc)); |
69 | if (!uc) | |
70 | return -ENOMEM; | |
71 | if (uc_drv->priv_auto_alloc_size) { | |
72 | uc->priv = calloc(1, uc_drv->priv_auto_alloc_size); | |
73 | if (!uc->priv) { | |
74 | ret = -ENOMEM; | |
75 | goto fail_mem; | |
76 | } | |
77 | } | |
78 | uc->uc_drv = uc_drv; | |
79 | INIT_LIST_HEAD(&uc->sibling_node); | |
80 | INIT_LIST_HEAD(&uc->dev_head); | |
89876a55 | 81 | list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST); |
6494d708 SG |
82 | |
83 | if (uc_drv->init) { | |
84 | ret = uc_drv->init(uc); | |
85 | if (ret) | |
86 | goto fail; | |
87 | } | |
88 | ||
89 | *ucp = uc; | |
90 | ||
91 | return 0; | |
92 | fail: | |
93 | if (uc_drv->priv_auto_alloc_size) { | |
94 | free(uc->priv); | |
95 | uc->priv = NULL; | |
96 | } | |
97 | list_del(&uc->sibling_node); | |
98 | fail_mem: | |
99 | free(uc); | |
100 | ||
101 | return ret; | |
102 | } | |
103 | ||
104 | int uclass_destroy(struct uclass *uc) | |
105 | { | |
106 | struct uclass_driver *uc_drv; | |
07d260e0 | 107 | struct udevice *dev; |
6494d708 SG |
108 | int ret; |
109 | ||
07d260e0 SG |
110 | /* |
111 | * We cannot use list_for_each_entry_safe() here. If a device in this | |
112 | * uclass has a child device also in this uclass, it will be also be | |
113 | * unbound (by the recursion in the call to device_unbind() below). | |
114 | * We can loop until the list is empty. | |
115 | */ | |
116 | while (!list_empty(&uc->dev_head)) { | |
117 | dev = list_first_entry(&uc->dev_head, struct udevice, | |
118 | uclass_node); | |
6494d708 SG |
119 | ret = device_remove(dev); |
120 | if (ret) | |
121 | return ret; | |
122 | ret = device_unbind(dev); | |
123 | if (ret) | |
124 | return ret; | |
125 | } | |
126 | ||
127 | uc_drv = uc->uc_drv; | |
128 | if (uc_drv->destroy) | |
129 | uc_drv->destroy(uc); | |
130 | list_del(&uc->sibling_node); | |
131 | if (uc_drv->priv_auto_alloc_size) | |
132 | free(uc->priv); | |
133 | free(uc); | |
134 | ||
135 | return 0; | |
136 | } | |
137 | ||
138 | int uclass_get(enum uclass_id id, struct uclass **ucp) | |
139 | { | |
140 | struct uclass *uc; | |
141 | ||
142 | *ucp = NULL; | |
143 | uc = uclass_find(id); | |
144 | if (!uc) | |
145 | return uclass_add(id, ucp); | |
146 | *ucp = uc; | |
147 | ||
148 | return 0; | |
149 | } | |
150 | ||
54c5d08a | 151 | int uclass_find_device(enum uclass_id id, int index, struct udevice **devp) |
6494d708 SG |
152 | { |
153 | struct uclass *uc; | |
54c5d08a | 154 | struct udevice *dev; |
6494d708 SG |
155 | int ret; |
156 | ||
157 | *devp = NULL; | |
158 | ret = uclass_get(id, &uc); | |
159 | if (ret) | |
160 | return ret; | |
2fda14ae SG |
161 | if (list_empty(&uc->dev_head)) |
162 | return -ENODEV; | |
6494d708 SG |
163 | |
164 | list_for_each_entry(dev, &uc->dev_head, uclass_node) { | |
165 | if (!index--) { | |
166 | *devp = dev; | |
167 | return 0; | |
168 | } | |
169 | } | |
170 | ||
171 | return -ENODEV; | |
172 | } | |
173 | ||
c1d6f919 PM |
174 | int uclass_find_first_device(enum uclass_id id, struct udevice **devp) |
175 | { | |
176 | struct uclass *uc; | |
177 | int ret; | |
178 | ||
179 | *devp = NULL; | |
180 | ret = uclass_get(id, &uc); | |
181 | if (ret) | |
182 | return ret; | |
183 | if (list_empty(&uc->dev_head)) | |
184 | return 0; | |
185 | ||
186 | *devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node); | |
187 | ||
188 | return 0; | |
189 | } | |
190 | ||
191 | int uclass_find_next_device(struct udevice **devp) | |
192 | { | |
193 | struct udevice *dev = *devp; | |
194 | ||
195 | *devp = NULL; | |
196 | if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head)) | |
197 | return 0; | |
198 | ||
199 | *devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node); | |
200 | ||
201 | return 0; | |
202 | } | |
203 | ||
e0735a4c PM |
204 | int uclass_find_device_by_name(enum uclass_id id, const char *name, |
205 | struct udevice **devp) | |
206 | { | |
207 | struct uclass *uc; | |
208 | struct udevice *dev; | |
209 | int ret; | |
210 | ||
211 | *devp = NULL; | |
212 | if (!name) | |
213 | return -EINVAL; | |
214 | ret = uclass_get(id, &uc); | |
215 | if (ret) | |
216 | return ret; | |
217 | ||
218 | list_for_each_entry(dev, &uc->dev_head, uclass_node) { | |
219 | if (!strncmp(dev->name, name, strlen(name))) { | |
220 | *devp = dev; | |
221 | return 0; | |
222 | } | |
223 | } | |
224 | ||
225 | return -ENODEV; | |
226 | } | |
227 | ||
5a66a8ff SG |
228 | int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq, |
229 | bool find_req_seq, struct udevice **devp) | |
230 | { | |
231 | struct uclass *uc; | |
232 | struct udevice *dev; | |
233 | int ret; | |
234 | ||
235 | *devp = NULL; | |
236 | debug("%s: %d %d\n", __func__, find_req_seq, seq_or_req_seq); | |
237 | if (seq_or_req_seq == -1) | |
238 | return -ENODEV; | |
239 | ret = uclass_get(id, &uc); | |
240 | if (ret) | |
241 | return ret; | |
242 | ||
243 | list_for_each_entry(dev, &uc->dev_head, uclass_node) { | |
244 | debug(" - %d %d\n", dev->req_seq, dev->seq); | |
245 | if ((find_req_seq ? dev->req_seq : dev->seq) == | |
246 | seq_or_req_seq) { | |
247 | *devp = dev; | |
248 | debug(" - found\n"); | |
249 | return 0; | |
250 | } | |
251 | } | |
252 | debug(" - not found\n"); | |
253 | ||
254 | return -ENODEV; | |
255 | } | |
256 | ||
f4cdead2 SG |
257 | static int uclass_find_device_by_of_offset(enum uclass_id id, int node, |
258 | struct udevice **devp) | |
259 | { | |
260 | struct uclass *uc; | |
261 | struct udevice *dev; | |
262 | int ret; | |
263 | ||
264 | *devp = NULL; | |
265 | if (node < 0) | |
266 | return -ENODEV; | |
267 | ret = uclass_get(id, &uc); | |
268 | if (ret) | |
269 | return ret; | |
270 | ||
271 | list_for_each_entry(dev, &uc->dev_head, uclass_node) { | |
272 | if (dev->of_offset == node) { | |
273 | *devp = dev; | |
274 | return 0; | |
275 | } | |
276 | } | |
277 | ||
278 | return -ENODEV; | |
279 | } | |
280 | ||
c275dfef | 281 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
d82ba4c0 SG |
282 | static int uclass_find_device_by_phandle(enum uclass_id id, |
283 | struct udevice *parent, | |
284 | const char *name, | |
285 | struct udevice **devp) | |
286 | { | |
287 | struct udevice *dev; | |
288 | struct uclass *uc; | |
289 | int find_phandle; | |
290 | int ret; | |
291 | ||
292 | *devp = NULL; | |
293 | find_phandle = fdtdec_get_int(gd->fdt_blob, parent->of_offset, name, | |
294 | -1); | |
295 | if (find_phandle <= 0) | |
296 | return -ENOENT; | |
297 | ret = uclass_get(id, &uc); | |
298 | if (ret) | |
299 | return ret; | |
300 | ||
301 | list_for_each_entry(dev, &uc->dev_head, uclass_node) { | |
302 | uint phandle = fdt_get_phandle(gd->fdt_blob, dev->of_offset); | |
303 | ||
304 | if (phandle == find_phandle) { | |
305 | *devp = dev; | |
306 | return 0; | |
307 | } | |
308 | } | |
309 | ||
310 | return -ENODEV; | |
311 | } | |
c275dfef | 312 | #endif |
d82ba4c0 | 313 | |
794d5219 | 314 | int uclass_get_device_tail(struct udevice *dev, int ret, |
9ca296a1 | 315 | struct udevice **devp) |
6494d708 | 316 | { |
6494d708 SG |
317 | if (ret) |
318 | return ret; | |
319 | ||
f66529f9 | 320 | assert(dev); |
6494d708 SG |
321 | ret = device_probe(dev); |
322 | if (ret) | |
323 | return ret; | |
324 | ||
325 | *devp = dev; | |
326 | ||
327 | return 0; | |
328 | } | |
329 | ||
9ca296a1 SG |
330 | int uclass_get_device(enum uclass_id id, int index, struct udevice **devp) |
331 | { | |
332 | struct udevice *dev; | |
333 | int ret; | |
334 | ||
335 | *devp = NULL; | |
336 | ret = uclass_find_device(id, index, &dev); | |
337 | return uclass_get_device_tail(dev, ret, devp); | |
338 | } | |
339 | ||
b7af1a2d PM |
340 | int uclass_get_device_by_name(enum uclass_id id, const char *name, |
341 | struct udevice **devp) | |
342 | { | |
343 | struct udevice *dev; | |
344 | int ret; | |
345 | ||
346 | *devp = NULL; | |
347 | ret = uclass_find_device_by_name(id, name, &dev); | |
348 | return uclass_get_device_tail(dev, ret, devp); | |
349 | } | |
350 | ||
5a66a8ff SG |
351 | int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp) |
352 | { | |
353 | struct udevice *dev; | |
354 | int ret; | |
355 | ||
356 | *devp = NULL; | |
357 | ret = uclass_find_device_by_seq(id, seq, false, &dev); | |
358 | if (ret == -ENODEV) { | |
359 | /* | |
360 | * We didn't find it in probed devices. See if there is one | |
361 | * that will request this seq if probed. | |
362 | */ | |
363 | ret = uclass_find_device_by_seq(id, seq, true, &dev); | |
364 | } | |
365 | return uclass_get_device_tail(dev, ret, devp); | |
366 | } | |
367 | ||
f4cdead2 SG |
368 | int uclass_get_device_by_of_offset(enum uclass_id id, int node, |
369 | struct udevice **devp) | |
370 | { | |
371 | struct udevice *dev; | |
372 | int ret; | |
373 | ||
374 | *devp = NULL; | |
375 | ret = uclass_find_device_by_of_offset(id, node, &dev); | |
376 | return uclass_get_device_tail(dev, ret, devp); | |
377 | } | |
378 | ||
c275dfef | 379 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
d82ba4c0 SG |
380 | int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent, |
381 | const char *name, struct udevice **devp) | |
382 | { | |
383 | struct udevice *dev; | |
384 | int ret; | |
385 | ||
386 | *devp = NULL; | |
387 | ret = uclass_find_device_by_phandle(id, parent, name, &dev); | |
388 | return uclass_get_device_tail(dev, ret, devp); | |
389 | } | |
c275dfef | 390 | #endif |
d82ba4c0 | 391 | |
54c5d08a | 392 | int uclass_first_device(enum uclass_id id, struct udevice **devp) |
6494d708 | 393 | { |
54c5d08a | 394 | struct udevice *dev; |
6494d708 SG |
395 | int ret; |
396 | ||
397 | *devp = NULL; | |
c1d6f919 | 398 | ret = uclass_find_first_device(id, &dev); |
f66529f9 SG |
399 | if (!dev) |
400 | return 0; | |
c1d6f919 | 401 | return uclass_get_device_tail(dev, ret, devp); |
6494d708 SG |
402 | } |
403 | ||
54c5d08a | 404 | int uclass_next_device(struct udevice **devp) |
6494d708 | 405 | { |
54c5d08a | 406 | struct udevice *dev = *devp; |
6494d708 SG |
407 | int ret; |
408 | ||
409 | *devp = NULL; | |
c1d6f919 | 410 | ret = uclass_find_next_device(&dev); |
f66529f9 SG |
411 | if (!dev) |
412 | return 0; | |
c1d6f919 | 413 | return uclass_get_device_tail(dev, ret, devp); |
6494d708 SG |
414 | } |
415 | ||
54c5d08a | 416 | int uclass_bind_device(struct udevice *dev) |
6494d708 SG |
417 | { |
418 | struct uclass *uc; | |
419 | int ret; | |
420 | ||
421 | uc = dev->uclass; | |
6494d708 SG |
422 | list_add_tail(&dev->uclass_node, &uc->dev_head); |
423 | ||
081f2fcb SG |
424 | if (dev->parent) { |
425 | struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv; | |
426 | ||
427 | if (uc_drv->child_post_bind) { | |
428 | ret = uc_drv->child_post_bind(dev); | |
429 | if (ret) | |
430 | goto err; | |
431 | } | |
432 | } | |
6494d708 SG |
433 | if (uc->uc_drv->post_bind) { |
434 | ret = uc->uc_drv->post_bind(dev); | |
081f2fcb SG |
435 | if (ret) |
436 | goto err; | |
6494d708 SG |
437 | } |
438 | ||
439 | return 0; | |
081f2fcb SG |
440 | err: |
441 | /* There is no need to undo the parent's post_bind call */ | |
442 | list_del(&dev->uclass_node); | |
443 | ||
444 | return ret; | |
6494d708 SG |
445 | } |
446 | ||
0a5804b5 | 447 | #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE) |
54c5d08a | 448 | int uclass_unbind_device(struct udevice *dev) |
6494d708 SG |
449 | { |
450 | struct uclass *uc; | |
451 | int ret; | |
452 | ||
453 | uc = dev->uclass; | |
454 | if (uc->uc_drv->pre_unbind) { | |
455 | ret = uc->uc_drv->pre_unbind(dev); | |
456 | if (ret) | |
457 | return ret; | |
458 | } | |
459 | ||
460 | list_del(&dev->uclass_node); | |
461 | return 0; | |
462 | } | |
7f9875e7 | 463 | #endif |
6494d708 | 464 | |
5a66a8ff SG |
465 | int uclass_resolve_seq(struct udevice *dev) |
466 | { | |
467 | struct udevice *dup; | |
468 | int seq; | |
469 | int ret; | |
470 | ||
471 | assert(dev->seq == -1); | |
472 | ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, dev->req_seq, | |
473 | false, &dup); | |
474 | if (!ret) { | |
475 | dm_warn("Device '%s': seq %d is in use by '%s'\n", | |
476 | dev->name, dev->req_seq, dup->name); | |
477 | } else if (ret == -ENODEV) { | |
478 | /* Our requested sequence number is available */ | |
479 | if (dev->req_seq != -1) | |
480 | return dev->req_seq; | |
481 | } else { | |
482 | return ret; | |
483 | } | |
484 | ||
485 | for (seq = 0; seq < DM_MAX_SEQ; seq++) { | |
486 | ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, seq, | |
487 | false, &dup); | |
488 | if (ret == -ENODEV) | |
489 | break; | |
490 | if (ret) | |
491 | return ret; | |
492 | } | |
493 | return seq; | |
494 | } | |
495 | ||
02c07b37 | 496 | int uclass_pre_probe_device(struct udevice *dev) |
83c7e434 SG |
497 | { |
498 | struct uclass_driver *uc_drv; | |
02c07b37 SG |
499 | int ret; |
500 | ||
501 | uc_drv = dev->uclass->uc_drv; | |
502 | if (uc_drv->pre_probe) { | |
503 | ret = uc_drv->pre_probe(dev); | |
504 | if (ret) | |
505 | return ret; | |
506 | } | |
83c7e434 SG |
507 | |
508 | if (!dev->parent) | |
509 | return 0; | |
510 | uc_drv = dev->parent->uclass->uc_drv; | |
511 | if (uc_drv->child_pre_probe) | |
512 | return uc_drv->child_pre_probe(dev); | |
513 | ||
514 | return 0; | |
515 | } | |
516 | ||
54c5d08a | 517 | int uclass_post_probe_device(struct udevice *dev) |
6494d708 SG |
518 | { |
519 | struct uclass_driver *uc_drv = dev->uclass->uc_drv; | |
520 | ||
521 | if (uc_drv->post_probe) | |
522 | return uc_drv->post_probe(dev); | |
523 | ||
524 | return 0; | |
525 | } | |
526 | ||
0a5804b5 | 527 | #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE) |
54c5d08a | 528 | int uclass_pre_remove_device(struct udevice *dev) |
6494d708 | 529 | { |
6494d708 SG |
530 | struct uclass *uc; |
531 | int ret; | |
532 | ||
533 | uc = dev->uclass; | |
6494d708 SG |
534 | if (uc->uc_drv->pre_remove) { |
535 | ret = uc->uc_drv->pre_remove(dev); | |
536 | if (ret) | |
537 | return ret; | |
538 | } | |
6494d708 SG |
539 | |
540 | return 0; | |
541 | } | |
7f9875e7 | 542 | #endif |