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 <errno.h>
12 #include <fdtdec.h>
13 #include <malloc.h>
14 #include <linux/libfdt.h>
15 #include <dm/device.h>
16 #include <dm/device-internal.h>
17 #include <dm/lists.h>
18 #include <dm/of.h>
19 #include <dm/of_access.h>
20 #include <dm/platdata.h>
21 #include <dm/read.h>
22 #include <dm/root.h>
23 #include <dm/uclass.h>
24 #include <dm/util.h>
25 #include <linux/list.h>
26
27 DECLARE_GLOBAL_DATA_PTR;
28
29 struct root_priv {
30 fdt_addr_t translation_offset; /* optional translation offset */
31 };
32
33 static const struct driver_info root_info = {
34 .name = "root_driver",
35 };
36
dm_root(void)37 struct udevice *dm_root(void)
38 {
39 if (!gd->dm_root) {
40 dm_warn("Virtual root driver does not exist!\n");
41 return NULL;
42 }
43
44 return gd->dm_root;
45 }
46
dm_fixup_for_gd_move(struct global_data * new_gd)47 void dm_fixup_for_gd_move(struct global_data *new_gd)
48 {
49 /* The sentinel node has moved, so update things that point to it */
50 if (gd->dm_root) {
51 new_gd->uclass_root.next->prev = &new_gd->uclass_root;
52 new_gd->uclass_root.prev->next = &new_gd->uclass_root;
53 }
54 }
55
dm_get_translation_offset(void)56 fdt_addr_t dm_get_translation_offset(void)
57 {
58 struct udevice *root = dm_root();
59 struct root_priv *priv = dev_get_priv(root);
60
61 return priv->translation_offset;
62 }
63
dm_set_translation_offset(fdt_addr_t offs)64 void dm_set_translation_offset(fdt_addr_t offs)
65 {
66 struct udevice *root = dm_root();
67 struct root_priv *priv = dev_get_priv(root);
68
69 priv->translation_offset = offs;
70 }
71
72 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
fix_drivers(void)73 void fix_drivers(void)
74 {
75 struct driver *drv =
76 ll_entry_start(struct driver, driver);
77 const int n_ents = ll_entry_count(struct driver, driver);
78 struct driver *entry;
79
80 for (entry = drv; entry != drv + n_ents; entry++) {
81 if (entry->of_match)
82 entry->of_match = (const struct udevice_id *)
83 ((u32)entry->of_match + gd->reloc_off);
84 if (entry->bind)
85 entry->bind += gd->reloc_off;
86 if (entry->probe)
87 entry->probe += gd->reloc_off;
88 if (entry->remove)
89 entry->remove += gd->reloc_off;
90 if (entry->unbind)
91 entry->unbind += gd->reloc_off;
92 if (entry->ofdata_to_platdata)
93 entry->ofdata_to_platdata += gd->reloc_off;
94 if (entry->child_post_bind)
95 entry->child_post_bind += gd->reloc_off;
96 if (entry->child_pre_probe)
97 entry->child_pre_probe += gd->reloc_off;
98 if (entry->child_post_remove)
99 entry->child_post_remove += gd->reloc_off;
100 /* OPS are fixed in every uclass post_probe function */
101 if (entry->ops)
102 entry->ops += gd->reloc_off;
103 }
104 }
105
fix_uclass(void)106 void fix_uclass(void)
107 {
108 struct uclass_driver *uclass =
109 ll_entry_start(struct uclass_driver, uclass);
110 const int n_ents = ll_entry_count(struct uclass_driver, uclass);
111 struct uclass_driver *entry;
112
113 for (entry = uclass; entry != uclass + n_ents; entry++) {
114 if (entry->post_bind)
115 entry->post_bind += gd->reloc_off;
116 if (entry->pre_unbind)
117 entry->pre_unbind += gd->reloc_off;
118 if (entry->pre_probe)
119 entry->pre_probe += gd->reloc_off;
120 if (entry->post_probe)
121 entry->post_probe += gd->reloc_off;
122 if (entry->pre_remove)
123 entry->pre_remove += gd->reloc_off;
124 if (entry->child_post_bind)
125 entry->child_post_bind += gd->reloc_off;
126 if (entry->child_pre_probe)
127 entry->child_pre_probe += gd->reloc_off;
128 if (entry->init)
129 entry->init += gd->reloc_off;
130 if (entry->destroy)
131 entry->destroy += gd->reloc_off;
132 /* FIXME maybe also need to fix these ops */
133 if (entry->ops)
134 entry->ops += gd->reloc_off;
135 }
136 }
137
fix_devices(void)138 void fix_devices(void)
139 {
140 struct driver_info *dev =
141 ll_entry_start(struct driver_info, driver_info);
142 const int n_ents = ll_entry_count(struct driver_info, driver_info);
143 struct driver_info *entry;
144
145 for (entry = dev; entry != dev + n_ents; entry++) {
146 if (entry->platdata)
147 entry->platdata += gd->reloc_off;
148 }
149 }
150
151 #endif
152
dm_init(bool of_live)153 int dm_init(bool of_live)
154 {
155 int ret;
156
157 if (gd->dm_root) {
158 dm_warn("Virtual root driver already exists!\n");
159 return -EINVAL;
160 }
161 INIT_LIST_HEAD(&DM_UCLASS_ROOT_NON_CONST);
162
163 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
164 fix_drivers();
165 fix_uclass();
166 fix_devices();
167 #endif
168
169 ret = device_bind_by_name(NULL, false, &root_info, &DM_ROOT_NON_CONST);
170 if (ret)
171 return ret;
172 #if CONFIG_IS_ENABLED(OF_CONTROL)
173 # if CONFIG_IS_ENABLED(OF_LIVE)
174 if (of_live)
175 DM_ROOT_NON_CONST->node = np_to_ofnode(gd->of_root);
176 else
177 #endif
178 DM_ROOT_NON_CONST->node = offset_to_ofnode(0);
179 #endif
180 ret = device_probe(DM_ROOT_NON_CONST);
181 if (ret)
182 return ret;
183
184 return 0;
185 }
186
dm_uninit(void)187 int dm_uninit(void)
188 {
189 device_remove(dm_root(), DM_REMOVE_NORMAL);
190 device_unbind(dm_root());
191
192 return 0;
193 }
194
195 #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
dm_remove_devices_flags(uint flags)196 int dm_remove_devices_flags(uint flags)
197 {
198 device_remove(dm_root(), flags);
199
200 return 0;
201 }
202 #endif
203
dm_scan_platdata(bool pre_reloc_only)204 int dm_scan_platdata(bool pre_reloc_only)
205 {
206 int ret;
207
208 ret = lists_bind_drivers(DM_ROOT_NON_CONST, pre_reloc_only);
209 if (ret == -ENOENT) {
210 dm_warn("Some drivers were not found\n");
211 ret = 0;
212 }
213
214 return ret;
215 }
216
217 #if CONFIG_IS_ENABLED(OF_LIVE)
dm_scan_fdt_live(struct udevice * parent,const struct device_node * node_parent,bool pre_reloc_only)218 static int dm_scan_fdt_live(struct udevice *parent,
219 const struct device_node *node_parent,
220 bool pre_reloc_only)
221 {
222 struct device_node *np;
223 int ret = 0, err;
224
225 for (np = node_parent->child; np; np = np->sibling) {
226 if (pre_reloc_only &&
227 (!of_find_property(np, "u-boot,dm-pre-reloc", NULL) &&
228 !of_find_property(np, "u-boot,dm-spl", NULL)))
229 continue;
230 if (!of_device_is_available(np)) {
231 pr_debug(" - ignoring disabled device\n");
232 continue;
233 }
234 err = lists_bind_fdt(parent, np_to_ofnode(np), NULL);
235 if (err && !ret) {
236 ret = err;
237 debug("%s: ret=%d\n", np->name, ret);
238 }
239
240 /* There is no compatible in "/firmware", bind it by default. */
241 if (!pre_reloc_only && !strcmp(np->name, "firmware"))
242 ret = device_bind_driver_to_node(gd->dm_root,
243 "firmware", np->name, np_to_ofnode(np), NULL);
244 }
245
246 if (ret)
247 dm_warn("Some drivers failed to bind\n");
248
249 return ret;
250 }
251 #endif /* CONFIG_IS_ENABLED(OF_LIVE) */
252
253 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
254 /**
255 * dm_scan_fdt_node() - Scan the device tree and bind drivers for a node
256 *
257 * This scans the subnodes of a device tree node and and creates a driver
258 * for each one.
259 *
260 * @parent: Parent device for the devices that will be created
261 * @blob: Pointer to device tree blob
262 * @offset: Offset of node to scan
263 * @pre_reloc_only: If true, bind only drivers with the DM_FLAG_PRE_RELOC
264 * flag. If false bind all drivers.
265 * @return 0 if OK, -ve on error
266 */
dm_scan_fdt_node(struct udevice * parent,const void * blob,int offset,bool pre_reloc_only)267 static int dm_scan_fdt_node(struct udevice *parent, const void *blob,
268 int offset, bool pre_reloc_only)
269 {
270 int ret = 0, err;
271
272 for (offset = fdt_first_subnode(blob, offset);
273 offset > 0;
274 offset = fdt_next_subnode(blob, offset)) {
275 if (pre_reloc_only &&
276 !dm_fdt_pre_reloc(blob, offset))
277 continue;
278 if (!fdtdec_get_is_enabled(blob, offset)) {
279 pr_debug(" - ignoring disabled device\n");
280 continue;
281 }
282 err = lists_bind_fdt(parent, offset_to_ofnode(offset), NULL);
283 if (err && !ret) {
284 ret = err;
285 debug("%s: ret=%d\n", fdt_get_name(blob, offset, NULL),
286 ret);
287 }
288
289 #if CONFIG_IS_ENABLED(SCMI_FIRMWARE)
290 const char *name;
291
292 /* There is no compatible in "/firmware", bind it by default. */
293 name = fdt_get_name(blob, offset, NULL);
294 if (name && !strcmp(name, "firmware"))
295 ret = device_bind_driver_to_node(parent, "firmware",
296 name, offset_to_ofnode(offset), NULL);
297 #endif
298 }
299
300 if (ret)
301 dm_warn("Some drivers failed to bind\n");
302
303 return ret;
304 }
305
dm_scan_fdt_dev(struct udevice * dev)306 int dm_scan_fdt_dev(struct udevice *dev)
307 {
308 if (!dev_of_valid(dev))
309 return 0;
310
311 #if CONFIG_IS_ENABLED(OF_LIVE)
312 if (of_live_active())
313 return dm_scan_fdt_live(dev, dev_np(dev),
314 gd->flags & GD_FLG_RELOC ? false : true);
315 else
316 #endif
317 return dm_scan_fdt_node(dev, gd->fdt_blob, dev_of_offset(dev),
318 gd->flags & GD_FLG_RELOC ? false : true);
319 }
320
dm_scan_fdt(const void * blob,bool pre_reloc_only)321 int dm_scan_fdt(const void *blob, bool pre_reloc_only)
322 {
323 #if CONFIG_IS_ENABLED(OF_LIVE)
324 if (of_live_active())
325 return dm_scan_fdt_live(gd->dm_root, gd->of_root,
326 pre_reloc_only);
327 else
328 #endif
329 return dm_scan_fdt_node(gd->dm_root, blob, 0, pre_reloc_only);
330 }
331 #else
dm_scan_fdt_node(struct udevice * parent,const void * blob,int offset,bool pre_reloc_only)332 static int dm_scan_fdt_node(struct udevice *parent, const void *blob,
333 int offset, bool pre_reloc_only)
334 {
335 return 0;
336 }
337 #endif
338
dm_extended_scan_fdt(const void * blob,bool pre_reloc_only)339 int dm_extended_scan_fdt(const void *blob, bool pre_reloc_only)
340 {
341 int node, ret;
342
343 ret = dm_scan_fdt(gd->fdt_blob, pre_reloc_only);
344 if (ret) {
345 debug("dm_scan_fdt() failed: %d\n", ret);
346 return ret;
347 }
348
349 /* bind fixed-clock */
350 node = ofnode_to_offset(ofnode_path("/clocks"));
351 /* if no DT "clocks" node, no need to go further */
352 if (node < 0)
353 return ret;
354
355 ret = dm_scan_fdt_node(gd->dm_root, gd->fdt_blob, node,
356 pre_reloc_only);
357 if (ret)
358 debug("dm_scan_fdt_node() failed: %d\n", ret);
359
360 return ret;
361 }
362
dm_scan_other(bool pre_reloc_only)363 __weak int dm_scan_other(bool pre_reloc_only)
364 {
365 return 0;
366 }
367
dm_init_and_scan(bool pre_reloc_only)368 int dm_init_and_scan(bool pre_reloc_only)
369 {
370 int ret;
371
372 ret = dm_init(IS_ENABLED(CONFIG_OF_LIVE));
373 if (ret) {
374 debug("dm_init() failed: %d\n", ret);
375 return ret;
376 }
377 ret = dm_scan_platdata(pre_reloc_only);
378 if (ret) {
379 debug("dm_scan_platdata() failed: %d\n", ret);
380 return ret;
381 }
382
383 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
384 ret = dm_extended_scan_fdt(gd->fdt_blob, pre_reloc_only);
385 if (ret) {
386 debug("dm_extended_scan_dt() failed: %d\n", ret);
387 return ret;
388 }
389 }
390
391 ret = dm_scan_other(pre_reloc_only);
392 if (ret)
393 return ret;
394
395 return 0;
396 }
397
398 /* This is the root driver - all drivers are children of this */
399 U_BOOT_DRIVER(root_driver) = {
400 .name = "root_driver",
401 .id = UCLASS_ROOT,
402 .priv_auto_alloc_size = sizeof(struct root_priv),
403 };
404
405 /* This is the root uclass */
406 UCLASS_DRIVER(root) = {
407 .name = "root",
408 .id = UCLASS_ROOT,
409 };
410