1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2013 Google, Inc
4 *
5 * (C) Copyright 2012
6 * Pavel Herrmann <morpheus.ibis@gmail.com>
7 */
8
9 #include <common.h>
10 #include <dm.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
uclass_find(enum uclass_id key)22 struct uclass *uclass_find(enum uclass_id key)
23 {
24 struct uclass *uc;
25
26 if (!gd->dm_root)
27 return NULL;
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 */
uclass_add(enum uclass_id id,struct uclass ** ucp)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) {
59 debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
60 id);
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;
67 }
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);
81 list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST);
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
uclass_destroy(struct uclass * uc)104 int uclass_destroy(struct uclass *uc)
105 {
106 struct uclass_driver *uc_drv;
107 struct udevice *dev;
108 int ret;
109
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);
119 ret = device_remove(dev, DM_REMOVE_NORMAL);
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
uclass_get(enum uclass_id id,struct uclass ** ucp)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
uclass_get_name(enum uclass_id id)151 const char *uclass_get_name(enum uclass_id id)
152 {
153 struct uclass *uc;
154
155 if (uclass_get(id, &uc))
156 return NULL;
157 return uc->uc_drv->name;
158 }
159
uclass_get_by_name(const char * name)160 enum uclass_id uclass_get_by_name(const char *name)
161 {
162 int i;
163
164 for (i = 0; i < UCLASS_COUNT; i++) {
165 struct uclass_driver *uc_drv = lists_uclass_lookup(i);
166
167 if (uc_drv && !strcmp(uc_drv->name, name))
168 return i;
169 }
170
171 return UCLASS_INVALID;
172 }
173
dev_get_uclass_index(struct udevice * dev,struct uclass ** ucp)174 int dev_get_uclass_index(struct udevice *dev, struct uclass **ucp)
175 {
176 struct udevice *iter;
177 struct uclass *uc = dev->uclass;
178 int i = 0;
179
180 if (list_empty(&uc->dev_head))
181 return -ENODEV;
182
183 uclass_foreach_dev(iter, uc) {
184 if (iter == dev) {
185 if (ucp)
186 *ucp = uc;
187 return i;
188 }
189 i++;
190 }
191
192 return -ENODEV;
193 }
194
uclass_find_device(enum uclass_id id,int index,struct udevice ** devp)195 int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
196 {
197 struct uclass *uc;
198 struct udevice *dev;
199 int ret;
200
201 *devp = NULL;
202 ret = uclass_get(id, &uc);
203 if (ret)
204 return ret;
205 if (list_empty(&uc->dev_head))
206 return -ENODEV;
207
208 uclass_foreach_dev(dev, uc) {
209 if (!index--) {
210 *devp = dev;
211 return 0;
212 }
213 }
214
215 return -ENODEV;
216 }
217
uclass_find_first_device(enum uclass_id id,struct udevice ** devp)218 int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
219 {
220 struct uclass *uc;
221 int ret;
222
223 *devp = NULL;
224 ret = uclass_get(id, &uc);
225 if (ret)
226 return ret;
227 if (list_empty(&uc->dev_head))
228 return -ENODEV;
229
230 *devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
231
232 return 0;
233 }
234
uclass_find_next_device(struct udevice ** devp)235 int uclass_find_next_device(struct udevice **devp)
236 {
237 struct udevice *dev = *devp;
238
239 *devp = NULL;
240 if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
241 return 0;
242
243 *devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);
244
245 return 0;
246 }
247
uclass_find_device_by_name(enum uclass_id id,const char * name,struct udevice ** devp)248 int uclass_find_device_by_name(enum uclass_id id, const char *name,
249 struct udevice **devp)
250 {
251 struct uclass *uc;
252 struct udevice *dev;
253 int ret;
254
255 *devp = NULL;
256 if (!name)
257 return -EINVAL;
258 ret = uclass_get(id, &uc);
259 if (ret)
260 return ret;
261
262 uclass_foreach_dev(dev, uc) {
263 if (!strncmp(dev->name, name, strlen(name))) {
264 *devp = dev;
265 return 0;
266 }
267 }
268
269 return -ENODEV;
270 }
271
272 #if !CONFIG_IS_ENABLED(OF_CONTROL) || CONFIG_IS_ENABLED(OF_PLATDATA)
uclass_find_next_free_req_seq(enum uclass_id id)273 int uclass_find_next_free_req_seq(enum uclass_id id)
274 {
275 struct uclass *uc;
276 struct udevice *dev;
277 int ret;
278 int max = -1;
279
280 ret = uclass_get(id, &uc);
281 if (ret)
282 return ret;
283
284 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
285 if ((dev->req_seq != -1) && (dev->req_seq > max))
286 max = dev->req_seq;
287 }
288
289 if (max == -1)
290 return 0;
291
292 return max + 1;
293 }
294 #endif
295
uclass_find_device_by_seq(enum uclass_id id,int seq_or_req_seq,bool find_req_seq,struct udevice ** devp)296 int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
297 bool find_req_seq, struct udevice **devp)
298 {
299 struct uclass *uc;
300 struct udevice *dev;
301 int ret;
302
303 *devp = NULL;
304 debug("%s: %d %d\n", __func__, find_req_seq, seq_or_req_seq);
305 if (seq_or_req_seq == -1)
306 return -ENODEV;
307 ret = uclass_get(id, &uc);
308 if (ret)
309 return ret;
310
311 uclass_foreach_dev(dev, uc) {
312 debug(" - %d %d '%s'\n", dev->req_seq, dev->seq, dev->name);
313 if ((find_req_seq ? dev->req_seq : dev->seq) ==
314 seq_or_req_seq) {
315 *devp = dev;
316 debug(" - found\n");
317 return 0;
318 }
319 }
320 debug(" - not found\n");
321
322 return -ENODEV;
323 }
324
uclass_find_device_by_of_offset(enum uclass_id id,int node,struct udevice ** devp)325 int uclass_find_device_by_of_offset(enum uclass_id id, int node,
326 struct udevice **devp)
327 {
328 struct uclass *uc;
329 struct udevice *dev;
330 int ret;
331
332 *devp = NULL;
333 if (node < 0)
334 return -ENODEV;
335 ret = uclass_get(id, &uc);
336 if (ret)
337 return ret;
338
339 uclass_foreach_dev(dev, uc) {
340 if (dev_of_offset(dev) == node) {
341 *devp = dev;
342 return 0;
343 }
344 }
345
346 return -ENODEV;
347 }
348
uclass_find_device_by_ofnode(enum uclass_id id,ofnode node,struct udevice ** devp)349 int uclass_find_device_by_ofnode(enum uclass_id id, ofnode node,
350 struct udevice **devp)
351 {
352 struct uclass *uc;
353 struct udevice *dev;
354 int ret;
355
356 log(LOGC_DM, LOGL_DEBUG, "Looking for %s\n", ofnode_get_name(node));
357 *devp = NULL;
358 if (!ofnode_valid(node))
359 return -ENODEV;
360 ret = uclass_get(id, &uc);
361 if (ret)
362 return ret;
363
364 uclass_foreach_dev(dev, uc) {
365 log(LOGC_DM, LOGL_DEBUG_CONTENT, " - checking %s\n",
366 dev->name);
367 if (ofnode_equal(dev_ofnode(dev), node)) {
368 *devp = dev;
369 goto done;
370 }
371 }
372 ret = -ENODEV;
373
374 done:
375 log(LOGC_DM, LOGL_DEBUG, " - result for %s: %s (ret=%d)\n",
376 ofnode_get_name(node), *devp ? (*devp)->name : "(none)", ret);
377 return ret;
378 }
379
380 #if CONFIG_IS_ENABLED(OF_CONTROL)
uclass_find_device_by_phandle(enum uclass_id id,struct udevice * parent,const char * name,struct udevice ** devp)381 int uclass_find_device_by_phandle(enum uclass_id id, struct udevice *parent,
382 const char *name, struct udevice **devp)
383 {
384 struct udevice *dev;
385 struct uclass *uc;
386 int find_phandle;
387 int ret;
388
389 *devp = NULL;
390 find_phandle = dev_read_u32_default(parent, name, -1);
391 if (find_phandle <= 0)
392 return -ENOENT;
393 ret = uclass_get(id, &uc);
394 if (ret)
395 return ret;
396
397 uclass_foreach_dev(dev, uc) {
398 uint phandle;
399
400 phandle = dev_read_phandle(dev);
401
402 if (phandle == find_phandle) {
403 *devp = dev;
404 return 0;
405 }
406 }
407
408 return -ENODEV;
409 }
410 #endif
411
uclass_get_device_by_driver(enum uclass_id id,const struct driver * find_drv,struct udevice ** devp)412 int uclass_get_device_by_driver(enum uclass_id id,
413 const struct driver *find_drv,
414 struct udevice **devp)
415 {
416 struct udevice *dev;
417 struct uclass *uc;
418 int ret;
419
420 ret = uclass_get(id, &uc);
421 if (ret)
422 return ret;
423
424 uclass_foreach_dev(dev, uc) {
425 if (dev->driver == find_drv)
426 return uclass_get_device_tail(dev, 0, devp);
427 }
428
429 return -ENODEV;
430 }
431
uclass_get_device_tail(struct udevice * dev,int ret,struct udevice ** devp)432 int uclass_get_device_tail(struct udevice *dev, int ret, struct udevice **devp)
433 {
434 if (ret)
435 return ret;
436
437 assert(dev);
438 ret = device_probe(dev);
439 if (ret)
440 return ret;
441
442 *devp = dev;
443
444 return 0;
445 }
446
uclass_get_device(enum uclass_id id,int index,struct udevice ** devp)447 int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
448 {
449 struct udevice *dev;
450 int ret;
451
452 *devp = NULL;
453 ret = uclass_find_device(id, index, &dev);
454 return uclass_get_device_tail(dev, ret, devp);
455 }
456
uclass_get_device_by_name(enum uclass_id id,const char * name,struct udevice ** devp)457 int uclass_get_device_by_name(enum uclass_id id, const char *name,
458 struct udevice **devp)
459 {
460 struct udevice *dev;
461 int ret;
462
463 *devp = NULL;
464 ret = uclass_find_device_by_name(id, name, &dev);
465 return uclass_get_device_tail(dev, ret, devp);
466 }
467
uclass_get_device_by_seq(enum uclass_id id,int seq,struct udevice ** devp)468 int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
469 {
470 struct udevice *dev;
471 int ret;
472
473 *devp = NULL;
474 ret = uclass_find_device_by_seq(id, seq, false, &dev);
475 if (ret == -ENODEV) {
476 /*
477 * We didn't find it in probed devices. See if there is one
478 * that will request this seq if probed.
479 */
480 ret = uclass_find_device_by_seq(id, seq, true, &dev);
481 }
482 return uclass_get_device_tail(dev, ret, devp);
483 }
484
uclass_get_device_by_of_offset(enum uclass_id id,int node,struct udevice ** devp)485 int uclass_get_device_by_of_offset(enum uclass_id id, int node,
486 struct udevice **devp)
487 {
488 struct udevice *dev;
489 int ret;
490
491 *devp = NULL;
492 ret = uclass_find_device_by_of_offset(id, node, &dev);
493 return uclass_get_device_tail(dev, ret, devp);
494 }
495
uclass_get_device_by_ofnode(enum uclass_id id,ofnode node,struct udevice ** devp)496 int uclass_get_device_by_ofnode(enum uclass_id id, ofnode node,
497 struct udevice **devp)
498 {
499 struct udevice *dev;
500 int ret;
501
502 log(LOGC_DM, LOGL_DEBUG, "Looking for %s\n", ofnode_get_name(node));
503 *devp = NULL;
504 ret = uclass_find_device_by_ofnode(id, node, &dev);
505 log(LOGC_DM, LOGL_DEBUG, " - result for %s: %s (ret=%d)\n",
506 ofnode_get_name(node), dev ? dev->name : "(none)", ret);
507
508 return uclass_get_device_tail(dev, ret, devp);
509 }
510
511 #if CONFIG_IS_ENABLED(OF_CONTROL)
uclass_get_device_by_phandle_id(enum uclass_id id,uint phandle_id,struct udevice ** devp)512 int uclass_get_device_by_phandle_id(enum uclass_id id, uint phandle_id,
513 struct udevice **devp)
514 {
515 struct udevice *dev;
516 struct uclass *uc;
517 int ret;
518
519 *devp = NULL;
520 ret = uclass_get(id, &uc);
521 if (ret)
522 return ret;
523
524 uclass_foreach_dev(dev, uc) {
525 uint phandle;
526
527 phandle = dev_read_phandle(dev);
528
529 if (phandle == phandle_id) {
530 *devp = dev;
531 return uclass_get_device_tail(dev, ret, devp);
532 }
533 }
534
535 return -ENODEV;
536 }
537
uclass_get_device_by_phandle(enum uclass_id id,struct udevice * parent,const char * name,struct udevice ** devp)538 int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
539 const char *name, struct udevice **devp)
540 {
541 struct udevice *dev;
542 int ret;
543
544 *devp = NULL;
545 ret = uclass_find_device_by_phandle(id, parent, name, &dev);
546 return uclass_get_device_tail(dev, ret, devp);
547 }
548 #endif
549
uclass_first_device(enum uclass_id id,struct udevice ** devp)550 int uclass_first_device(enum uclass_id id, struct udevice **devp)
551 {
552 struct udevice *dev;
553 int ret;
554
555 *devp = NULL;
556 ret = uclass_find_first_device(id, &dev);
557 if (!dev)
558 return 0;
559 return uclass_get_device_tail(dev, ret, devp);
560 }
561
uclass_first_device_err(enum uclass_id id,struct udevice ** devp)562 int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
563 {
564 int ret;
565
566 ret = uclass_first_device(id, devp);
567 if (ret)
568 return ret;
569 else if (!*devp)
570 return -ENODEV;
571
572 return 0;
573 }
574
uclass_next_device(struct udevice ** devp)575 int uclass_next_device(struct udevice **devp)
576 {
577 struct udevice *dev = *devp;
578 int ret;
579
580 *devp = NULL;
581 ret = uclass_find_next_device(&dev);
582 if (!dev)
583 return 0;
584 return uclass_get_device_tail(dev, ret, devp);
585 }
586
uclass_next_device_err(struct udevice ** devp)587 int uclass_next_device_err(struct udevice **devp)
588 {
589 int ret;
590
591 ret = uclass_next_device(devp);
592 if (ret)
593 return ret;
594 else if (!*devp)
595 return -ENODEV;
596
597 return 0;
598 }
599
uclass_first_device_check(enum uclass_id id,struct udevice ** devp)600 int uclass_first_device_check(enum uclass_id id, struct udevice **devp)
601 {
602 int ret;
603
604 *devp = NULL;
605 ret = uclass_find_first_device(id, devp);
606 if (ret)
607 return ret;
608 if (!*devp)
609 return 0;
610
611 return device_probe(*devp);
612 }
613
uclass_next_device_check(struct udevice ** devp)614 int uclass_next_device_check(struct udevice **devp)
615 {
616 int ret;
617
618 ret = uclass_find_next_device(devp);
619 if (ret)
620 return ret;
621 if (!*devp)
622 return 0;
623
624 return device_probe(*devp);
625 }
626
uclass_bind_device(struct udevice * dev)627 int uclass_bind_device(struct udevice *dev)
628 {
629 struct uclass *uc;
630 int ret;
631
632 uc = dev->uclass;
633 list_add_tail(&dev->uclass_node, &uc->dev_head);
634
635 if (dev->parent) {
636 struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv;
637
638 if (uc_drv->child_post_bind) {
639 ret = uc_drv->child_post_bind(dev);
640 if (ret)
641 goto err;
642 }
643 }
644
645 return 0;
646 err:
647 /* There is no need to undo the parent's post_bind call */
648 list_del(&dev->uclass_node);
649
650 return ret;
651 }
652
653 #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
uclass_unbind_device(struct udevice * dev)654 int uclass_unbind_device(struct udevice *dev)
655 {
656 struct uclass *uc;
657 int ret;
658
659 uc = dev->uclass;
660 if (uc->uc_drv->pre_unbind) {
661 ret = uc->uc_drv->pre_unbind(dev);
662 if (ret)
663 return ret;
664 }
665
666 list_del(&dev->uclass_node);
667 return 0;
668 }
669 #endif
670
uclass_resolve_seq(struct udevice * dev)671 int uclass_resolve_seq(struct udevice *dev)
672 {
673 struct udevice *dup;
674 int seq;
675 int ret;
676
677 assert(dev->seq == -1);
678 ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, dev->req_seq,
679 false, &dup);
680 if (!ret) {
681 dm_warn("Device '%s': seq %d is in use by '%s'\n",
682 dev->name, dev->req_seq, dup->name);
683 } else if (ret == -ENODEV) {
684 /* Our requested sequence number is available */
685 if (dev->req_seq != -1)
686 return dev->req_seq;
687 } else {
688 return ret;
689 }
690
691 for (seq = 0; seq < DM_MAX_SEQ; seq++) {
692 ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, seq,
693 false, &dup);
694 if (ret == -ENODEV)
695 break;
696 if (ret)
697 return ret;
698 }
699 return seq;
700 }
701
uclass_pre_probe_device(struct udevice * dev)702 int uclass_pre_probe_device(struct udevice *dev)
703 {
704 struct uclass_driver *uc_drv;
705 int ret;
706
707 uc_drv = dev->uclass->uc_drv;
708 if (uc_drv->pre_probe) {
709 ret = uc_drv->pre_probe(dev);
710 if (ret)
711 return ret;
712 }
713
714 if (!dev->parent)
715 return 0;
716 uc_drv = dev->parent->uclass->uc_drv;
717 if (uc_drv->child_pre_probe)
718 return uc_drv->child_pre_probe(dev);
719
720 return 0;
721 }
722
uclass_post_probe_device(struct udevice * dev)723 int uclass_post_probe_device(struct udevice *dev)
724 {
725 struct uclass_driver *uc_drv;
726 int ret;
727
728 if (dev->parent) {
729 uc_drv = dev->parent->uclass->uc_drv;
730 if (uc_drv->child_post_probe) {
731 ret = uc_drv->child_post_probe(dev);
732 if (ret)
733 return ret;
734 }
735 }
736
737 uc_drv = dev->uclass->uc_drv;
738 if (uc_drv->post_probe)
739 return uc_drv->post_probe(dev);
740
741 return 0;
742 }
743
744 #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
uclass_pre_remove_device(struct udevice * dev)745 int uclass_pre_remove_device(struct udevice *dev)
746 {
747 struct uclass *uc;
748 int ret;
749
750 uc = dev->uclass;
751 if (uc->uc_drv->pre_remove) {
752 ret = uc->uc_drv->pre_remove(dev);
753 if (ret)
754 return ret;
755 }
756
757 return 0;
758 }
759 #endif
760
761 UCLASS_DRIVER(nop) = {
762 .id = UCLASS_NOP,
763 .name = "nop",
764 };
765