1 // SPDX-License-Identifier: GPL-2.0+
5 * Copyright (c) 2013 Google, Inc
8 * Pavel Herrmann <morpheus.ibis@gmail.com>
15 #include <asm/global_data.h>
19 #include <fdt_support.h>
21 #include <asm/cache.h>
22 #include <dm/device.h>
23 #include <dm/device-internal.h>
25 #include <dm/of_access.h>
26 #include <dm/pinctrl.h>
27 #include <dm/platdata.h>
29 #include <dm/uclass.h>
30 #include <dm/uclass-internal.h>
33 #include <linux/err.h>
34 #include <linux/list.h>
35 #include <power-domain.h>
37 DECLARE_GLOBAL_DATA_PTR;
39 static 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)
50 if (CONFIG_IS_ENABLED(OF_PLATDATA_NO_BIND))
58 ret = uclass_get(drv->id, &uc);
60 debug("Missing uclass for driver %s\n", drv->name);
64 dev = calloc(1, sizeof(struct udevice));
68 INIT_LIST_HEAD(&dev->sibling_node);
69 INIT_LIST_HEAD(&dev->child_head);
70 INIT_LIST_HEAD(&dev->uclass_node);
72 INIT_LIST_HEAD(&dev->devres_head);
74 dev_set_plat(dev, plat);
75 dev->driver_data = driver_data;
77 dev_set_ofnode(dev, node);
83 if (CONFIG_IS_ENABLED(DM_SEQ_ALIAS) &&
84 (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS)) {
86 * Some devices, such as a SPI bus, I2C bus and serial ports
87 * are numbered using aliases.
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_)) {
94 log_debug(" - seq=%d\n", dev->seq_);
99 if (auto_seq && !(uc->uc_drv->flags & DM_UC_FLAG_NO_AUTO_SEQ))
100 dev->seq_ = uclass_find_next_free_seq(uc);
102 /* Check if we need to allocate plat */
103 if (drv->plat_auto) {
107 * For of-platdata, we try use the existing data, but if
108 * plat_auto is larger, we must allocate a new space
110 if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
112 dev_or_flags(dev, DM_FLAG_OF_PLATDATA);
113 if (of_plat_size < drv->plat_auto)
117 dev_or_flags(dev, DM_FLAG_ALLOC_PDATA);
118 ptr = calloc(1, drv->plat_auto);
125 * For of-platdata, copy the old plat into the new
128 if (CONFIG_IS_ENABLED(OF_PLATDATA) && plat)
129 memcpy(ptr, plat, of_plat_size);
130 dev_set_plat(dev, ptr);
134 size = uc->uc_drv->per_device_plat_auto;
136 dev_or_flags(dev, DM_FLAG_ALLOC_UCLASS_PDATA);
137 ptr = calloc(1, size);
142 dev_set_uclass_plat(dev, ptr);
146 size = parent->driver->per_child_plat_auto;
148 size = parent->uclass->uc_drv->per_child_plat_auto;
150 dev_or_flags(dev, DM_FLAG_ALLOC_PARENT_PDATA);
151 ptr = calloc(1, size);
156 dev_set_parent_plat(dev, ptr);
158 /* put dev into parent's successor list */
159 list_add_tail(&dev->sibling_node, &parent->child_head);
162 ret = uclass_bind_device(dev);
164 goto fail_uclass_bind;
166 /* if we fail to bind we remove device from successors and free it */
168 ret = drv->bind(dev);
172 if (parent && parent->driver->child_post_bind) {
173 ret = parent->driver->child_post_bind(dev);
175 goto fail_child_post_bind;
177 if (uc->uc_drv->post_bind) {
178 ret = uc->uc_drv->post_bind(dev);
180 goto fail_uclass_post_bind;
184 pr_debug("Bound device %s to %s\n", dev->name, parent->name);
188 dev_or_flags(dev, DM_FLAG_BOUND);
192 fail_uclass_post_bind:
193 /* There is no child unbind() method, so no clean-up required */
194 fail_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",
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",
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);
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);
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);
232 devres_release_all(dev);
239 int 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)
244 return device_bind_common(parent, drv, name, NULL, driver_data, node,
248 int device_bind(struct udevice *parent, const struct driver *drv,
249 const char *name, void *plat, ofnode node,
250 struct udevice **devp)
252 return device_bind_common(parent, drv, name, plat, 0, node, 0,
256 int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
257 const struct driver_info *info, struct udevice **devp)
263 drv = lists_driver_lookup_name(info->name);
266 if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
269 #if CONFIG_IS_ENABLED(OF_PLATDATA)
270 plat_size = info->plat_size;
272 ret = device_bind_common(parent, drv, info->name, (void *)info->plat, 0,
273 ofnode_null(), plat_size, devp);
280 int device_reparent(struct udevice *dev, struct udevice *new_parent)
282 struct udevice *pos, *n;
287 list_for_each_entry_safe(pos, n, &dev->parent->child_head,
289 if (pos->driver != dev->driver)
292 list_del(&dev->sibling_node);
293 list_add_tail(&dev->sibling_node, &new_parent->child_head);
294 dev->parent = new_parent;
302 static void *alloc_priv(int size, uint flags)
306 if (flags & DM_FLAG_ALLOC_PRIV_DMA) {
307 size = ROUND(size, ARCH_DMA_MINALIGN);
308 priv = memalign(ARCH_DMA_MINALIGN, size);
310 memset(priv, '\0', size);
313 * Ensure that the zero bytes are flushed to memory.
314 * This prevents problems if the driver uses this as
315 * both an input and an output buffer:
317 * 1. Zeroes written to buffer (here) and sit in the
319 * 2. Driver issues a read command to DMA
320 * 3. CPU runs out of cache space and evicts some cache
321 * data in the buffer, writing zeroes to RAM from
324 * 5. Buffer now has some DMA data and some zeroes
325 * 6. Data being read is now incorrect
327 * To prevent this, ensure that the cache is clean
328 * within this range at the start. The driver can then
329 * use normal flush-after-write, invalidate-before-read
332 * TODO(sjg@chromium.org): Drop this microblaze
335 #ifndef CONFIG_MICROBLAZE
336 flush_dcache_range((ulong)priv, (ulong)priv + size);
340 priv = calloc(1, size);
347 * device_alloc_priv() - Allocate priv/plat data required by the device
349 * @dev: Device to process
350 * Return: 0 if OK, -ENOMEM if out of memory
352 static int device_alloc_priv(struct udevice *dev)
354 const struct driver *drv;
361 /* Allocate private data if requested and not reentered */
362 if (drv->priv_auto && !dev_get_priv(dev)) {
363 ptr = alloc_priv(drv->priv_auto, drv->flags);
366 dev_set_priv(dev, ptr);
369 /* Allocate private data if requested and not reentered */
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);
375 dev_set_uclass_priv(dev, ptr);
378 /* Allocate parent data for this child */
380 size = dev->parent->driver->per_child_auto;
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);
387 dev_set_parent_priv(dev, ptr);
394 int device_of_to_plat(struct udevice *dev)
396 const struct driver *drv;
402 if (dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID)
406 * This is not needed if binding is disabled, since data is allocated
409 if (!CONFIG_IS_ENABLED(OF_PLATDATA_NO_BIND)) {
410 /* Ensure all parents have ofdata */
412 ret = device_of_to_plat(dev->parent);
417 * The device might have already been probed during
418 * the call to device_probe() on its parent device
419 * (e.g. PCI bridge devices). Test the flags again
420 * so that we don't mess up the device.
422 if (dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID)
426 ret = device_alloc_priv(dev);
433 if (drv->of_to_plat &&
434 (CONFIG_IS_ENABLED(OF_PLATDATA) || dev_has_ofnode(dev))) {
435 ret = drv->of_to_plat(dev);
440 dev_or_flags(dev, DM_FLAG_PLATDATA_VALID);
450 * device_get_dma_constraints() - Populate device's DMA constraints
452 * Gets a device's DMA constraints from firmware. This information is later
453 * used by drivers to translate physcal addresses to the device's bus address
454 * space. For now only device-tree is supported.
456 * @dev: Pointer to target device
457 * Return: 0 if OK or if no DMA constraints were found, error otherwise
459 static int device_get_dma_constraints(struct udevice *dev)
461 struct udevice *parent = dev->parent;
467 if (!CONFIG_IS_ENABLED(DM_DMA) || !parent || !dev_has_ofnode(parent))
471 * We start parsing for dma-ranges from the device's bus node. This is
472 * specially important on nested buses.
474 ret = dev_get_dma_range(parent, &cpu, &bus, &size);
475 /* Don't return an error if no 'dma-ranges' were found */
476 if (ret && ret != -ENOENT) {
477 dm_warn("%s: failed to get DMA range, %d\n", dev->name, ret);
481 dev_set_dma_offset(dev, cpu - bus);
486 int device_probe(struct udevice *dev)
488 const struct driver *drv;
494 if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
497 ret = device_notify(dev, EVT_DM_PRE_PROBE);
504 ret = device_of_to_plat(dev);
508 /* Ensure all parents are probed */
510 ret = device_probe(dev->parent);
515 * The device might have already been probed during
516 * the call to device_probe() on its parent device
517 * (e.g. PCI bridge devices). Test the flags again
518 * so that we don't mess up the device.
520 if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
524 dev_or_flags(dev, DM_FLAG_ACTIVATED);
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);
535 * Process pinctrl for everything except the root device, and
536 * continue regardless of the result of pinctrl. Don't process pinctrl
537 * settings for pinctrl devices since the device may not yet be
540 * This call can produce some non-intuitive results. For example, on an
541 * x86 device where dev is the main PCI bus, the pinctrl device may be
542 * child or grandchild of that bus, meaning that the child will be
543 * probed here. If the child happens to be the P2SB and the pinctrl
544 * device is a child of that, then both the pinctrl and P2SB will be
545 * probed by this call. This works because the DM_FLAG_ACTIVATED flag
546 * is set just above. However, the PCI bus' probe() method and
547 * associated uclass methods have not yet been called.
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));
556 if (CONFIG_IS_ENABLED(IOMMU) && dev->parent &&
557 (device_get_uclass_id(dev) != UCLASS_IOMMU)) {
558 ret = dev_iommu_enable(dev);
563 ret = device_get_dma_constraints(dev);
567 ret = uclass_pre_probe_device(dev);
571 if (dev->parent && dev->parent->driver->child_pre_probe) {
572 ret = dev->parent->driver->child_pre_probe(dev);
577 /* Only handle devices that have a valid ofnode */
578 if (dev_has_ofnode(dev)) {
580 * Process 'assigned-{clocks/clock-parents/clock-rates}'
583 ret = clk_set_defaults(dev, CLK_DEFAULTS_PRE);
589 ret = drv->probe(dev);
594 ret = uclass_post_probe_device(dev);
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));
605 ret = device_notify(dev, EVT_DM_POST_PROBE);
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);
616 dev_bic_flags(dev, DM_FLAG_ACTIVATED);
623 void *dev_get_plat(const struct udevice *dev)
626 dm_warn("%s: null device\n", __func__);
630 return dm_priv_to_rw(dev->plat_);
633 void *dev_get_parent_plat(const struct udevice *dev)
636 dm_warn("%s: null device\n", __func__);
640 return dm_priv_to_rw(dev->parent_plat_);
643 void *dev_get_uclass_plat(const struct udevice *dev)
646 dm_warn("%s: null device\n", __func__);
650 return dm_priv_to_rw(dev->uclass_plat_);
653 void *dev_get_priv(const struct udevice *dev)
656 dm_warn("%s: null device\n", __func__);
660 return dm_priv_to_rw(dev->priv_);
663 void *dev_get_uclass_priv(const struct udevice *dev)
666 dm_warn("%s: null device\n", __func__);
670 return dm_priv_to_rw(dev->uclass_priv_);
673 void *dev_get_parent_priv(const struct udevice *dev)
676 dm_warn("%s: null device\n", __func__);
680 return dm_priv_to_rw(dev->parent_priv_);
683 static int device_get_device_tail(struct udevice *dev, int ret,
684 struct udevice **devp)
689 ret = device_probe(dev);
698 #if CONFIG_IS_ENABLED(OF_REAL)
700 * device_find_by_ofnode() - Return device associated with given ofnode
702 * The returned device is *not* activated.
704 * @node: The ofnode for which a associated device should be looked up
705 * @devp: Pointer to structure to hold the found device
706 * Return: 0 if OK, -ve on error
708 static int device_find_by_ofnode(ofnode node, struct udevice **devp)
714 list_for_each_entry(uc, gd->uclass_root, sibling_node) {
715 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node,
727 int device_get_child(const struct udevice *parent, int index,
728 struct udevice **devp)
732 list_for_each_entry(dev, &parent->child_head, sibling_node) {
734 return device_get_device_tail(dev, 0, devp);
740 int device_get_child_count(const struct udevice *parent)
745 list_for_each_entry(dev, &parent->child_head, sibling_node)
751 int device_get_decendent_count(const struct udevice *parent)
753 const struct udevice *dev;
756 list_for_each_entry(dev, &parent->child_head, sibling_node)
757 count += device_get_decendent_count(dev);
762 int device_find_child_by_seq(const struct udevice *parent, int seq,
763 struct udevice **devp)
769 list_for_each_entry(dev, &parent->child_head, sibling_node) {
770 if (dev->seq_ == seq) {
779 int device_get_child_by_seq(const struct udevice *parent, int seq,
780 struct udevice **devp)
786 ret = device_find_child_by_seq(parent, seq, &dev);
788 return device_get_device_tail(dev, ret, devp);
791 int device_find_child_by_of_offset(const struct udevice *parent, int of_offset,
792 struct udevice **devp)
798 list_for_each_entry(dev, &parent->child_head, sibling_node) {
799 if (dev_of_offset(dev) == of_offset) {
808 int device_get_child_by_of_offset(const struct udevice *parent, int node,
809 struct udevice **devp)
815 ret = device_find_child_by_of_offset(parent, node, &dev);
816 return device_get_device_tail(dev, ret, devp);
819 static struct udevice *_device_find_global_by_ofnode(struct udevice *parent,
822 struct udevice *dev, *found;
824 if (ofnode_equal(dev_ofnode(parent), ofnode))
827 list_for_each_entry(dev, &parent->child_head, sibling_node) {
828 found = _device_find_global_by_ofnode(dev, ofnode);
836 int device_find_global_by_ofnode(ofnode ofnode, struct udevice **devp)
838 *devp = _device_find_global_by_ofnode(gd->dm_root, ofnode);
840 return *devp ? 0 : -ENOENT;
843 int device_get_global_by_ofnode(ofnode ofnode, struct udevice **devp)
847 dev = _device_find_global_by_ofnode(gd->dm_root, ofnode);
848 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
851 #if CONFIG_IS_ENABLED(OF_PLATDATA)
852 int device_get_by_ofplat_idx(uint idx, struct udevice **devp)
856 if (CONFIG_IS_ENABLED(OF_PLATDATA_INST)) {
857 struct udevice *base = ll_entry_start(struct udevice, udevice);
861 struct driver_rt *drt = gd_dm_driver_rt() + idx;
867 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
871 int device_find_first_child(const struct udevice *parent, struct udevice **devp)
873 if (list_empty(&parent->child_head)) {
876 *devp = list_first_entry(&parent->child_head, struct udevice,
883 int device_find_next_child(struct udevice **devp)
885 struct udevice *dev = *devp;
886 struct udevice *parent = dev->parent;
888 if (list_is_last(&dev->sibling_node, &parent->child_head)) {
891 *devp = list_entry(dev->sibling_node.next, struct udevice,
898 int device_find_first_inactive_child(const struct udevice *parent,
899 enum uclass_id uclass_id,
900 struct udevice **devp)
905 list_for_each_entry(dev, &parent->child_head, sibling_node) {
906 if (!device_active(dev) &&
907 device_get_uclass_id(dev) == uclass_id) {
916 int device_find_first_child_by_uclass(const struct udevice *parent,
917 enum uclass_id uclass_id,
918 struct udevice **devp)
923 list_for_each_entry(dev, &parent->child_head, sibling_node) {
924 if (device_get_uclass_id(dev) == uclass_id) {
933 int device_find_child_by_namelen(const struct udevice *parent, const char *name,
934 int len, struct udevice **devp)
940 list_for_each_entry(dev, &parent->child_head, sibling_node) {
941 if (!strncmp(dev->name, name, len) &&
942 strlen(dev->name) == len) {
951 int device_find_child_by_name(const struct udevice *parent, const char *name,
952 struct udevice **devp)
954 return device_find_child_by_namelen(parent, name, strlen(name), devp);
957 int device_first_child_err(struct udevice *parent, struct udevice **devp)
961 device_find_first_child(parent, &dev);
965 return device_get_device_tail(dev, 0, devp);
968 int device_next_child_err(struct udevice **devp)
970 struct udevice *dev = *devp;
972 device_find_next_child(&dev);
976 return device_get_device_tail(dev, 0, devp);
979 int device_first_child_ofdata_err(struct udevice *parent, struct udevice **devp)
984 device_find_first_child(parent, &dev);
988 ret = device_of_to_plat(dev);
997 int device_next_child_ofdata_err(struct udevice **devp)
999 struct udevice *dev = *devp;
1002 device_find_next_child(&dev);
1006 ret = device_of_to_plat(dev);
1015 struct udevice *dev_get_parent(const struct udevice *child)
1017 return child->parent;
1020 ulong dev_get_driver_data(const struct udevice *dev)
1022 return dev->driver_data;
1025 const void *dev_get_driver_ops(const struct udevice *dev)
1027 if (!dev || !dev->driver->ops)
1030 return dev->driver->ops;
1033 enum uclass_id device_get_uclass_id(const struct udevice *dev)
1035 return dev->uclass->uc_drv->id;
1038 const char *dev_get_uclass_name(const struct udevice *dev)
1043 return dev->uclass->uc_drv->name;
1046 bool device_has_children(const struct udevice *dev)
1048 return !list_empty(&dev->child_head);
1051 bool device_has_active_children(const struct udevice *dev)
1053 struct udevice *child;
1055 for (device_find_first_child(dev, &child);
1057 device_find_next_child(&child)) {
1058 if (device_active(child))
1065 bool device_is_last_sibling(const struct udevice *dev)
1067 struct udevice *parent = dev->parent;
1071 return list_is_last(&dev->sibling_node, &parent->child_head);
1074 void device_set_name_alloced(struct udevice *dev)
1076 dev_or_flags(dev, DM_FLAG_NAME_ALLOCED);
1079 int device_set_name(struct udevice *dev, const char *name)
1081 name = strdup(name);
1085 device_set_name_alloced(dev);
1090 void dev_set_priv(struct udevice *dev, void *priv)
1095 void dev_set_parent_priv(struct udevice *dev, void *parent_priv)
1097 dev->parent_priv_ = parent_priv;
1100 void dev_set_uclass_priv(struct udevice *dev, void *uclass_priv)
1102 dev->uclass_priv_ = uclass_priv;
1105 void dev_set_plat(struct udevice *dev, void *plat)
1110 void dev_set_parent_plat(struct udevice *dev, void *parent_plat)
1112 dev->parent_plat_ = parent_plat;
1115 void dev_set_uclass_plat(struct udevice *dev, void *uclass_plat)
1117 dev->uclass_plat_ = uclass_plat;
1120 #if CONFIG_IS_ENABLED(OF_REAL)
1121 bool device_is_compatible(const struct udevice *dev, const char *compat)
1123 return ofnode_device_is_compatible(dev_ofnode(dev), compat);
1126 bool of_machine_is_compatible(const char *compat)
1128 const void *fdt = gd->fdt_blob;
1130 return !fdt_node_check_compatible(fdt, 0, compat);
1133 int dev_disable_by_path(const char *path)
1136 ofnode node = ofnode_path(path);
1137 struct udevice *dev;
1140 if (!of_live_active())
1143 list_for_each_entry(uc, gd->uclass_root, sibling_node) {
1144 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node, &dev);
1152 ret = device_remove(dev, DM_REMOVE_NORMAL);
1156 ret = device_unbind(dev);
1160 return ofnode_set_enabled(node, false);
1163 int dev_enable_by_path(const char *path)
1165 ofnode node = ofnode_path(path);
1166 ofnode pnode = ofnode_get_parent(node);
1167 struct udevice *parent;
1170 if (!of_live_active())
1173 ret = device_find_by_ofnode(pnode, &parent);
1177 ret = ofnode_set_enabled(node, true);
1181 return lists_bind_fdt(parent, node, NULL, NULL, false);
1185 #if CONFIG_IS_ENABLED(OF_PLATDATA_RT)
1186 static struct udevice_rt *dev_get_rt(const struct udevice *dev)
1188 struct udevice *base = ll_entry_start(struct udevice, udevice);
1189 int idx = dev - base;
1191 struct udevice_rt *urt = gd_dm_udevice_rt() + idx;
1196 u32 dev_get_flags(const struct udevice *dev)
1198 const struct udevice_rt *urt = dev_get_rt(dev);
1203 void dev_or_flags(const struct udevice *dev, u32 or)
1205 struct udevice_rt *urt = dev_get_rt(dev);
1210 void dev_bic_flags(const struct udevice *dev, u32 bic)
1212 struct udevice_rt *urt = dev_get_rt(dev);
1214 urt->flags_ &= ~bic;
1216 #endif /* OF_PLATDATA_RT */