]>
Commit | Line | Data |
---|---|---|
6494d708 SG |
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> | |
94f7afdf | 12 | #include <fdtdec.h> |
6494d708 | 13 | #include <malloc.h> |
6a6d8fbe | 14 | #include <libfdt.h> |
6494d708 SG |
15 | #include <dm/device.h> |
16 | #include <dm/device-internal.h> | |
17 | #include <dm/lists.h> | |
19c8205e SG |
18 | #include <dm/of.h> |
19 | #include <dm/of_access.h> | |
6494d708 | 20 | #include <dm/platdata.h> |
19c8205e | 21 | #include <dm/read.h> |
fd536d81 | 22 | #include <dm/root.h> |
6494d708 SG |
23 | #include <dm/uclass.h> |
24 | #include <dm/util.h> | |
25 | #include <linux/list.h> | |
26 | ||
27 | DECLARE_GLOBAL_DATA_PTR; | |
28 | ||
66eaea6c SR |
29 | struct root_priv { |
30 | fdt_addr_t translation_offset; /* optional translation offset */ | |
31 | }; | |
32 | ||
6494d708 SG |
33 | static const struct driver_info root_info = { |
34 | .name = "root_driver", | |
35 | }; | |
36 | ||
54c5d08a | 37 | struct udevice *dm_root(void) |
6494d708 SG |
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 | ||
2f11cd91 SG |
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 */ | |
b0d9512a LV |
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 | } | |
2f11cd91 SG |
54 | } |
55 | ||
66eaea6c SR |
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 | ||
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 | ||
484fdf5b MS |
72 | #if defined(CONFIG_NEEDS_MANUAL_RELOC) |
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; | |
31e1029a MS |
94 | if (entry->child_post_bind) |
95 | entry->child_post_bind += gd->reloc_off; | |
484fdf5b MS |
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 | ||
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; | |
31e1029a MS |
118 | if (entry->pre_probe) |
119 | entry->pre_probe += gd->reloc_off; | |
484fdf5b MS |
120 | if (entry->post_probe) |
121 | entry->post_probe += gd->reloc_off; | |
122 | if (entry->pre_remove) | |
123 | entry->pre_remove += gd->reloc_off; | |
31e1029a MS |
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; | |
484fdf5b MS |
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 | } | |
5aeedebc AD |
137 | |
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 | ||
484fdf5b MS |
151 | #endif |
152 | ||
19c8205e | 153 | int dm_init(bool of_live) |
6494d708 SG |
154 | { |
155 | int ret; | |
156 | ||
157 | if (gd->dm_root) { | |
158 | dm_warn("Virtual root driver already exists!\n"); | |
159 | return -EINVAL; | |
160 | } | |
89876a55 | 161 | INIT_LIST_HEAD(&DM_UCLASS_ROOT_NON_CONST); |
6494d708 | 162 | |
484fdf5b MS |
163 | #if defined(CONFIG_NEEDS_MANUAL_RELOC) |
164 | fix_drivers(); | |
165 | fix_uclass(); | |
5aeedebc | 166 | fix_devices(); |
484fdf5b MS |
167 | #endif |
168 | ||
00606d7e | 169 | ret = device_bind_by_name(NULL, false, &root_info, &DM_ROOT_NON_CONST); |
7497812d SG |
170 | if (ret) |
171 | return ret; | |
0f925822 | 172 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
19c8205e SG |
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); | |
2f3b95db | 179 | #endif |
7497812d | 180 | ret = device_probe(DM_ROOT_NON_CONST); |
6494d708 SG |
181 | if (ret) |
182 | return ret; | |
183 | ||
184 | return 0; | |
185 | } | |
186 | ||
9adbd7a1 SG |
187 | int dm_uninit(void) |
188 | { | |
706865af | 189 | device_remove(dm_root(), DM_REMOVE_NORMAL); |
9adbd7a1 SG |
190 | device_unbind(dm_root()); |
191 | ||
192 | return 0; | |
193 | } | |
194 | ||
bc85aa40 SR |
195 | #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE) |
196 | int dm_remove_devices_flags(uint flags) | |
197 | { | |
198 | device_remove(dm_root(), flags); | |
199 | ||
200 | return 0; | |
201 | } | |
202 | #endif | |
203 | ||
00606d7e | 204 | int dm_scan_platdata(bool pre_reloc_only) |
6494d708 SG |
205 | { |
206 | int ret; | |
207 | ||
00606d7e | 208 | ret = lists_bind_drivers(DM_ROOT_NON_CONST, pre_reloc_only); |
6494d708 SG |
209 | if (ret == -ENOENT) { |
210 | dm_warn("Some drivers were not found\n"); | |
211 | ret = 0; | |
212 | } | |
6494d708 | 213 | |
cbf86d71 | 214 | return ret; |
6494d708 SG |
215 | } |
216 | ||
19c8205e SG |
217 | #if CONFIG_IS_ENABLED(OF_LIVE) |
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 | continue; | |
229 | if (!of_device_is_available(np)) { | |
230 | dm_dbg(" - ignoring disabled device\n"); | |
231 | continue; | |
232 | } | |
233 | err = lists_bind_fdt(parent, np_to_ofnode(np), NULL); | |
234 | if (err && !ret) { | |
235 | ret = err; | |
236 | debug("%s: ret=%d\n", np->name, ret); | |
237 | } | |
238 | } | |
239 | ||
240 | if (ret) | |
241 | dm_warn("Some drivers failed to bind\n"); | |
242 | ||
243 | return ret; | |
244 | } | |
245 | #endif /* CONFIG_IS_ENABLED(OF_LIVE) */ | |
246 | ||
29629eb8 | 247 | #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA) |
a771a04f SG |
248 | /** |
249 | * dm_scan_fdt_node() - Scan the device tree and bind drivers for a node | |
250 | * | |
251 | * This scans the subnodes of a device tree node and and creates a driver | |
252 | * for each one. | |
253 | * | |
254 | * @parent: Parent device for the devices that will be created | |
255 | * @blob: Pointer to device tree blob | |
256 | * @offset: Offset of node to scan | |
257 | * @pre_reloc_only: If true, bind only drivers with the DM_FLAG_PRE_RELOC | |
258 | * flag. If false bind all drivers. | |
259 | * @return 0 if OK, -ve on error | |
260 | */ | |
261 | static int dm_scan_fdt_node(struct udevice *parent, const void *blob, | |
262 | int offset, bool pre_reloc_only) | |
6494d708 | 263 | { |
6494d708 | 264 | int ret = 0, err; |
1ca7e206 SG |
265 | |
266 | for (offset = fdt_first_subnode(blob, offset); | |
267 | offset > 0; | |
268 | offset = fdt_next_subnode(blob, offset)) { | |
269 | if (pre_reloc_only && | |
27326c7e | 270 | !dm_fdt_pre_reloc(blob, offset)) |
1ca7e206 | 271 | continue; |
94f7afdf SG |
272 | if (!fdtdec_get_is_enabled(blob, offset)) { |
273 | dm_dbg(" - ignoring disabled device\n"); | |
274 | continue; | |
275 | } | |
f5b5719c | 276 | err = lists_bind_fdt(parent, offset_to_ofnode(offset), NULL); |
bc7b2f43 | 277 | if (err && !ret) { |
1ca7e206 | 278 | ret = err; |
bc7b2f43 SG |
279 | debug("%s: ret=%d\n", fdt_get_name(blob, offset, NULL), |
280 | ret); | |
281 | } | |
1ca7e206 | 282 | } |
6494d708 SG |
283 | |
284 | if (ret) | |
285 | dm_warn("Some drivers failed to bind\n"); | |
286 | ||
287 | return ret; | |
288 | } | |
1ca7e206 | 289 | |
cc7f66f7 SG |
290 | int dm_scan_fdt_dev(struct udevice *dev) |
291 | { | |
19c8205e | 292 | if (!dev_of_valid(dev)) |
cc7f66f7 SG |
293 | return 0; |
294 | ||
19c8205e SG |
295 | #if CONFIG_IS_ENABLED(OF_LIVE) |
296 | if (of_live_active()) | |
297 | return dm_scan_fdt_live(dev, dev_np(dev), | |
298 | gd->flags & GD_FLG_RELOC ? false : true); | |
299 | else | |
300 | #endif | |
e160f7d4 | 301 | return dm_scan_fdt_node(dev, gd->fdt_blob, dev_of_offset(dev), |
cc7f66f7 SG |
302 | gd->flags & GD_FLG_RELOC ? false : true); |
303 | } | |
304 | ||
1ca7e206 SG |
305 | int dm_scan_fdt(const void *blob, bool pre_reloc_only) |
306 | { | |
19c8205e SG |
307 | #if CONFIG_IS_ENABLED(OF_LIVE) |
308 | if (of_live_active()) | |
309 | return dm_scan_fdt_live(gd->dm_root, gd->of_root, | |
310 | pre_reloc_only); | |
311 | else | |
312 | #endif | |
1ca7e206 SG |
313 | return dm_scan_fdt_node(gd->dm_root, blob, 0, pre_reloc_only); |
314 | } | |
e81c9864 PC |
315 | #else |
316 | static int dm_scan_fdt_node(struct udevice *parent, const void *blob, | |
317 | int offset, bool pre_reloc_only) | |
318 | { | |
319 | return 0; | |
320 | } | |
6494d708 SG |
321 | #endif |
322 | ||
e81c9864 PC |
323 | int dm_extended_scan_fdt(const void *blob, bool pre_reloc_only) |
324 | { | |
325 | int node, ret; | |
326 | ||
327 | ret = dm_scan_fdt(gd->fdt_blob, pre_reloc_only); | |
328 | if (ret) { | |
329 | debug("dm_scan_fdt() failed: %d\n", ret); | |
330 | return ret; | |
331 | } | |
332 | ||
333 | /* bind fixed-clock */ | |
334 | node = ofnode_to_offset(ofnode_path("/clocks")); | |
335 | /* if no DT "clocks" node, no need to go further */ | |
336 | if (node < 0) | |
337 | return ret; | |
338 | ||
339 | ret = dm_scan_fdt_node(gd->dm_root, gd->fdt_blob, node, | |
340 | pre_reloc_only); | |
341 | if (ret) | |
342 | debug("dm_scan_fdt_node() failed: %d\n", ret); | |
343 | ||
344 | return ret; | |
345 | } | |
346 | ||
bb58503d SG |
347 | __weak int dm_scan_other(bool pre_reloc_only) |
348 | { | |
349 | return 0; | |
350 | } | |
351 | ||
ab7cd627 SG |
352 | int dm_init_and_scan(bool pre_reloc_only) |
353 | { | |
354 | int ret; | |
355 | ||
19c8205e | 356 | ret = dm_init(IS_ENABLED(CONFIG_OF_LIVE)); |
ab7cd627 SG |
357 | if (ret) { |
358 | debug("dm_init() failed: %d\n", ret); | |
359 | return ret; | |
360 | } | |
361 | ret = dm_scan_platdata(pre_reloc_only); | |
362 | if (ret) { | |
363 | debug("dm_scan_platdata() failed: %d\n", ret); | |
364 | return ret; | |
365 | } | |
b2b0d3e7 | 366 | |
29629eb8 | 367 | if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) { |
e81c9864 | 368 | ret = dm_extended_scan_fdt(gd->fdt_blob, pre_reloc_only); |
b2b0d3e7 | 369 | if (ret) { |
e81c9864 | 370 | debug("dm_extended_scan_dt() failed: %d\n", ret); |
b2b0d3e7 SG |
371 | return ret; |
372 | } | |
ab7cd627 | 373 | } |
b2b0d3e7 | 374 | |
bb58503d SG |
375 | ret = dm_scan_other(pre_reloc_only); |
376 | if (ret) | |
377 | return ret; | |
ab7cd627 SG |
378 | |
379 | return 0; | |
380 | } | |
381 | ||
6494d708 SG |
382 | /* This is the root driver - all drivers are children of this */ |
383 | U_BOOT_DRIVER(root_driver) = { | |
384 | .name = "root_driver", | |
385 | .id = UCLASS_ROOT, | |
66eaea6c | 386 | .priv_auto_alloc_size = sizeof(struct root_priv), |
6494d708 SG |
387 | }; |
388 | ||
389 | /* This is the root uclass */ | |
390 | UCLASS_DRIVER(root) = { | |
391 | .name = "root", | |
392 | .id = UCLASS_ROOT, | |
393 | }; |