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 <dm.h>
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
uclass_find(enum uclass_id key)23 struct uclass *uclass_find(enum uclass_id key)
24 {
25 struct uclass *uc;
26
27 if (!gd->dm_root)
28 return NULL;
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 if (uc->uc_drv->id == UCLASS_ROOT)
39 break;
40 }
41
42 return NULL;
43 }
44
45 /**
46 * uclass_add() - Create new uclass in list
47 * @id: Id number to create
48 * @ucp: Returns pointer to uclass, or NULL on error
49 * @return 0 on success, -ve on error
50 *
51 * The new uclass is added to the list. There must be only one uclass for
52 * each id.
53 */
uclass_add(enum uclass_id id,struct uclass ** ucp)54 static int uclass_add(enum uclass_id id, struct uclass **ucp)
55 {
56 struct uclass_driver *uc_drv;
57 struct uclass *uc;
58 int ret;
59
60 *ucp = NULL;
61 uc_drv = lists_uclass_lookup(id);
62 if (!uc_drv) {
63 debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
64 id);
65 /*
66 * Use a strange error to make this case easier to find. When
67 * a uclass is not available it can prevent driver model from
68 * starting up and this failure is otherwise hard to debug.
69 */
70 return -EPFNOSUPPORT;
71 }
72 uc = calloc(1, sizeof(*uc));
73 if (!uc)
74 return -ENOMEM;
75 if (uc_drv->priv_auto_alloc_size) {
76 uc->priv = calloc(1, uc_drv->priv_auto_alloc_size);
77 if (!uc->priv) {
78 ret = -ENOMEM;
79 goto fail_mem;
80 }
81 }
82 uc->uc_drv = uc_drv;
83 #ifdef CONFIG_USING_KERNEL_DTB_V2
84 uc->u_boot_dev_head = NULL;
85 #endif
86 INIT_LIST_HEAD(&uc->sibling_node);
87 INIT_LIST_HEAD(&uc->dev_head);
88 list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST);
89
90 if (uc_drv->init) {
91 ret = uc_drv->init(uc);
92 if (ret)
93 goto fail;
94 }
95
96 *ucp = uc;
97
98 return 0;
99 fail:
100 if (uc_drv->priv_auto_alloc_size) {
101 free(uc->priv);
102 uc->priv = NULL;
103 }
104 list_del(&uc->sibling_node);
105 fail_mem:
106 free(uc);
107
108 return ret;
109 }
110
uclass_destroy(struct uclass * uc)111 int uclass_destroy(struct uclass *uc)
112 {
113 struct uclass_driver *uc_drv;
114 struct udevice *dev;
115 int ret;
116
117 /*
118 * We cannot use list_for_each_entry_safe() here. If a device in this
119 * uclass has a child device also in this uclass, it will be also be
120 * unbound (by the recursion in the call to device_unbind() below).
121 * We can loop until the list is empty.
122 */
123 while (!list_empty(&uc->dev_head)) {
124 dev = list_first_entry(&uc->dev_head, struct udevice,
125 uclass_node);
126 ret = device_remove(dev, DM_REMOVE_NORMAL);
127 if (ret)
128 return ret;
129 ret = device_unbind(dev);
130 if (ret)
131 return ret;
132 }
133
134 uc_drv = uc->uc_drv;
135 if (uc_drv->destroy)
136 uc_drv->destroy(uc);
137 list_del(&uc->sibling_node);
138 if (uc_drv->priv_auto_alloc_size)
139 free(uc->priv);
140 free(uc);
141
142 return 0;
143 }
144
uclass_get(enum uclass_id id,struct uclass ** ucp)145 int uclass_get(enum uclass_id id, struct uclass **ucp)
146 {
147 struct uclass *uc;
148
149 *ucp = NULL;
150 uc = uclass_find(id);
151 if (!uc)
152 return uclass_add(id, ucp);
153 *ucp = uc;
154
155 return 0;
156 }
157
uclass_get_name(enum uclass_id id)158 const char *uclass_get_name(enum uclass_id id)
159 {
160 struct uclass *uc;
161
162 if (uclass_get(id, &uc))
163 return NULL;
164 return uc->uc_drv->name;
165 }
166
uclass_get_by_name(const char * name)167 enum uclass_id uclass_get_by_name(const char *name)
168 {
169 int i;
170
171 for (i = 0; i < UCLASS_COUNT; i++) {
172 struct uclass_driver *uc_drv = lists_uclass_lookup(i);
173
174 if (uc_drv && !strcmp(uc_drv->name, name))
175 return i;
176 }
177
178 return UCLASS_INVALID;
179 }
180
uclass_find_device(enum uclass_id id,int index,struct udevice ** devp)181 int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
182 {
183 struct uclass *uc;
184 struct udevice *dev;
185 int ret;
186
187 *devp = NULL;
188 ret = uclass_get(id, &uc);
189 if (ret)
190 return ret;
191 if (list_empty(&uc->dev_head))
192 return -ENODEV;
193
194 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
195 if (!index--) {
196 *devp = dev;
197 return 0;
198 }
199 }
200
201 return -ENODEV;
202 }
203
uclass_find_first_device(enum uclass_id id,struct udevice ** devp)204 int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
205 {
206 struct uclass *uc;
207 int ret;
208
209 *devp = NULL;
210 ret = uclass_get(id, &uc);
211 if (ret)
212 return ret;
213 if (list_empty(&uc->dev_head))
214 return 0;
215
216 *devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
217
218 return 0;
219 }
220
uclass_find_next_device(struct udevice ** devp)221 int uclass_find_next_device(struct udevice **devp)
222 {
223 struct udevice *dev = *devp;
224
225 *devp = NULL;
226 if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
227 return 0;
228
229 *devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);
230
231 return 0;
232 }
233
uclass_find_device_by_name(enum uclass_id id,const char * name,struct udevice ** devp)234 int uclass_find_device_by_name(enum uclass_id id, const char *name,
235 struct udevice **devp)
236 {
237 struct uclass *uc;
238 struct udevice *dev;
239 int ret;
240
241 *devp = NULL;
242 if (!name)
243 return -EINVAL;
244 ret = uclass_get(id, &uc);
245 if (ret)
246 return ret;
247
248 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
249 if (!strncmp(dev->name, name, strlen(name))) {
250 *devp = dev;
251 return 0;
252 }
253 }
254
255 return -ENODEV;
256 }
257
uclass_find_device_by_seq(enum uclass_id id,int seq_or_req_seq,bool find_req_seq,struct udevice ** devp)258 int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
259 bool find_req_seq, struct udevice **devp)
260 {
261 struct uclass *uc;
262 struct udevice *dev;
263 int ret;
264
265 *devp = NULL;
266 pr_debug("%s: %d %d\n", __func__, find_req_seq, seq_or_req_seq);
267 if (seq_or_req_seq == -1)
268 return -ENODEV;
269 ret = uclass_get(id, &uc);
270 if (ret)
271 return ret;
272
273 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
274 pr_debug(" - %d %d '%s'\n", dev->req_seq, dev->seq, dev->name);
275 if ((find_req_seq ? dev->req_seq : dev->seq) ==
276 seq_or_req_seq) {
277 *devp = dev;
278 pr_debug(" - found\n");
279 return 0;
280 }
281 }
282 pr_debug(" - not found\n");
283
284 return -ENODEV;
285 }
286
uclass_find_device_by_of_offset(enum uclass_id id,int node,struct udevice ** devp)287 int uclass_find_device_by_of_offset(enum uclass_id id, int node,
288 struct udevice **devp)
289 {
290 struct uclass *uc;
291 struct udevice *dev;
292 int ret;
293
294 *devp = NULL;
295 if (node < 0)
296 return -ENODEV;
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 if (dev_of_offset(dev) == node) {
303 *devp = dev;
304 return 0;
305 }
306 }
307
308 return -ENODEV;
309 }
310
uclass_find_device_by_ofnode(enum uclass_id id,ofnode node,struct udevice ** devp)311 int uclass_find_device_by_ofnode(enum uclass_id id, ofnode node,
312 struct udevice **devp)
313 {
314 struct uclass *uc;
315 struct udevice *dev;
316 int ret;
317
318 *devp = NULL;
319 if (!ofnode_valid(node))
320 return -ENODEV;
321 ret = uclass_get(id, &uc);
322 if (ret)
323 return ret;
324
325 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
326 if (ofnode_equal(dev_ofnode(dev), node)) {
327 *devp = dev;
328 return 0;
329 }
330 }
331
332 return -ENODEV;
333 }
334
335 #if CONFIG_IS_ENABLED(OF_CONTROL)
uclass_find_device_by_phandle(enum uclass_id id,struct udevice * parent,const char * name,struct udevice ** devp)336 static int uclass_find_device_by_phandle(enum uclass_id id,
337 struct udevice *parent,
338 const char *name,
339 struct udevice **devp)
340 {
341 struct udevice *dev;
342 struct uclass *uc;
343 int find_phandle;
344 int ret;
345
346 *devp = NULL;
347 find_phandle = dev_read_u32_default(parent, name, -1);
348 if (find_phandle <= 0)
349 return -ENOENT;
350 ret = uclass_get(id, &uc);
351 if (ret)
352 return ret;
353
354 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
355 uint phandle;
356
357 phandle = dev_read_phandle(dev);
358
359 if (phandle == find_phandle) {
360 *devp = dev;
361 return 0;
362 }
363 }
364
365 return -ENODEV;
366 }
367 #endif
368
uclass_get_device_by_driver(enum uclass_id id,const struct driver * find_drv,struct udevice ** devp)369 int uclass_get_device_by_driver(enum uclass_id id,
370 const struct driver *find_drv,
371 struct udevice **devp)
372 {
373 struct udevice *dev;
374 struct uclass *uc;
375 int ret;
376
377 ret = uclass_get(id, &uc);
378 if (ret)
379 return ret;
380
381 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
382 if (dev->driver == find_drv)
383 return uclass_get_device_tail(dev, 0, devp);
384 }
385
386 return -ENODEV;
387 }
388
uclass_get_device_tail(struct udevice * dev,int ret,struct udevice ** devp)389 int uclass_get_device_tail(struct udevice *dev, int ret, struct udevice **devp)
390 {
391 if (ret)
392 return ret;
393
394 assert(dev);
395 ret = device_probe(dev);
396 if (ret)
397 return ret;
398
399 *devp = dev;
400
401 return 0;
402 }
403
uclass_get_device(enum uclass_id id,int index,struct udevice ** devp)404 int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
405 {
406 struct udevice *dev;
407 int ret;
408
409 *devp = NULL;
410 ret = uclass_find_device(id, index, &dev);
411 return uclass_get_device_tail(dev, ret, devp);
412 }
413
uclass_get_device_by_name(enum uclass_id id,const char * name,struct udevice ** devp)414 int uclass_get_device_by_name(enum uclass_id id, const char *name,
415 struct udevice **devp)
416 {
417 struct udevice *dev;
418 int ret;
419
420 *devp = NULL;
421 ret = uclass_find_device_by_name(id, name, &dev);
422 return uclass_get_device_tail(dev, ret, devp);
423 }
424
uclass_get_device_by_seq(enum uclass_id id,int seq,struct udevice ** devp)425 int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
426 {
427 struct udevice *dev;
428 int ret;
429
430 *devp = NULL;
431 ret = uclass_find_device_by_seq(id, seq, false, &dev);
432 if (ret == -ENODEV) {
433 /*
434 * We didn't find it in probed devices. See if there is one
435 * that will request this seq if probed.
436 */
437 ret = uclass_find_device_by_seq(id, seq, true, &dev);
438 }
439 return uclass_get_device_tail(dev, ret, devp);
440 }
441
uclass_get_device_by_of_offset(enum uclass_id id,int node,struct udevice ** devp)442 int uclass_get_device_by_of_offset(enum uclass_id id, int node,
443 struct udevice **devp)
444 {
445 struct udevice *dev;
446 int ret;
447
448 *devp = NULL;
449 ret = uclass_find_device_by_of_offset(id, node, &dev);
450 return uclass_get_device_tail(dev, ret, devp);
451 }
452
uclass_get_device_by_ofnode(enum uclass_id id,ofnode node,struct udevice ** devp)453 int uclass_get_device_by_ofnode(enum uclass_id id, ofnode node,
454 struct udevice **devp)
455 {
456 struct udevice *dev;
457 int ret;
458
459 *devp = NULL;
460 ret = uclass_find_device_by_ofnode(id, node, &dev);
461
462 return uclass_get_device_tail(dev, ret, devp);
463 }
464
465 #if CONFIG_IS_ENABLED(OF_CONTROL)
uclass_get_device_by_phandle_id(enum uclass_id id,uint phandle_id,struct udevice ** devp)466 int uclass_get_device_by_phandle_id(enum uclass_id id, uint phandle_id,
467 struct udevice **devp)
468 {
469 struct udevice *dev;
470 struct uclass *uc;
471 int ret;
472
473 *devp = NULL;
474 ret = uclass_get(id, &uc);
475 if (ret)
476 return ret;
477
478 ret = -ENODEV;
479 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
480 uint phandle;
481
482 phandle = dev_read_phandle(dev);
483
484 if (phandle == phandle_id) {
485 *devp = dev;
486 ret = 0;
487 break;
488 }
489 }
490
491 return uclass_get_device_tail(dev, ret, devp);
492 }
493
uclass_get_device_by_phandle(enum uclass_id id,struct udevice * parent,const char * name,struct udevice ** devp)494 int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
495 const char *name, struct udevice **devp)
496 {
497 struct udevice *dev;
498 int ret;
499
500 *devp = NULL;
501 ret = uclass_find_device_by_phandle(id, parent, name, &dev);
502 return uclass_get_device_tail(dev, ret, devp);
503 }
504 #endif
505
506 /*
507 * Starting from the given device @dev, return pointer to the first device in
508 * the uclass that probes successfully in @devp.
509 */
_uclass_next_device(struct udevice * dev,struct udevice ** devp)510 static void _uclass_next_device(struct udevice *dev, struct udevice **devp)
511 {
512 for (; dev; uclass_find_next_device(&dev)) {
513 if (!device_probe(dev))
514 break;
515 }
516 *devp = dev;
517 }
518
uclass_first_device(enum uclass_id id,struct udevice ** devp)519 void uclass_first_device(enum uclass_id id, struct udevice **devp)
520 {
521 struct udevice *dev;
522
523 uclass_find_first_device(id, &dev);
524 _uclass_next_device(dev, devp);
525 }
526
uclass_next_device(struct udevice ** devp)527 void uclass_next_device(struct udevice **devp)
528 {
529 struct udevice *dev = *devp;
530
531 uclass_find_next_device(&dev);
532 _uclass_next_device(dev, devp);
533 }
534
uclass_first_device_err(enum uclass_id id,struct udevice ** devp)535 int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
536 {
537 int ret;
538
539 ret = uclass_first_device_check(id, devp);
540 if (ret)
541 return ret;
542 else if (!*devp)
543 return -ENODEV;
544
545 return 0;
546 }
547
uclass_next_device_err(struct udevice ** devp)548 int uclass_next_device_err(struct udevice **devp)
549 {
550 int ret;
551
552 ret = uclass_next_device_check(devp);
553 if (ret)
554 return ret;
555 else if (!*devp)
556 return -ENODEV;
557
558 return 0;
559 }
560
uclass_first_device_check(enum uclass_id id,struct udevice ** devp)561 int uclass_first_device_check(enum uclass_id id, struct udevice **devp)
562 {
563 int ret;
564
565 *devp = NULL;
566 ret = uclass_find_first_device(id, devp);
567 if (ret)
568 return ret;
569 if (!*devp)
570 return 0;
571
572 return device_probe(*devp);
573 }
574
uclass_next_device_check(struct udevice ** devp)575 int uclass_next_device_check(struct udevice **devp)
576 {
577 int ret;
578
579 ret = uclass_find_next_device(devp);
580 if (ret)
581 return ret;
582 if (!*devp)
583 return 0;
584
585 return device_probe(*devp);
586 }
587
uclass_first_device_drvdata(enum uclass_id id,ulong driver_data,struct udevice ** devp)588 int uclass_first_device_drvdata(enum uclass_id id, ulong driver_data,
589 struct udevice **devp)
590 {
591 struct udevice *dev;
592 struct uclass *uc;
593
594 uclass_id_foreach_dev(id, dev, uc) {
595 if (dev_get_driver_data(dev) == driver_data) {
596 *devp = dev;
597
598 return device_probe(dev);
599 }
600 }
601
602 return -ENODEV;
603 }
604
uclass_bind_device(struct udevice * dev,bool after_u_boot_dev)605 int uclass_bind_device(struct udevice *dev, bool after_u_boot_dev)
606 {
607 struct uclass *uc;
608 int ret;
609
610 uc = dev->uclass;
611 #ifdef CONFIG_USING_KERNEL_DTB_V2
612 if (after_u_boot_dev)
613 list_add_tail(&dev->uclass_node, &uc->dev_head);
614 else
615 list_add_tail(&dev->uclass_node, uc->u_boot_dev_head);
616 #else
617 list_add_tail(&dev->uclass_node, &uc->dev_head);
618 #endif
619 if (dev->parent) {
620 struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv;
621
622 if (uc_drv->child_post_bind) {
623 ret = uc_drv->child_post_bind(dev);
624 if (ret)
625 goto err;
626 }
627 }
628
629 return 0;
630 err:
631 /* There is no need to undo the parent's post_bind call */
632 list_del(&dev->uclass_node);
633
634 return ret;
635 }
636
637 #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
uclass_unbind_device(struct udevice * dev)638 int uclass_unbind_device(struct udevice *dev)
639 {
640 struct uclass *uc;
641 int ret;
642
643 uc = dev->uclass;
644 if (uc->uc_drv->pre_unbind) {
645 ret = uc->uc_drv->pre_unbind(dev);
646 if (ret)
647 return ret;
648 }
649
650 list_del(&dev->uclass_node);
651 return 0;
652 }
653 #endif
654
uclass_resolve_seq(struct udevice * dev)655 int uclass_resolve_seq(struct udevice *dev)
656 {
657 struct udevice *dup;
658 int seq;
659 int ret;
660
661 assert(dev->seq == -1);
662 ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, dev->req_seq,
663 false, &dup);
664 if (!ret) {
665 dm_warn("Device '%s': seq %d is in use by '%s'\n",
666 dev->name, dev->req_seq, dup->name);
667 } else if (ret == -ENODEV) {
668 /* Our requested sequence number is available */
669 if (dev->req_seq != -1)
670 return dev->req_seq;
671 } else {
672 return ret;
673 }
674
675 for (seq = 0; seq < DM_MAX_SEQ; seq++) {
676 ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, seq,
677 false, &dup);
678 if (ret == -ENODEV)
679 break;
680 if (ret)
681 return ret;
682 }
683 return seq;
684 }
685
uclass_pre_probe_device(struct udevice * dev)686 int uclass_pre_probe_device(struct udevice *dev)
687 {
688 struct uclass_driver *uc_drv;
689 int ret;
690
691 uc_drv = dev->uclass->uc_drv;
692 if (uc_drv->pre_probe) {
693 ret = uc_drv->pre_probe(dev);
694 if (ret)
695 return ret;
696 }
697
698 if (!dev->parent)
699 return 0;
700 uc_drv = dev->parent->uclass->uc_drv;
701 if (uc_drv->child_pre_probe)
702 return uc_drv->child_pre_probe(dev);
703
704 return 0;
705 }
706
uclass_post_probe_device(struct udevice * dev)707 int uclass_post_probe_device(struct udevice *dev)
708 {
709 struct uclass_driver *uc_drv = dev->uclass->uc_drv;
710
711 if (uc_drv->post_probe)
712 return uc_drv->post_probe(dev);
713
714 return 0;
715 }
716
717 #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
uclass_pre_remove_device(struct udevice * dev)718 int uclass_pre_remove_device(struct udevice *dev)
719 {
720 struct uclass *uc;
721 int ret;
722
723 uc = dev->uclass;
724 if (uc->uc_drv->pre_remove) {
725 ret = uc->uc_drv->pre_remove(dev);
726 if (ret)
727 return ret;
728 }
729
730 return 0;
731 }
732 #endif
733
734 UCLASS_DRIVER(nop) = {
735 .id = UCLASS_NOP,
736 .name = "nop",
737 };
738