2 * Copyright (c) 2013 Google, Inc
5 * Pavel Herrmann <morpheus.ibis@gmail.com>
7 * SPDX-License-Identifier: GPL-2.0+
15 #include <dm/device.h>
16 #include <dm/device-internal.h>
18 #include <dm/platdata.h>
20 #include <dm/uclass.h>
22 #include <linux/list.h>
24 DECLARE_GLOBAL_DATA_PTR;
27 fdt_addr_t translation_offset; /* optional translation offset */
30 static const struct driver_info root_info = {
31 .name = "root_driver",
34 struct udevice *dm_root(void)
37 dm_warn("Virtual root driver does not exist!\n");
44 void dm_fixup_for_gd_move(struct global_data *new_gd)
46 /* The sentinel node has moved, so update things that point to it */
48 new_gd->uclass_root.next->prev = &new_gd->uclass_root;
49 new_gd->uclass_root.prev->next = &new_gd->uclass_root;
53 fdt_addr_t dm_get_translation_offset(void)
55 struct udevice *root = dm_root();
56 struct root_priv *priv = dev_get_priv(root);
58 return priv->translation_offset;
61 void dm_set_translation_offset(fdt_addr_t offs)
63 struct udevice *root = dm_root();
64 struct root_priv *priv = dev_get_priv(root);
66 priv->translation_offset = offs;
69 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
70 void fix_drivers(void)
73 ll_entry_start(struct driver, driver);
74 const int n_ents = ll_entry_count(struct driver, driver);
77 for (entry = drv; entry != drv + n_ents; entry++) {
79 entry->of_match = (const struct udevice_id *)
80 ((u32)entry->of_match + gd->reloc_off);
82 entry->bind += gd->reloc_off;
84 entry->probe += gd->reloc_off;
86 entry->remove += gd->reloc_off;
88 entry->unbind += gd->reloc_off;
89 if (entry->ofdata_to_platdata)
90 entry->ofdata_to_platdata += gd->reloc_off;
91 if (entry->child_post_bind)
92 entry->child_post_bind += gd->reloc_off;
93 if (entry->child_pre_probe)
94 entry->child_pre_probe += gd->reloc_off;
95 if (entry->child_post_remove)
96 entry->child_post_remove += gd->reloc_off;
97 /* OPS are fixed in every uclass post_probe function */
99 entry->ops += gd->reloc_off;
103 void fix_uclass(void)
105 struct uclass_driver *uclass =
106 ll_entry_start(struct uclass_driver, uclass);
107 const int n_ents = ll_entry_count(struct uclass_driver, uclass);
108 struct uclass_driver *entry;
110 for (entry = uclass; entry != uclass + n_ents; entry++) {
111 if (entry->post_bind)
112 entry->post_bind += gd->reloc_off;
113 if (entry->pre_unbind)
114 entry->pre_unbind += gd->reloc_off;
115 if (entry->pre_probe)
116 entry->pre_probe += gd->reloc_off;
117 if (entry->post_probe)
118 entry->post_probe += gd->reloc_off;
119 if (entry->pre_remove)
120 entry->pre_remove += gd->reloc_off;
121 if (entry->child_post_bind)
122 entry->child_post_bind += gd->reloc_off;
123 if (entry->child_pre_probe)
124 entry->child_pre_probe += gd->reloc_off;
126 entry->init += gd->reloc_off;
128 entry->destroy += gd->reloc_off;
129 /* FIXME maybe also need to fix these ops */
131 entry->ops += gd->reloc_off;
135 void fix_devices(void)
137 struct driver_info *dev =
138 ll_entry_start(struct driver_info, driver_info);
139 const int n_ents = ll_entry_count(struct driver_info, driver_info);
140 struct driver_info *entry;
142 for (entry = dev; entry != dev + n_ents; entry++) {
144 entry->platdata += gd->reloc_off;
155 dm_warn("Virtual root driver already exists!\n");
158 INIT_LIST_HEAD(&DM_UCLASS_ROOT_NON_CONST);
160 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
166 ret = device_bind_by_name(NULL, false, &root_info, &DM_ROOT_NON_CONST);
169 #if CONFIG_IS_ENABLED(OF_CONTROL)
170 DM_ROOT_NON_CONST->of_offset = 0;
172 ret = device_probe(DM_ROOT_NON_CONST);
181 device_remove(dm_root(), DM_REMOVE_NORMAL);
182 device_unbind(dm_root());
187 #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
188 int dm_remove_devices_flags(uint flags)
190 device_remove(dm_root(), flags);
196 int dm_scan_platdata(bool pre_reloc_only)
200 ret = lists_bind_drivers(DM_ROOT_NON_CONST, pre_reloc_only);
201 if (ret == -ENOENT) {
202 dm_warn("Some drivers were not found\n");
209 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
211 * dm_scan_fdt_node() - Scan the device tree and bind drivers for a node
213 * This scans the subnodes of a device tree node and and creates a driver
216 * @parent: Parent device for the devices that will be created
217 * @blob: Pointer to device tree blob
218 * @offset: Offset of node to scan
219 * @pre_reloc_only: If true, bind only drivers with the DM_FLAG_PRE_RELOC
220 * flag. If false bind all drivers.
221 * @return 0 if OK, -ve on error
223 static int dm_scan_fdt_node(struct udevice *parent, const void *blob,
224 int offset, bool pre_reloc_only)
228 for (offset = fdt_first_subnode(blob, offset);
230 offset = fdt_next_subnode(blob, offset)) {
231 if (pre_reloc_only &&
232 !dm_fdt_pre_reloc(blob, offset))
234 if (!fdtdec_get_is_enabled(blob, offset)) {
235 dm_dbg(" - ignoring disabled device\n");
238 err = lists_bind_fdt(parent, blob, offset, NULL);
241 debug("%s: ret=%d\n", fdt_get_name(blob, offset, NULL),
247 dm_warn("Some drivers failed to bind\n");
252 int dm_scan_fdt_dev(struct udevice *dev)
254 if (dev_of_offset(dev) == -1)
257 return dm_scan_fdt_node(dev, gd->fdt_blob, dev_of_offset(dev),
258 gd->flags & GD_FLG_RELOC ? false : true);
261 int dm_scan_fdt(const void *blob, bool pre_reloc_only)
263 return dm_scan_fdt_node(gd->dm_root, blob, 0, pre_reloc_only);
267 __weak int dm_scan_other(bool pre_reloc_only)
272 int dm_init_and_scan(bool pre_reloc_only)
278 debug("dm_init() failed: %d\n", ret);
281 ret = dm_scan_platdata(pre_reloc_only);
283 debug("dm_scan_platdata() failed: %d\n", ret);
287 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
288 ret = dm_scan_fdt(gd->fdt_blob, pre_reloc_only);
290 debug("dm_scan_fdt() failed: %d\n", ret);
295 ret = dm_scan_other(pre_reloc_only);
302 /* This is the root driver - all drivers are children of this */
303 U_BOOT_DRIVER(root_driver) = {
304 .name = "root_driver",
306 .priv_auto_alloc_size = sizeof(struct root_priv),
309 /* This is the root uclass */
310 UCLASS_DRIVER(root) = {