]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
64dbbd40 GVB |
2 | /* |
3 | * (C) Copyright 2007 | |
4 | * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com | |
64dbbd40 GVB |
5 | */ |
6 | ||
7 | #ifndef __FDT_SUPPORT_H | |
8 | #define __FDT_SUPPORT_H | |
9 | ||
813f75d8 | 10 | #if !defined(USE_HOSTCC) |
64dbbd40 | 11 | |
63736e9c | 12 | #include <asm/u-boot.h> |
b08c8c48 | 13 | #include <linux/libfdt.h> |
6dca1d9a | 14 | #include <abuf.h> |
64dbbd40 | 15 | |
807765b0 SG |
16 | /** |
17 | * arch_fixup_fdt() - Write arch-specific information to fdt | |
18 | * | |
19 | * Defined in arch/$(ARCH)/lib/bootm-fdt.c | |
20 | * | |
21 | * @blob: FDT blob to write to | |
185f812c | 22 | * Return: 0 if ok, or -ve FDT_ERR_... on failure |
807765b0 SG |
23 | */ |
24 | int arch_fixup_fdt(void *blob); | |
25 | ||
b75d8dc5 | 26 | void ft_cpu_setup(void *blob, struct bd_info *bd); |
807765b0 | 27 | |
b75d8dc5 | 28 | void ft_pci_setup(void *blob, struct bd_info *bd); |
807765b0 | 29 | |
94fb182c AG |
30 | u32 fdt_getprop_u32_default_node(const void *fdt, int off, int cell, |
31 | const char *prop, const u32 dflt); | |
07e12784 GB |
32 | u32 fdt_getprop_u32_default(const void *fdt, const char *path, |
33 | const char *prop, const u32 dflt); | |
3c4c142e PK |
34 | |
35 | /** | |
36 | * Add data to the root of the FDT before booting the OS. | |
37 | * | |
38 | * See doc/device-tree-bindings/root.txt | |
39 | * | |
40 | * @param fdt FDT address in memory | |
185f812c | 41 | * Return: 0 if ok, or -FDT_ERR_... on error |
3c4c142e | 42 | */ |
10be5b5d | 43 | int fdt_root(void *fdt); |
3c4c142e PK |
44 | |
45 | /** | |
46 | * Add chosen data the FDT before booting the OS. | |
47 | * | |
48 | * In particular, this adds the kernel command line (bootargs) to the FDT. | |
49 | * | |
50 | * @param fdt FDT address in memory | |
185f812c | 51 | * Return: 0 if ok, or -FDT_ERR_... on error |
3c4c142e | 52 | */ |
bc6ed0f9 | 53 | int fdt_chosen(void *fdt); |
3c4c142e PK |
54 | |
55 | /** | |
56 | * Add initrd information to the FDT before booting the OS. | |
57 | * | |
f2cbe6e4 SG |
58 | * Adds linux,initrd-start and linux,initrd-end properties to the /chosen node, |
59 | * creating it if necessary. | |
60 | * | |
61 | * A memory reservation for the ramdisk is added to the FDT, or an existing one | |
62 | * (with matching @initrd_start) updated. | |
63 | * | |
64 | * If @initrd_start == @initrd_end this function does nothing and returns 0. | |
65 | * | |
66 | * @fdt: Pointer to FDT in memory | |
67 | * @initrd_start: Start of ramdisk | |
68 | * @initrd_end: End of ramdisk | |
185f812c | 69 | * Return: 0 if ok, or -FDT_ERR_... on error |
3c4c142e | 70 | */ |
dbe963ae | 71 | int fdt_initrd(void *fdt, ulong initrd_start, ulong initrd_end); |
3c4c142e | 72 | |
e93becf8 KG |
73 | void do_fixup_by_path(void *fdt, const char *path, const char *prop, |
74 | const void *val, int len, int create); | |
75 | void do_fixup_by_path_u32(void *fdt, const char *path, const char *prop, | |
76 | u32 val, int create); | |
8ddb10ea CL |
77 | |
78 | static inline void do_fixup_by_path_string(void *fdt, const char *path, | |
79 | const char *prop, const char *status) | |
80 | { | |
81 | do_fixup_by_path(fdt, path, prop, status, strlen(status) + 1, 1); | |
82 | } | |
83 | ||
9eb77cea KG |
84 | void do_fixup_by_prop(void *fdt, |
85 | const char *pname, const void *pval, int plen, | |
86 | const char *prop, const void *val, int len, | |
87 | int create); | |
88 | void do_fixup_by_prop_u32(void *fdt, | |
89 | const char *pname, const void *pval, int plen, | |
90 | const char *prop, u32 val, int create); | |
91 | void do_fixup_by_compat(void *fdt, const char *compat, | |
92 | const char *prop, const void *val, int len, int create); | |
93 | void do_fixup_by_compat_u32(void *fdt, const char *compat, | |
94 | const char *prop, u32 val, int create); | |
5c1cf89f AP |
95 | /** |
96 | * Setup the memory node in the DT. Creates one if none was existing before. | |
97 | * Calls fdt_fixup_memory_banks() to populate a single reg pair covering the | |
98 | * whole memory. | |
99 | * | |
100 | * @param blob FDT blob to update | |
101 | * @param start Begin of DRAM mapping in physical memory | |
102 | * @param size Size of the single memory bank | |
185f812c | 103 | * Return: 0 if ok, or -1 or -FDT_ERR_... on error |
5c1cf89f | 104 | */ |
3c927281 | 105 | int fdt_fixup_memory(void *blob, u64 start, u64 size); |
5c1cf89f AP |
106 | |
107 | /** | |
108 | * Fill the DT memory node with multiple memory banks. | |
109 | * Creates the node if none was existing before. | |
110 | * If banks is 0, it will not touch the existing reg property. This allows | |
111 | * boards to not mess with the existing DT setup, which may have been | |
112 | * filled in properly before. | |
113 | * | |
114 | * @param blob FDT blob to update | |
115 | * @param start Array of size <banks> to hold the start addresses. | |
116 | * @param size Array of size <banks> to hold the size of each region. | |
117 | * @param banks Number of memory banks to create. If 0, the reg | |
118 | * property will be left untouched. | |
185f812c | 119 | * Return: 0 if ok, or -1 or -FDT_ERR_... on error |
5c1cf89f | 120 | */ |
63c09417 | 121 | #ifdef CONFIG_ARCH_FIXUP_FDT_MEMORY |
a6bd9e83 | 122 | int fdt_fixup_memory_banks(void *blob, u64 start[], u64 size[], int banks); |
949b5a96 | 123 | int fdt_set_usable_memory(void *blob, u64 start[], u64 size[], int banks); |
63c09417 MY |
124 | #else |
125 | static inline int fdt_fixup_memory_banks(void *blob, u64 start[], u64 size[], | |
126 | int banks) | |
127 | { | |
128 | return 0; | |
129 | } | |
130 | #endif | |
5c1cf89f | 131 | |
ba37aa03 | 132 | void fdt_fixup_ethernet(void *fdt); |
22fb2246 MF |
133 | int fdt_find_and_setprop(void *fdt, const char *node, const char *prop, |
134 | const void *val, int len, int create); | |
b8ec2385 | 135 | void fdt_fixup_qe_firmware(void *fdt); |
64dbbd40 | 136 | |
08daa258 TH |
137 | /** |
138 | * Update native-mode property of display-timings node to the phandle | |
139 | * of the timings matching a display by name (case insensitive). | |
140 | * | |
141 | * see kernel Documentation/devicetree/bindings/video/display-timing.txt | |
142 | * | |
143 | * @param blob FDT blob to update | |
144 | * @param path path within dt | |
145 | * @param display name of display timing to match | |
185f812c | 146 | * Return: 0 if ok, or -FDT_ERR_... on error |
08daa258 TH |
147 | */ |
148 | int fdt_fixup_display(void *blob, const char *path, const char *display); | |
149 | ||
b9f6786a | 150 | #if defined(CONFIG_USB_EHCI_FSL) || defined(CONFIG_USB_XHCI_FSL) |
b75d8dc5 | 151 | void fsl_fdt_fixup_dr_usb(void *blob, struct bd_info *bd); |
18e69a35 | 152 | #else |
b75d8dc5 | 153 | static inline void fsl_fdt_fixup_dr_usb(void *blob, struct bd_info *bd) {} |
b9f6786a | 154 | #endif /* defined(CONFIG_USB_EHCI_FSL) || defined(CONFIG_USB_XHCI_FSL) */ |
18e69a35 | 155 | |
929a2138 | 156 | #if defined(CONFIG_SYS_FSL_SEC_COMPAT) |
6b70ffb9 KP |
157 | void fdt_fixup_crypto_node(void *blob, int sec_rev); |
158 | #else | |
159 | static inline void fdt_fixup_crypto_node(void *blob, int sec_rev) {} | |
160 | #endif | |
161 | ||
9f45aeb9 PT |
162 | /** |
163 | * Record information about a processed loadable in /fit-images (creating | |
164 | * /fit-images if necessary). | |
165 | * | |
166 | * @param blob FDT blob to update | |
167 | * @param index index of this loadable | |
168 | * @param name name of the loadable | |
169 | * @param load_addr address the loadable was loaded to | |
170 | * @param size number of bytes loaded | |
171 | * @param entry_point entry point (if specified, otherwise pass -1) | |
172 | * @param type type (if specified, otherwise pass NULL) | |
173 | * @param os os-type (if specified, otherwise pass NULL) | |
be2d1a87 | 174 | * @param arch architecture (if specified, otherwise pass NULL) |
185f812c | 175 | * Return: 0 if ok, or -1 or -FDT_ERR_... on error |
9f45aeb9 PT |
176 | */ |
177 | int fdt_record_loadable(void *blob, u32 index, const char *name, | |
178 | uintptr_t load_addr, u32 size, uintptr_t entry_point, | |
be2d1a87 | 179 | const char *type, const char *os, const char *arch); |
9f45aeb9 | 180 | |
8ab451c4 KG |
181 | #ifdef CONFIG_PCI |
182 | #include <pci.h> | |
183 | int fdt_pci_dma_ranges(void *blob, int phb_off, struct pci_controller *hose); | |
184 | #endif | |
185 | ||
a9e8e291 SG |
186 | int fdt_find_or_add_subnode(void *fdt, int parentoffset, const char *name); |
187 | ||
e895a4b0 SG |
188 | /** |
189 | * Add board-specific data to the FDT before booting the OS. | |
190 | * | |
191 | * Use CONFIG_SYS_FDT_PAD to ensure there is sufficient space. | |
6f4dbc21 | 192 | * This function is called if CONFIG_OF_BOARD_SETUP is defined |
e895a4b0 SG |
193 | * |
194 | * @param blob FDT blob to update | |
bb5a2cf9 | 195 | * @param bd Pointer to board data |
185f812c | 196 | * Return: 0 if ok, or -FDT_ERR_... on error |
e895a4b0 | 197 | */ |
b75d8dc5 | 198 | int ft_board_setup(void *blob, struct bd_info *bd); |
e895a4b0 | 199 | |
6dca1d9a RV |
200 | /** |
201 | * board_rng_seed() - Provide a seed to be passed via /chosen/rng-seed | |
202 | * | |
203 | * This function is called if CONFIG_BOARD_RNG_SEED is set, and must | |
204 | * be provided by the board. It should return, via @buf, some suitable | |
205 | * seed value to pass to the kernel. | |
206 | * | |
207 | * @param buf A struct abuf for returning the seed and its size. | |
208 | * @return 0 if ok, negative on error. | |
209 | */ | |
210 | int board_rng_seed(struct abuf *buf); | |
211 | ||
f0b21ebd NM |
212 | /** |
213 | * board_fdt_chosen_bootargs() - Arbitrarily amend fdt kernel command line | |
214 | * | |
215 | * This is used for late modification of kernel command line arguments just | |
216 | * before they are added into the /chosen node in flat device tree. | |
217 | * | |
218 | * @return: pointer to kernel command line arguments in memory | |
219 | */ | |
220 | char *board_fdt_chosen_bootargs(void); | |
221 | ||
00c200f1 VA |
222 | /* |
223 | * The keystone2 SOC requires all 32 bit aliased addresses to be converted | |
224 | * to their 36 physical format. This has to happen after all fdt nodes | |
225 | * are added or modified by the image_setup_libfdt(). The ft_board_setup_ex() | |
226 | * called at the end of the image_setup_libfdt() is to do that convertion. | |
227 | */ | |
b75d8dc5 | 228 | void ft_board_setup_ex(void *blob, struct bd_info *bd); |
e125a2ff | 229 | |
c654b517 SG |
230 | /** |
231 | * Add system-specific data to the FDT before booting the OS. | |
232 | * | |
233 | * Use CONFIG_SYS_FDT_PAD to ensure there is sufficient space. | |
234 | * This function is called if CONFIG_OF_SYSTEM_SETUP is defined | |
235 | * | |
236 | * @param blob FDT blob to update | |
bb5a2cf9 | 237 | * @param bd Pointer to board data |
185f812c | 238 | * Return: 0 if ok, or -FDT_ERR_... on error |
c654b517 | 239 | */ |
b75d8dc5 | 240 | int ft_system_setup(void *blob, struct bd_info *bd); |
c654b517 | 241 | |
90fbee3e | 242 | void set_working_fdt_addr(ulong addr); |
ef476836 HS |
243 | |
244 | /** | |
451c1ab6 SG |
245 | * fdt_shrink_to_minimum() - shrink FDT while allowing for some margin |
246 | * | |
247 | * Shrink down the given blob to 'minimum' size + some extrasize. | |
248 | * | |
249 | * The new size is enough to hold the existing contents plus @extrasize bytes, | |
250 | * plus 5 memory reservations. Also, the end of the FDT is aligned to a 4KB | |
251 | * boundary, so it might end up up to 4KB larger than needed. | |
252 | * | |
253 | * If there is an existing memory reservation for @blob in the FDT, it is | |
254 | * updated for the new size. | |
ef476836 HS |
255 | * |
256 | * @param blob FDT blob to update | |
257 | * @param extrasize additional bytes needed | |
185f812c | 258 | * Return: 0 if ok, or -FDT_ERR_... on error |
ef476836 HS |
259 | */ |
260 | int fdt_shrink_to_minimum(void *blob, uint extrasize); | |
451c1ab6 | 261 | |
b3606f14 | 262 | int fdt_increase_size(void *fdt, int add_len); |
54f9c866 | 263 | |
574506c3 MB |
264 | int fdt_delete_disabled_nodes(void *blob); |
265 | ||
5f4e32d0 | 266 | struct node_info; |
f4ae23a7 | 267 | #if defined(CONFIG_FDT_FIXUP_PARTITIONS) |
5f4e32d0 MY |
268 | void fdt_fixup_mtdparts(void *fdt, const struct node_info *node_info, |
269 | int node_info_size); | |
f4ae23a7 | 270 | #else |
5f4e32d0 MY |
271 | static inline void fdt_fixup_mtdparts(void *fdt, |
272 | const struct node_info *node_info, | |
273 | int node_info_size) | |
274 | { | |
275 | } | |
f4ae23a7 CS |
276 | #endif |
277 | ||
163c5f60 PD |
278 | /** |
279 | * copy the fixed-partition nodes from U-Boot device tree to external blob | |
280 | * | |
281 | * @param blob FDT blob to update | |
282 | * Return: 0 if ok, or non-zero on error | |
283 | */ | |
284 | int fdt_copy_fixed_partitions(void *blob); | |
285 | ||
49b97d9c | 286 | void fdt_del_node_and_alias(void *blob, const char *alias); |
641067fb FD |
287 | |
288 | /** | |
289 | * Translate an address from the DT into a CPU physical address | |
290 | * | |
291 | * The translation relies on the "ranges" property. | |
292 | * | |
293 | * @param blob Pointer to device tree blob | |
294 | * @param node_offset Node DT offset | |
295 | * @param in_addr Pointer to the address to translate | |
185f812c | 296 | * Return: translated address or OF_BAD_ADDR on error |
641067fb | 297 | */ |
11e44fc6 SW |
298 | u64 fdt_translate_address(const void *blob, int node_offset, |
299 | const __be32 *in_addr); | |
641067fb FD |
300 | /** |
301 | * Translate a DMA address from the DT into a CPU physical address | |
302 | * | |
303 | * The translation relies on the "dma-ranges" property. | |
304 | * | |
305 | * @param blob Pointer to device tree blob | |
306 | * @param node_offset Node DT offset | |
307 | * @param in_addr Pointer to the DMA address to translate | |
185f812c | 308 | * Return: translated DMA address or OF_BAD_ADDR on error |
641067fb FD |
309 | */ |
310 | u64 fdt_translate_dma_address(const void *blob, int node_offset, | |
311 | const __be32 *in_addr); | |
312 | ||
51bdb509 NSJ |
313 | /** |
314 | * Get DMA ranges for a specifc node, this is useful to perform bus->cpu and | |
315 | * cpu->bus address translations | |
316 | * | |
317 | * @param blob Pointer to device tree blob | |
318 | * @param node_offset Node DT offset | |
319 | * @param cpu Pointer to variable storing the range's cpu address | |
320 | * @param bus Pointer to variable storing the range's bus address | |
321 | * @param size Pointer to variable storing the range's size | |
185f812c | 322 | * Return: translated DMA address or OF_BAD_ADDR on error |
51bdb509 NSJ |
323 | */ |
324 | int fdt_get_dma_range(const void *blob, int node_offset, phys_addr_t *cpu, | |
325 | dma_addr_t *bus, u64 *size); | |
326 | ||
75e73afd KG |
327 | int fdt_node_offset_by_compat_reg(void *blob, const char *compat, |
328 | phys_addr_t compat_off); | |
9ab0c2f8 MB |
329 | int fdt_node_offset_by_pathf(void *blob, const char *fmt, ...) |
330 | __attribute__ ((format (printf, 2, 3))); | |
3058e283 MB |
331 | |
332 | #define fdt_for_each_node_by_compatible(node, fdt, start, compat) \ | |
333 | for (node = fdt_node_offset_by_compatible(fdt, start, compat); \ | |
334 | node >= 0; \ | |
335 | node = fdt_node_offset_by_compatible(fdt, node, compat)) | |
336 | ||
f117c0f0 | 337 | int fdt_set_phandle(void *fdt, int nodeoffset, uint32_t phandle); |
3c927ccc | 338 | unsigned int fdt_create_phandle(void *fdt, int nodeoffset); |
9ab0c2f8 MB |
339 | unsigned int fdt_create_phandle_by_compatible(void *fdt, const char *compat); |
340 | unsigned int fdt_create_phandle_by_pathf(void *fdt, const char *fmt, ...) | |
341 | __attribute__ ((format (printf, 2, 3))); | |
beca5a5f | 342 | int fdt_add_edid(void *blob, const char *compat, unsigned char *buf); |
3c950e2e | 343 | |
bb682001 TT |
344 | int fdt_verify_alias_address(void *fdt, int anode, const char *alias, |
345 | u64 addr); | |
ec002119 | 346 | u64 fdt_get_base_address(const void *fdt, int node); |
c48e6868 AG |
347 | int fdt_read_range(void *fdt, int node, int n, uint64_t *child_addr, |
348 | uint64_t *addr, uint64_t *len); | |
bb682001 | 349 | |
2a523f52 SL |
350 | enum fdt_status { |
351 | FDT_STATUS_OKAY, | |
352 | FDT_STATUS_DISABLED, | |
353 | FDT_STATUS_FAIL, | |
2a523f52 | 354 | }; |
2105cd04 | 355 | int fdt_set_node_status(void *fdt, int nodeoffset, enum fdt_status status); |
2a523f52 SL |
356 | static inline int fdt_status_okay(void *fdt, int nodeoffset) |
357 | { | |
2105cd04 | 358 | return fdt_set_node_status(fdt, nodeoffset, FDT_STATUS_OKAY); |
2a523f52 SL |
359 | } |
360 | static inline int fdt_status_disabled(void *fdt, int nodeoffset) | |
361 | { | |
2105cd04 | 362 | return fdt_set_node_status(fdt, nodeoffset, FDT_STATUS_DISABLED); |
2a523f52 | 363 | } |
b940ca64 GR |
364 | static inline int fdt_status_fail(void *fdt, int nodeoffset) |
365 | { | |
2105cd04 | 366 | return fdt_set_node_status(fdt, nodeoffset, FDT_STATUS_FAIL); |
b940ca64 | 367 | } |
2a523f52 | 368 | |
b940ca64 | 369 | int fdt_set_status_by_alias(void *fdt, const char *alias, |
2105cd04 | 370 | enum fdt_status status); |
b940ca64 | 371 | static inline int fdt_status_okay_by_alias(void *fdt, const char *alias) |
2a523f52 | 372 | { |
2105cd04 | 373 | return fdt_set_status_by_alias(fdt, alias, FDT_STATUS_OKAY); |
2a523f52 | 374 | } |
b940ca64 | 375 | static inline int fdt_status_disabled_by_alias(void *fdt, const char *alias) |
2a523f52 | 376 | { |
2105cd04 | 377 | return fdt_set_status_by_alias(fdt, alias, FDT_STATUS_DISABLED); |
2a523f52 | 378 | } |
b940ca64 GR |
379 | static inline int fdt_status_fail_by_alias(void *fdt, const char *alias) |
380 | { | |
2105cd04 | 381 | return fdt_set_status_by_alias(fdt, alias, FDT_STATUS_FAIL); |
b940ca64 | 382 | } |
2a523f52 | 383 | |
9ab0c2f8 MB |
384 | int fdt_set_status_by_compatible(void *fdt, const char *compat, |
385 | enum fdt_status status); | |
386 | static inline int fdt_status_okay_by_compatible(void *fdt, const char *compat) | |
387 | { | |
388 | return fdt_set_status_by_compatible(fdt, compat, FDT_STATUS_OKAY); | |
389 | } | |
390 | static inline int fdt_status_disabled_by_compatible(void *fdt, | |
391 | const char *compat) | |
392 | { | |
393 | return fdt_set_status_by_compatible(fdt, compat, FDT_STATUS_DISABLED); | |
394 | } | |
395 | static inline int fdt_status_fail_by_compatible(void *fdt, const char *compat) | |
396 | { | |
397 | return fdt_set_status_by_compatible(fdt, compat, FDT_STATUS_FAIL); | |
398 | } | |
399 | ||
400 | int fdt_set_status_by_pathf(void *fdt, enum fdt_status status, const char *fmt, | |
401 | ...) __attribute__ ((format (printf, 3, 4))); | |
402 | #define fdt_status_okay_by_pathf(fdt, fmt, ...) \ | |
403 | fdt_set_status_by_pathf((fdt), FDT_STATUS_OKAY, (fmt), ##__VA_ARGS__) | |
404 | #define fdt_status_disabled_by_pathf(fdt, fmt, ...) \ | |
405 | fdt_set_status_by_pathf((fdt), FDT_STATUS_DISABLED, (fmt), ##__VA_ARGS__) | |
406 | #define fdt_status_fail_by_pathf(fdt, fmt, ...) \ | |
407 | fdt_set_status_by_pathf((fdt), FDT_STATUS_FAIL, (fmt), ##__VA_ARGS__) | |
408 | ||
08df4a21 | 409 | /* Helper to read a big number; size is in cells (not bytes) */ |
eed36609 | 410 | static inline u64 fdt_read_number(const fdt32_t *cell, int size) |
08df4a21 AB |
411 | { |
412 | u64 r = 0; | |
413 | while (size--) | |
414 | r = (r << 32) | fdt32_to_cpu(*(cell++)); | |
415 | return r; | |
416 | } | |
417 | ||
eed36609 | 418 | void fdt_support_default_count_cells(const void *blob, int parentoffset, |
f43b4356 | 419 | int *addrc, int *sizec); |
d50b07df JH |
420 | int ft_verify_fdt(void *fdt); |
421 | int arch_fixup_memory_node(void *blob); | |
f43b4356 | 422 | |
d4f495a8 HG |
423 | int fdt_setup_simplefb_node(void *fdt, int node, u64 base_address, u32 width, |
424 | u32 height, u32 stride, const char *format); | |
425 | ||
fc7c3189 PA |
426 | int fdt_overlay_apply_verbose(void *fdt, void *fdto); |
427 | ||
bbdbcaf5 KM |
428 | int fdt_valid(struct fdt_header **blobp); |
429 | ||
90c08fa0 MP |
430 | /** |
431 | * fdt_get_cells_len() - Get the length of a type of cell in top-level nodes | |
432 | * | |
433 | * Returns the length of the cell type in bytes (4 or 8). | |
434 | * | |
435 | * @blob: Pointer to device tree blob | |
436 | * @nr_cells_name: Name to lookup, e.g. "#address-cells" | |
437 | */ | |
438 | int fdt_get_cells_len(const void *blob, char *nr_cells_name); | |
439 | ||
813f75d8 | 440 | #endif /* !USE_HOSTCC */ |
29a23f9d HS |
441 | |
442 | #ifdef USE_HOSTCC | |
443 | int fdtdec_get_int(const void *blob, int node, const char *prop_name, | |
444 | int default_val); | |
10d887dd KY |
445 | |
446 | /* | |
447 | * Count child nodes of one parent node. | |
448 | * | |
449 | * @param blob FDT blob | |
450 | * @param node parent node | |
185f812c | 451 | * Return: number of child node; 0 if there is not child node |
10d887dd KY |
452 | */ |
453 | int fdtdec_get_child_count(const void *blob, int node); | |
29a23f9d | 454 | #endif |
6bedf447 PK |
455 | #ifdef CONFIG_FMAN_ENET |
456 | int fdt_update_ethernet_dt(void *blob); | |
457 | #endif | |
f9747a5a YG |
458 | #ifdef CONFIG_FSL_MC_ENET |
459 | void fdt_fixup_board_enet(void *blob); | |
460 | #endif | |
9ea0a1ee FD |
461 | #ifdef CONFIG_CMD_PSTORE |
462 | void fdt_fixup_pstore(void *blob); | |
463 | #endif | |
64dbbd40 | 464 | #endif /* ifndef __FDT_SUPPORT_H */ |