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