1
2
3
4
5
6
7
8
9
10
11#include <common.h>
12#include <cpu_func.h>
13#include <event.h>
14#include <log.h>
15#include <asm/global_data.h>
16#include <asm/io.h>
17#include <clk.h>
18#include <fdtdec.h>
19#include <fdt_support.h>
20#include <malloc.h>
21#include <asm/cache.h>
22#include <dm/device.h>
23#include <dm/device-internal.h>
24#include <dm/lists.h>
25#include <dm/of_access.h>
26#include <dm/pinctrl.h>
27#include <dm/platdata.h>
28#include <dm/read.h>
29#include <dm/uclass.h>
30#include <dm/uclass-internal.h>
31#include <dm/util.h>
32#include <iommu.h>
33#include <linux/err.h>
34#include <linux/list.h>
35#include <power-domain.h>
36
37DECLARE_GLOBAL_DATA_PTR;
38
39static int device_bind_common(struct udevice *parent, const struct driver *drv,
40 const char *name, void *plat,
41 ulong driver_data, ofnode node,
42 uint of_plat_size, struct udevice **devp)
43{
44 struct udevice *dev;
45 struct uclass *uc;
46 int size, ret = 0;
47 bool auto_seq = true;
48 void *ptr;
49
50 if (CONFIG_IS_ENABLED(OF_PLATDATA_NO_BIND))
51 return -ENOSYS;
52
53 if (devp)
54 *devp = NULL;
55 if (!name)
56 return -EINVAL;
57
58 ret = uclass_get(drv->id, &uc);
59 if (ret) {
60 debug("Missing uclass for driver %s\n", drv->name);
61 return ret;
62 }
63
64 dev = calloc(1, sizeof(struct udevice));
65 if (!dev)
66 return -ENOMEM;
67
68 INIT_LIST_HEAD(&dev->sibling_node);
69 INIT_LIST_HEAD(&dev->child_head);
70 INIT_LIST_HEAD(&dev->uclass_node);
71#if CONFIG_IS_ENABLED(DEVRES)
72 INIT_LIST_HEAD(&dev->devres_head);
73#endif
74 dev_set_plat(dev, plat);
75 dev->driver_data = driver_data;
76 dev->name = name;
77 dev_set_ofnode(dev, node);
78 dev->parent = parent;
79 dev->driver = drv;
80 dev->uclass = uc;
81
82 dev->seq_ = -1;
83 if (CONFIG_IS_ENABLED(DM_SEQ_ALIAS) &&
84 (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS)) {
85
86
87
88
89 if (CONFIG_IS_ENABLED(OF_CONTROL) &&
90 !CONFIG_IS_ENABLED(OF_PLATDATA)) {
91 if (uc->uc_drv->name && ofnode_valid(node)) {
92 if (!dev_read_alias_seq(dev, &dev->seq_)) {
93 auto_seq = false;
94 log_debug(" - seq=%d\n", dev->seq_);
95 }
96 }
97 }
98 }
99 if (auto_seq && !(uc->uc_drv->flags & DM_UC_FLAG_NO_AUTO_SEQ))
100 dev->seq_ = uclass_find_next_free_seq(uc);
101
102
103 if (drv->plat_auto) {
104 bool alloc = !plat;
105
106
107
108
109
110 if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
111 if (of_plat_size)
112 dev_or_flags(dev, DM_FLAG_OF_PLATDATA);
113 if (of_plat_size < drv->plat_auto)
114 alloc = true;
115 }
116 if (alloc) {
117 dev_or_flags(dev, DM_FLAG_ALLOC_PDATA);
118 ptr = calloc(1, drv->plat_auto);
119 if (!ptr) {
120 ret = -ENOMEM;
121 goto fail_alloc1;
122 }
123
124
125
126
127
128 if (CONFIG_IS_ENABLED(OF_PLATDATA) && plat)
129 memcpy(ptr, plat, of_plat_size);
130 dev_set_plat(dev, ptr);
131 }
132 }
133
134 size = uc->uc_drv->per_device_plat_auto;
135 if (size) {
136 dev_or_flags(dev, DM_FLAG_ALLOC_UCLASS_PDATA);
137 ptr = calloc(1, size);
138 if (!ptr) {
139 ret = -ENOMEM;
140 goto fail_alloc2;
141 }
142 dev_set_uclass_plat(dev, ptr);
143 }
144
145 if (parent) {
146 size = parent->driver->per_child_plat_auto;
147 if (!size)
148 size = parent->uclass->uc_drv->per_child_plat_auto;
149 if (size) {
150 dev_or_flags(dev, DM_FLAG_ALLOC_PARENT_PDATA);
151 ptr = calloc(1, size);
152 if (!ptr) {
153 ret = -ENOMEM;
154 goto fail_alloc3;
155 }
156 dev_set_parent_plat(dev, ptr);
157 }
158
159 list_add_tail(&dev->sibling_node, &parent->child_head);
160 }
161
162 ret = uclass_bind_device(dev);
163 if (ret)
164 goto fail_uclass_bind;
165
166
167 if (drv->bind) {
168 ret = drv->bind(dev);
169 if (ret)
170 goto fail_bind;
171 }
172 if (parent && parent->driver->child_post_bind) {
173 ret = parent->driver->child_post_bind(dev);
174 if (ret)
175 goto fail_child_post_bind;
176 }
177 if (uc->uc_drv->post_bind) {
178 ret = uc->uc_drv->post_bind(dev);
179 if (ret)
180 goto fail_uclass_post_bind;
181 }
182
183 if (parent)
184 pr_debug("Bound device %s to %s\n", dev->name, parent->name);
185 if (devp)
186 *devp = dev;
187
188 dev_or_flags(dev, DM_FLAG_BOUND);
189
190 return 0;
191
192fail_uclass_post_bind:
193
194fail_child_post_bind:
195 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
196 if (drv->unbind && drv->unbind(dev)) {
197 dm_warn("unbind() method failed on dev '%s' on error path\n",
198 dev->name);
199 }
200 }
201
202fail_bind:
203 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
204 if (uclass_unbind_device(dev)) {
205 dm_warn("Failed to unbind dev '%s' on error path\n",
206 dev->name);
207 }
208 }
209fail_uclass_bind:
210 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
211 list_del(&dev->sibling_node);
212 if (dev_get_flags(dev) & DM_FLAG_ALLOC_PARENT_PDATA) {
213 free(dev_get_parent_plat(dev));
214 dev_set_parent_plat(dev, NULL);
215 }
216 }
217fail_alloc3:
218 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
219 if (dev_get_flags(dev) & DM_FLAG_ALLOC_UCLASS_PDATA) {
220 free(dev_get_uclass_plat(dev));
221 dev_set_uclass_plat(dev, NULL);
222 }
223 }
224fail_alloc2:
225 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
226 if (dev_get_flags(dev) & DM_FLAG_ALLOC_PDATA) {
227 free(dev_get_plat(dev));
228 dev_set_plat(dev, NULL);
229 }
230 }
231fail_alloc1:
232 devres_release_all(dev);
233
234 free(dev);
235
236 return ret;
237}
238
239int device_bind_with_driver_data(struct udevice *parent,
240 const struct driver *drv, const char *name,
241 ulong driver_data, ofnode node,
242 struct udevice **devp)
243{
244 return device_bind_common(parent, drv, name, NULL, driver_data, node,
245 0, devp);
246}
247
248int device_bind(struct udevice *parent, const struct driver *drv,
249 const char *name, void *plat, ofnode node,
250 struct udevice **devp)
251{
252 return device_bind_common(parent, drv, name, plat, 0, node, 0,
253 devp);
254}
255
256int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
257 const struct driver_info *info, struct udevice **devp)
258{
259 struct driver *drv;
260 uint plat_size = 0;
261 int ret;
262
263 drv = lists_driver_lookup_name(info->name);
264 if (!drv)
265 return -ENOENT;
266 if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
267 return -EPERM;
268
269#if CONFIG_IS_ENABLED(OF_PLATDATA)
270 plat_size = info->plat_size;
271#endif
272 ret = device_bind_common(parent, drv, info->name, (void *)info->plat, 0,
273 ofnode_null(), plat_size, devp);
274 if (ret)
275 return ret;
276
277 return ret;
278}
279
280int device_reparent(struct udevice *dev, struct udevice *new_parent)
281{
282 struct udevice *pos, *n;
283
284 assert(dev);
285 assert(new_parent);
286
287 list_for_each_entry_safe(pos, n, &dev->parent->child_head,
288 sibling_node) {
289 if (pos->driver != dev->driver)
290 continue;
291
292 list_del(&dev->sibling_node);
293 list_add_tail(&dev->sibling_node, &new_parent->child_head);
294 dev->parent = new_parent;
295
296 break;
297 }
298
299 return 0;
300}
301
302static void *alloc_priv(int size, uint flags)
303{
304 void *priv;
305
306 if (flags & DM_FLAG_ALLOC_PRIV_DMA) {
307 size = ROUND(size, ARCH_DMA_MINALIGN);
308 priv = memalign(ARCH_DMA_MINALIGN, size);
309 if (priv) {
310 memset(priv, '\0', size);
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335#ifndef CONFIG_MICROBLAZE
336 flush_dcache_range((ulong)priv, (ulong)priv + size);
337#endif
338 }
339 } else {
340 priv = calloc(1, size);
341 }
342
343 return priv;
344}
345
346
347
348
349
350
351
352static int device_alloc_priv(struct udevice *dev)
353{
354 const struct driver *drv;
355 void *ptr;
356 int size;
357
358 drv = dev->driver;
359 assert(drv);
360
361
362 if (drv->priv_auto && !dev_get_priv(dev)) {
363 ptr = alloc_priv(drv->priv_auto, drv->flags);
364 if (!ptr)
365 return -ENOMEM;
366 dev_set_priv(dev, ptr);
367 }
368
369
370 size = dev->uclass->uc_drv->per_device_auto;
371 if (size && !dev_get_uclass_priv(dev)) {
372 ptr = alloc_priv(size, dev->uclass->uc_drv->flags);
373 if (!ptr)
374 return -ENOMEM;
375 dev_set_uclass_priv(dev, ptr);
376 }
377
378
379 if (dev->parent) {
380 size = dev->parent->driver->per_child_auto;
381 if (!size)
382 size = dev->parent->uclass->uc_drv->per_child_auto;
383 if (size && !dev_get_parent_priv(dev)) {
384 ptr = alloc_priv(size, drv->flags);
385 if (!ptr)
386 return -ENOMEM;
387 dev_set_parent_priv(dev, ptr);
388 }
389 }
390
391 return 0;
392}
393
394int device_of_to_plat(struct udevice *dev)
395{
396 const struct driver *drv;
397 int ret;
398
399 if (!dev)
400 return -EINVAL;
401
402 if (dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID)
403 return 0;
404
405
406
407
408
409 if (!CONFIG_IS_ENABLED(OF_PLATDATA_NO_BIND)) {
410
411 if (dev->parent) {
412 ret = device_of_to_plat(dev->parent);
413 if (ret)
414 goto fail;
415
416
417
418
419
420
421
422 if (dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID)
423 return 0;
424 }
425
426 ret = device_alloc_priv(dev);
427 if (ret)
428 goto fail;
429 }
430 drv = dev->driver;
431 assert(drv);
432
433 if (drv->of_to_plat &&
434 (CONFIG_IS_ENABLED(OF_PLATDATA) || dev_has_ofnode(dev))) {
435 ret = drv->of_to_plat(dev);
436 if (ret)
437 goto fail;
438 }
439
440 dev_or_flags(dev, DM_FLAG_PLATDATA_VALID);
441
442 return 0;
443fail:
444 device_free(dev);
445
446 return ret;
447}
448
449
450
451
452
453
454
455
456
457
458
459static int device_get_dma_constraints(struct udevice *dev)
460{
461 struct udevice *parent = dev->parent;
462 phys_addr_t cpu = 0;
463 dma_addr_t bus = 0;
464 u64 size = 0;
465 int ret;
466
467 if (!CONFIG_IS_ENABLED(DM_DMA) || !parent || !dev_has_ofnode(parent))
468 return 0;
469
470
471
472
473
474 ret = dev_get_dma_range(parent, &cpu, &bus, &size);
475
476 if (ret && ret != -ENOENT) {
477 dm_warn("%s: failed to get DMA range, %d\n", dev->name, ret);
478 return ret;
479 }
480
481 dev_set_dma_offset(dev, cpu - bus);
482
483 return 0;
484}
485
486int device_probe(struct udevice *dev)
487{
488 const struct driver *drv;
489 int ret;
490
491 if (!dev)
492 return -EINVAL;
493
494 if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
495 return 0;
496
497 ret = device_notify(dev, EVT_DM_PRE_PROBE);
498 if (ret)
499 return ret;
500
501 drv = dev->driver;
502 assert(drv);
503
504 ret = device_of_to_plat(dev);
505 if (ret)
506 goto fail;
507
508
509 if (dev->parent) {
510 ret = device_probe(dev->parent);
511 if (ret)
512 goto fail;
513
514
515
516
517
518
519
520 if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
521 return 0;
522 }
523
524 dev_or_flags(dev, DM_FLAG_ACTIVATED);
525
526 if (CONFIG_IS_ENABLED(POWER_DOMAIN) && dev->parent &&
527 (device_get_uclass_id(dev) != UCLASS_POWER_DOMAIN) &&
528 !(drv->flags & DM_FLAG_DEFAULT_PD_CTRL_OFF)) {
529 ret = dev_power_domain_on(dev);
530 if (ret)
531 goto fail;
532 }
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549 if (dev->parent && device_get_uclass_id(dev) != UCLASS_PINCTRL) {
550 ret = pinctrl_select_state(dev, "default");
551 if (ret && ret != -ENOSYS)
552 log_debug("Device '%s' failed to configure default pinctrl: %d (%s)\n",
553 dev->name, ret, errno_str(ret));
554 }
555
556 if (CONFIG_IS_ENABLED(IOMMU) && dev->parent &&
557 (device_get_uclass_id(dev) != UCLASS_IOMMU)) {
558 ret = dev_iommu_enable(dev);
559 if (ret)
560 goto fail;
561 }
562
563 ret = device_get_dma_constraints(dev);
564 if (ret)
565 goto fail;
566
567 ret = uclass_pre_probe_device(dev);
568 if (ret)
569 goto fail;
570
571 if (dev->parent && dev->parent->driver->child_pre_probe) {
572 ret = dev->parent->driver->child_pre_probe(dev);
573 if (ret)
574 goto fail;
575 }
576
577
578 if (dev_has_ofnode(dev)) {
579
580
581
582
583 ret = clk_set_defaults(dev, CLK_DEFAULTS_PRE);
584 if (ret)
585 goto fail;
586 }
587
588 if (drv->probe) {
589 ret = drv->probe(dev);
590 if (ret)
591 goto fail;
592 }
593
594 ret = uclass_post_probe_device(dev);
595 if (ret)
596 goto fail_uclass;
597
598 if (dev->parent && device_get_uclass_id(dev) == UCLASS_PINCTRL) {
599 ret = pinctrl_select_state(dev, "default");
600 if (ret && ret != -ENOSYS)
601 log_debug("Device '%s' failed to configure default pinctrl: %d (%s)\n",
602 dev->name, ret, errno_str(ret));
603 }
604
605 ret = device_notify(dev, EVT_DM_POST_PROBE);
606 if (ret)
607 return ret;
608
609 return 0;
610fail_uclass:
611 if (device_remove(dev, DM_REMOVE_NORMAL)) {
612 dm_warn("%s: Device '%s' failed to remove on error path\n",
613 __func__, dev->name);
614 }
615fail:
616 dev_bic_flags(dev, DM_FLAG_ACTIVATED);
617
618 device_free(dev);
619
620 return ret;
621}
622
623void *dev_get_plat(const struct udevice *dev)
624{
625 if (!dev) {
626 dm_warn("%s: null device\n", __func__);
627 return NULL;
628 }
629
630 return dm_priv_to_rw(dev->plat_);
631}
632
633void *dev_get_parent_plat(const struct udevice *dev)
634{
635 if (!dev) {
636 dm_warn("%s: null device\n", __func__);
637 return NULL;
638 }
639
640 return dm_priv_to_rw(dev->parent_plat_);
641}
642
643void *dev_get_uclass_plat(const struct udevice *dev)
644{
645 if (!dev) {
646 dm_warn("%s: null device\n", __func__);
647 return NULL;
648 }
649
650 return dm_priv_to_rw(dev->uclass_plat_);
651}
652
653void *dev_get_priv(const struct udevice *dev)
654{
655 if (!dev) {
656 dm_warn("%s: null device\n", __func__);
657 return NULL;
658 }
659
660 return dm_priv_to_rw(dev->priv_);
661}
662
663void *dev_get_uclass_priv(const struct udevice *dev)
664{
665 if (!dev) {
666 dm_warn("%s: null device\n", __func__);
667 return NULL;
668 }
669
670 return dm_priv_to_rw(dev->uclass_priv_);
671}
672
673void *dev_get_parent_priv(const struct udevice *dev)
674{
675 if (!dev) {
676 dm_warn("%s: null device\n", __func__);
677 return NULL;
678 }
679
680 return dm_priv_to_rw(dev->parent_priv_);
681}
682
683static int device_get_device_tail(struct udevice *dev, int ret,
684 struct udevice **devp)
685{
686 if (ret)
687 return ret;
688
689 ret = device_probe(dev);
690 if (ret)
691 return ret;
692
693 *devp = dev;
694
695 return 0;
696}
697
698#if CONFIG_IS_ENABLED(OF_REAL)
699
700
701
702
703
704
705
706
707
708static int device_find_by_ofnode(ofnode node, struct udevice **devp)
709{
710 struct uclass *uc;
711 struct udevice *dev;
712 int ret;
713
714 list_for_each_entry(uc, gd->uclass_root, sibling_node) {
715 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node,
716 &dev);
717 if (!ret || dev) {
718 *devp = dev;
719 return 0;
720 }
721 }
722
723 return -ENODEV;
724}
725#endif
726
727int device_get_child(const struct udevice *parent, int index,
728 struct udevice **devp)
729{
730 struct udevice *dev;
731
732 list_for_each_entry(dev, &parent->child_head, sibling_node) {
733 if (!index--)
734 return device_get_device_tail(dev, 0, devp);
735 }
736
737 return -ENODEV;
738}
739
740int device_get_child_count(const struct udevice *parent)
741{
742 struct udevice *dev;
743 int count = 0;
744
745 list_for_each_entry(dev, &parent->child_head, sibling_node)
746 count++;
747
748 return count;
749}
750
751int device_get_decendent_count(const struct udevice *parent)
752{
753 const struct udevice *dev;
754 int count = 1;
755
756 list_for_each_entry(dev, &parent->child_head, sibling_node)
757 count += device_get_decendent_count(dev);
758
759 return count;
760}
761
762int device_find_child_by_seq(const struct udevice *parent, int seq,
763 struct udevice **devp)
764{
765 struct udevice *dev;
766
767 *devp = NULL;
768
769 list_for_each_entry(dev, &parent->child_head, sibling_node) {
770 if (dev->seq_ == seq) {
771 *devp = dev;
772 return 0;
773 }
774 }
775
776 return -ENODEV;
777}
778
779int device_get_child_by_seq(const struct udevice *parent, int seq,
780 struct udevice **devp)
781{
782 struct udevice *dev;
783 int ret;
784
785 *devp = NULL;
786 ret = device_find_child_by_seq(parent, seq, &dev);
787
788 return device_get_device_tail(dev, ret, devp);
789}
790
791int device_find_child_by_of_offset(const struct udevice *parent, int of_offset,
792 struct udevice **devp)
793{
794 struct udevice *dev;
795
796 *devp = NULL;
797
798 list_for_each_entry(dev, &parent->child_head, sibling_node) {
799 if (dev_of_offset(dev) == of_offset) {
800 *devp = dev;
801 return 0;
802 }
803 }
804
805 return -ENODEV;
806}
807
808int device_get_child_by_of_offset(const struct udevice *parent, int node,
809 struct udevice **devp)
810{
811 struct udevice *dev;
812 int ret;
813
814 *devp = NULL;
815 ret = device_find_child_by_of_offset(parent, node, &dev);
816 return device_get_device_tail(dev, ret, devp);
817}
818
819static struct udevice *_device_find_global_by_ofnode(struct udevice *parent,
820 ofnode ofnode)
821{
822 struct udevice *dev, *found;
823
824 if (ofnode_equal(dev_ofnode(parent), ofnode))
825 return parent;
826
827 list_for_each_entry(dev, &parent->child_head, sibling_node) {
828 found = _device_find_global_by_ofnode(dev, ofnode);
829 if (found)
830 return found;
831 }
832
833 return NULL;
834}
835
836int device_find_global_by_ofnode(ofnode ofnode, struct udevice **devp)
837{
838 *devp = _device_find_global_by_ofnode(gd->dm_root, ofnode);
839
840 return *devp ? 0 : -ENOENT;
841}
842
843int device_get_global_by_ofnode(ofnode ofnode, struct udevice **devp)
844{
845 struct udevice *dev;
846
847 dev = _device_find_global_by_ofnode(gd->dm_root, ofnode);
848 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
849}
850
851#if CONFIG_IS_ENABLED(OF_PLATDATA)
852int device_get_by_ofplat_idx(uint idx, struct udevice **devp)
853{
854 struct udevice *dev;
855
856 if (CONFIG_IS_ENABLED(OF_PLATDATA_INST)) {
857 struct udevice *base = ll_entry_start(struct udevice, udevice);
858
859 dev = base + idx;
860 } else {
861 struct driver_rt *drt = gd_dm_driver_rt() + idx;
862
863 dev = drt->dev;
864 }
865 *devp = NULL;
866
867 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
868}
869#endif
870
871int device_find_first_child(const struct udevice *parent, struct udevice **devp)
872{
873 if (list_empty(&parent->child_head)) {
874 *devp = NULL;
875 } else {
876 *devp = list_first_entry(&parent->child_head, struct udevice,
877 sibling_node);
878 }
879
880 return 0;
881}
882
883int device_find_next_child(struct udevice **devp)
884{
885 struct udevice *dev = *devp;
886 struct udevice *parent = dev->parent;
887
888 if (list_is_last(&dev->sibling_node, &parent->child_head)) {
889 *devp = NULL;
890 } else {
891 *devp = list_entry(dev->sibling_node.next, struct udevice,
892 sibling_node);
893 }
894
895 return 0;
896}
897
898int device_find_first_inactive_child(const struct udevice *parent,
899 enum uclass_id uclass_id,
900 struct udevice **devp)
901{
902 struct udevice *dev;
903
904 *devp = NULL;
905 list_for_each_entry(dev, &parent->child_head, sibling_node) {
906 if (!device_active(dev) &&
907 device_get_uclass_id(dev) == uclass_id) {
908 *devp = dev;
909 return 0;
910 }
911 }
912
913 return -ENODEV;
914}
915
916int device_find_first_child_by_uclass(const struct udevice *parent,
917 enum uclass_id uclass_id,
918 struct udevice **devp)
919{
920 struct udevice *dev;
921
922 *devp = NULL;
923 list_for_each_entry(dev, &parent->child_head, sibling_node) {
924 if (device_get_uclass_id(dev) == uclass_id) {
925 *devp = dev;
926 return 0;
927 }
928 }
929
930 return -ENODEV;
931}
932
933int device_find_child_by_namelen(const struct udevice *parent, const char *name,
934 int len, struct udevice **devp)
935{
936 struct udevice *dev;
937
938 *devp = NULL;
939
940 list_for_each_entry(dev, &parent->child_head, sibling_node) {
941 if (!strncmp(dev->name, name, len) &&
942 strlen(dev->name) == len) {
943 *devp = dev;
944 return 0;
945 }
946 }
947
948 return -ENODEV;
949}
950
951int device_find_child_by_name(const struct udevice *parent, const char *name,
952 struct udevice **devp)
953{
954 return device_find_child_by_namelen(parent, name, strlen(name), devp);
955}
956
957int device_first_child_err(struct udevice *parent, struct udevice **devp)
958{
959 struct udevice *dev;
960
961 device_find_first_child(parent, &dev);
962 if (!dev)
963 return -ENODEV;
964
965 return device_get_device_tail(dev, 0, devp);
966}
967
968int device_next_child_err(struct udevice **devp)
969{
970 struct udevice *dev = *devp;
971
972 device_find_next_child(&dev);
973 if (!dev)
974 return -ENODEV;
975
976 return device_get_device_tail(dev, 0, devp);
977}
978
979int device_first_child_ofdata_err(struct udevice *parent, struct udevice **devp)
980{
981 struct udevice *dev;
982 int ret;
983
984 device_find_first_child(parent, &dev);
985 if (!dev)
986 return -ENODEV;
987
988 ret = device_of_to_plat(dev);
989 if (ret)
990 return ret;
991
992 *devp = dev;
993
994 return 0;
995}
996
997int device_next_child_ofdata_err(struct udevice **devp)
998{
999 struct udevice *dev = *devp;
1000 int ret;
1001
1002 device_find_next_child(&dev);
1003 if (!dev)
1004 return -ENODEV;
1005
1006 ret = device_of_to_plat(dev);
1007 if (ret)
1008 return ret;
1009
1010 *devp = dev;
1011
1012 return 0;
1013}
1014
1015struct udevice *dev_get_parent(const struct udevice *child)
1016{
1017 return child->parent;
1018}
1019
1020ulong dev_get_driver_data(const struct udevice *dev)
1021{
1022 return dev->driver_data;
1023}
1024
1025const void *dev_get_driver_ops(const struct udevice *dev)
1026{
1027 if (!dev || !dev->driver->ops)
1028 return NULL;
1029
1030 return dev->driver->ops;
1031}
1032
1033enum uclass_id device_get_uclass_id(const struct udevice *dev)
1034{
1035 return dev->uclass->uc_drv->id;
1036}
1037
1038const char *dev_get_uclass_name(const struct udevice *dev)
1039{
1040 if (!dev)
1041 return NULL;
1042
1043 return dev->uclass->uc_drv->name;
1044}
1045
1046bool device_has_children(const struct udevice *dev)
1047{
1048 return !list_empty(&dev->child_head);
1049}
1050
1051bool device_has_active_children(const struct udevice *dev)
1052{
1053 struct udevice *child;
1054
1055 for (device_find_first_child(dev, &child);
1056 child;
1057 device_find_next_child(&child)) {
1058 if (device_active(child))
1059 return true;
1060 }
1061
1062 return false;
1063}
1064
1065bool device_is_last_sibling(const struct udevice *dev)
1066{
1067 struct udevice *parent = dev->parent;
1068
1069 if (!parent)
1070 return false;
1071 return list_is_last(&dev->sibling_node, &parent->child_head);
1072}
1073
1074void device_set_name_alloced(struct udevice *dev)
1075{
1076 dev_or_flags(dev, DM_FLAG_NAME_ALLOCED);
1077}
1078
1079int device_set_name(struct udevice *dev, const char *name)
1080{
1081 name = strdup(name);
1082 if (!name)
1083 return -ENOMEM;
1084 dev->name = name;
1085 device_set_name_alloced(dev);
1086
1087 return 0;
1088}
1089
1090void dev_set_priv(struct udevice *dev, void *priv)
1091{
1092 dev->priv_ = priv;
1093}
1094
1095void dev_set_parent_priv(struct udevice *dev, void *parent_priv)
1096{
1097 dev->parent_priv_ = parent_priv;
1098}
1099
1100void dev_set_uclass_priv(struct udevice *dev, void *uclass_priv)
1101{
1102 dev->uclass_priv_ = uclass_priv;
1103}
1104
1105void dev_set_plat(struct udevice *dev, void *plat)
1106{
1107 dev->plat_ = plat;
1108}
1109
1110void dev_set_parent_plat(struct udevice *dev, void *parent_plat)
1111{
1112 dev->parent_plat_ = parent_plat;
1113}
1114
1115void dev_set_uclass_plat(struct udevice *dev, void *uclass_plat)
1116{
1117 dev->uclass_plat_ = uclass_plat;
1118}
1119
1120#if CONFIG_IS_ENABLED(OF_REAL)
1121bool device_is_compatible(const struct udevice *dev, const char *compat)
1122{
1123 return ofnode_device_is_compatible(dev_ofnode(dev), compat);
1124}
1125
1126bool of_machine_is_compatible(const char *compat)
1127{
1128 const void *fdt = gd->fdt_blob;
1129
1130 return !fdt_node_check_compatible(fdt, 0, compat);
1131}
1132
1133int dev_disable_by_path(const char *path)
1134{
1135 struct uclass *uc;
1136 ofnode node = ofnode_path(path);
1137 struct udevice *dev;
1138 int ret = 1;
1139
1140 if (!of_live_active())
1141 return -ENOSYS;
1142
1143 list_for_each_entry(uc, gd->uclass_root, sibling_node) {
1144 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node, &dev);
1145 if (!ret)
1146 break;
1147 }
1148
1149 if (ret)
1150 return ret;
1151
1152 ret = device_remove(dev, DM_REMOVE_NORMAL);
1153 if (ret)
1154 return ret;
1155
1156 ret = device_unbind(dev);
1157 if (ret)
1158 return ret;
1159
1160 return ofnode_set_enabled(node, false);
1161}
1162
1163int dev_enable_by_path(const char *path)
1164{
1165 ofnode node = ofnode_path(path);
1166 ofnode pnode = ofnode_get_parent(node);
1167 struct udevice *parent;
1168 int ret = 1;
1169
1170 if (!of_live_active())
1171 return -ENOSYS;
1172
1173 ret = device_find_by_ofnode(pnode, &parent);
1174 if (ret)
1175 return ret;
1176
1177 ret = ofnode_set_enabled(node, true);
1178 if (ret)
1179 return ret;
1180
1181 return lists_bind_fdt(parent, node, NULL, NULL, false);
1182}
1183#endif
1184
1185#if CONFIG_IS_ENABLED(OF_PLATDATA_RT)
1186static struct udevice_rt *dev_get_rt(const struct udevice *dev)
1187{
1188 struct udevice *base = ll_entry_start(struct udevice, udevice);
1189 uint each_size = dm_udevice_size();
1190 int idx = ((void *)dev - (void *)base) / each_size;
1191
1192 struct udevice_rt *urt = gd_dm_udevice_rt() + idx;
1193
1194 return urt;
1195}
1196
1197u32 dev_get_flags(const struct udevice *dev)
1198{
1199 const struct udevice_rt *urt = dev_get_rt(dev);
1200
1201 return urt->flags_;
1202}
1203
1204void dev_or_flags(const struct udevice *dev, u32 or)
1205{
1206 struct udevice_rt *urt = dev_get_rt(dev);
1207
1208 urt->flags_ |= or;
1209}
1210
1211void dev_bic_flags(const struct udevice *dev, u32 bic)
1212{
1213 struct udevice_rt *urt = dev_get_rt(dev);
1214
1215 urt->flags_ &= ~bic;
1216}
1217#endif
1218