1 | /* SPDX-License-Identifier: (GPL-2.0-or-later OR BSD-2-Clause) */ |
2 | #ifndef LIBFDT_H |
3 | #define LIBFDT_H |
4 | /* |
5 | * libfdt - Flat Device Tree manipulation |
6 | * Copyright (C) 2006 David Gibson, IBM Corporation. |
7 | */ |
8 | |
9 | #include "libfdt_env.h" |
10 | #include "fdt.h" |
11 | |
12 | #ifdef __cplusplus |
13 | extern "C" { |
14 | #endif |
15 | |
16 | #define FDT_FIRST_SUPPORTED_VERSION 0x02 |
17 | #define FDT_LAST_COMPATIBLE_VERSION 0x10 |
18 | #define FDT_LAST_SUPPORTED_VERSION 0x11 |
19 | |
20 | /* Error codes: informative error codes */ |
21 | #define FDT_ERR_NOTFOUND 1 |
22 | /* FDT_ERR_NOTFOUND: The requested node or property does not exist */ |
23 | #define FDT_ERR_EXISTS 2 |
24 | /* FDT_ERR_EXISTS: Attempted to create a node or property which |
25 | * already exists */ |
26 | #define FDT_ERR_NOSPACE 3 |
27 | /* FDT_ERR_NOSPACE: Operation needed to expand the device |
28 | * tree, but its buffer did not have sufficient space to |
29 | * contain the expanded tree. Use fdt_open_into() to move the |
30 | * device tree to a buffer with more space. */ |
31 | |
32 | /* Error codes: codes for bad parameters */ |
33 | #define FDT_ERR_BADOFFSET 4 |
34 | /* FDT_ERR_BADOFFSET: Function was passed a structure block |
35 | * offset which is out-of-bounds, or which points to an |
36 | * unsuitable part of the structure for the operation. */ |
37 | #define FDT_ERR_BADPATH 5 |
38 | /* FDT_ERR_BADPATH: Function was passed a badly formatted path |
39 | * (e.g. missing a leading / for a function which requires an |
40 | * absolute path) */ |
41 | #define FDT_ERR_BADPHANDLE 6 |
42 | /* FDT_ERR_BADPHANDLE: Function was passed an invalid phandle. |
43 | * This can be caused either by an invalid phandle property |
44 | * length, or the phandle value was either 0 or -1, which are |
45 | * not permitted. */ |
46 | #define FDT_ERR_BADSTATE 7 |
47 | /* FDT_ERR_BADSTATE: Function was passed an incomplete device |
48 | * tree created by the sequential-write functions, which is |
49 | * not sufficiently complete for the requested operation. */ |
50 | |
51 | /* Error codes: codes for bad device tree blobs */ |
52 | #define FDT_ERR_TRUNCATED 8 |
53 | /* FDT_ERR_TRUNCATED: FDT or a sub-block is improperly |
54 | * terminated (overflows, goes outside allowed bounds, or |
55 | * isn't properly terminated). */ |
56 | #define FDT_ERR_BADMAGIC 9 |
57 | /* FDT_ERR_BADMAGIC: Given "device tree" appears not to be a |
58 | * device tree at all - it is missing the flattened device |
59 | * tree magic number. */ |
60 | #define FDT_ERR_BADVERSION 10 |
61 | /* FDT_ERR_BADVERSION: Given device tree has a version which |
62 | * can't be handled by the requested operation. For |
63 | * read-write functions, this may mean that fdt_open_into() is |
64 | * required to convert the tree to the expected version. */ |
65 | #define FDT_ERR_BADSTRUCTURE 11 |
66 | /* FDT_ERR_BADSTRUCTURE: Given device tree has a corrupt |
67 | * structure block or other serious error (e.g. misnested |
68 | * nodes, or subnodes preceding properties). */ |
69 | #define FDT_ERR_BADLAYOUT 12 |
70 | /* FDT_ERR_BADLAYOUT: For read-write functions, the given |
71 | * device tree has it's sub-blocks in an order that the |
72 | * function can't handle (memory reserve map, then structure, |
73 | * then strings). Use fdt_open_into() to reorganize the tree |
74 | * into a form suitable for the read-write operations. */ |
75 | |
76 | /* "Can't happen" error indicating a bug in libfdt */ |
77 | #define FDT_ERR_INTERNAL 13 |
78 | /* FDT_ERR_INTERNAL: libfdt has failed an internal assertion. |
79 | * Should never be returned, if it is, it indicates a bug in |
80 | * libfdt itself. */ |
81 | |
82 | /* Errors in device tree content */ |
83 | #define FDT_ERR_BADNCELLS 14 |
84 | /* FDT_ERR_BADNCELLS: Device tree has a #address-cells, #size-cells |
85 | * or similar property with a bad format or value */ |
86 | |
87 | #define FDT_ERR_BADVALUE 15 |
88 | /* FDT_ERR_BADVALUE: Device tree has a property with an unexpected |
89 | * value. For example: a property expected to contain a string list |
90 | * is not NUL-terminated within the length of its value. */ |
91 | |
92 | #define FDT_ERR_BADOVERLAY 16 |
93 | /* FDT_ERR_BADOVERLAY: The device tree overlay, while |
94 | * correctly structured, cannot be applied due to some |
95 | * unexpected or missing value, property or node. */ |
96 | |
97 | #define FDT_ERR_NOPHANDLES 17 |
98 | /* FDT_ERR_NOPHANDLES: The device tree doesn't have any |
99 | * phandle available anymore without causing an overflow */ |
100 | |
101 | #define FDT_ERR_BADFLAGS 18 |
102 | /* FDT_ERR_BADFLAGS: The function was passed a flags field that |
103 | * contains invalid flags or an invalid combination of flags. */ |
104 | |
105 | #define FDT_ERR_ALIGNMENT 19 |
106 | /* FDT_ERR_ALIGNMENT: The device tree base address is not 8-byte |
107 | * aligned. */ |
108 | |
109 | #define FDT_ERR_MAX 19 |
110 | |
111 | /* constants */ |
112 | #define FDT_MAX_PHANDLE 0xfffffffe |
113 | /* Valid values for phandles range from 1 to 2^32-2. */ |
114 | |
115 | /**********************************************************************/ |
116 | /* Low-level functions (you probably don't need these) */ |
117 | /**********************************************************************/ |
118 | |
119 | #ifndef SWIG /* This function is not useful in Python */ |
120 | const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int checklen); |
121 | #endif |
122 | static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen) |
123 | { |
124 | return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen); |
125 | } |
126 | |
127 | uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset); |
128 | |
129 | /* |
130 | * External helpers to access words from a device tree blob. They're built |
131 | * to work even with unaligned pointers on platforms (such as ARMv5) that don't |
132 | * like unaligned loads and stores. |
133 | */ |
134 | static inline uint16_t fdt16_ld(const fdt16_t *p) |
135 | { |
136 | const uint8_t *bp = (const uint8_t *)p; |
137 | |
138 | return ((uint16_t)bp[0] << 8) | bp[1]; |
139 | } |
140 | |
141 | static inline uint32_t fdt32_ld(const fdt32_t *p) |
142 | { |
143 | const uint8_t *bp = (const uint8_t *)p; |
144 | |
145 | return ((uint32_t)bp[0] << 24) |
146 | | ((uint32_t)bp[1] << 16) |
147 | | ((uint32_t)bp[2] << 8) |
148 | | bp[3]; |
149 | } |
150 | |
151 | static inline void fdt32_st(void *property, uint32_t value) |
152 | { |
153 | uint8_t *bp = (uint8_t *)property; |
154 | |
155 | bp[0] = value >> 24; |
156 | bp[1] = (value >> 16) & 0xff; |
157 | bp[2] = (value >> 8) & 0xff; |
158 | bp[3] = value & 0xff; |
159 | } |
160 | |
161 | static inline uint64_t fdt64_ld(const fdt64_t *p) |
162 | { |
163 | const uint8_t *bp = (const uint8_t *)p; |
164 | |
165 | return ((uint64_t)bp[0] << 56) |
166 | | ((uint64_t)bp[1] << 48) |
167 | | ((uint64_t)bp[2] << 40) |
168 | | ((uint64_t)bp[3] << 32) |
169 | | ((uint64_t)bp[4] << 24) |
170 | | ((uint64_t)bp[5] << 16) |
171 | | ((uint64_t)bp[6] << 8) |
172 | | bp[7]; |
173 | } |
174 | |
175 | static inline void fdt64_st(void *property, uint64_t value) |
176 | { |
177 | uint8_t *bp = (uint8_t *)property; |
178 | |
179 | bp[0] = value >> 56; |
180 | bp[1] = (value >> 48) & 0xff; |
181 | bp[2] = (value >> 40) & 0xff; |
182 | bp[3] = (value >> 32) & 0xff; |
183 | bp[4] = (value >> 24) & 0xff; |
184 | bp[5] = (value >> 16) & 0xff; |
185 | bp[6] = (value >> 8) & 0xff; |
186 | bp[7] = value & 0xff; |
187 | } |
188 | |
189 | /**********************************************************************/ |
190 | /* Traversal functions */ |
191 | /**********************************************************************/ |
192 | |
193 | int fdt_next_node(const void *fdt, int offset, int *depth); |
194 | |
195 | /** |
196 | * fdt_first_subnode() - get offset of first direct subnode |
197 | * @fdt: FDT blob |
198 | * @offset: Offset of node to check |
199 | * |
200 | * Return: offset of first subnode, or -FDT_ERR_NOTFOUND if there is none |
201 | */ |
202 | int fdt_first_subnode(const void *fdt, int offset); |
203 | |
204 | /** |
205 | * fdt_next_subnode() - get offset of next direct subnode |
206 | * @fdt: FDT blob |
207 | * @offset: Offset of previous subnode |
208 | * |
209 | * After first calling fdt_first_subnode(), call this function repeatedly to |
210 | * get direct subnodes of a parent node. |
211 | * |
212 | * Return: offset of next subnode, or -FDT_ERR_NOTFOUND if there are no more |
213 | * subnodes |
214 | */ |
215 | int fdt_next_subnode(const void *fdt, int offset); |
216 | |
217 | /** |
218 | * fdt_for_each_subnode - iterate over all subnodes of a parent |
219 | * |
220 | * @node: child node (int, lvalue) |
221 | * @fdt: FDT blob (const void *) |
222 | * @parent: parent node (int) |
223 | * |
224 | * This is actually a wrapper around a for loop and would be used like so: |
225 | * |
226 | * fdt_for_each_subnode(node, fdt, parent) { |
227 | * Use node |
228 | * ... |
229 | * } |
230 | * |
231 | * if ((node < 0) && (node != -FDT_ERR_NOTFOUND)) { |
232 | * Error handling |
233 | * } |
234 | * |
235 | * Note that this is implemented as a macro and @node is used as |
236 | * iterator in the loop. The parent variable be constant or even a |
237 | * literal. |
238 | */ |
239 | #define fdt_for_each_subnode(node, fdt, parent) \ |
240 | for (node = fdt_first_subnode(fdt, parent); \ |
241 | node >= 0; \ |
242 | node = fdt_next_subnode(fdt, node)) |
243 | |
244 | /**********************************************************************/ |
245 | /* General functions */ |
246 | /**********************************************************************/ |
247 | #define (fdt, field) \ |
248 | (fdt32_ld(&((const struct fdt_header *)(fdt))->field)) |
249 | #define fdt_magic(fdt) (fdt_get_header(fdt, magic)) |
250 | #define fdt_totalsize(fdt) (fdt_get_header(fdt, totalsize)) |
251 | #define fdt_off_dt_struct(fdt) (fdt_get_header(fdt, off_dt_struct)) |
252 | #define fdt_off_dt_strings(fdt) (fdt_get_header(fdt, off_dt_strings)) |
253 | #define fdt_off_mem_rsvmap(fdt) (fdt_get_header(fdt, off_mem_rsvmap)) |
254 | #define fdt_version(fdt) (fdt_get_header(fdt, version)) |
255 | #define fdt_last_comp_version(fdt) (fdt_get_header(fdt, last_comp_version)) |
256 | #define fdt_boot_cpuid_phys(fdt) (fdt_get_header(fdt, boot_cpuid_phys)) |
257 | #define fdt_size_dt_strings(fdt) (fdt_get_header(fdt, size_dt_strings)) |
258 | #define fdt_size_dt_struct(fdt) (fdt_get_header(fdt, size_dt_struct)) |
259 | |
260 | #define fdt_set_hdr_(name) \ |
261 | static inline void fdt_set_##name(void *fdt, uint32_t val) \ |
262 | { \ |
263 | struct fdt_header *fdth = (struct fdt_header *)fdt; \ |
264 | fdth->name = cpu_to_fdt32(val); \ |
265 | } |
266 | fdt_set_hdr_(magic); |
267 | fdt_set_hdr_(totalsize); |
268 | fdt_set_hdr_(off_dt_struct); |
269 | fdt_set_hdr_(off_dt_strings); |
270 | fdt_set_hdr_(off_mem_rsvmap); |
271 | fdt_set_hdr_(version); |
272 | fdt_set_hdr_(last_comp_version); |
273 | fdt_set_hdr_(boot_cpuid_phys); |
274 | fdt_set_hdr_(size_dt_strings); |
275 | fdt_set_hdr_(size_dt_struct); |
276 | #undef fdt_set_hdr_ |
277 | |
278 | /** |
279 | * fdt_header_size - return the size of the tree's header |
280 | * @fdt: pointer to a flattened device tree |
281 | * |
282 | * Return: size of DTB header in bytes |
283 | */ |
284 | size_t (const void *fdt); |
285 | |
286 | /** |
287 | * fdt_header_size_ - internal function to get header size from a version number |
288 | * @version: devicetree version number |
289 | * |
290 | * Return: size of DTB header in bytes |
291 | */ |
292 | size_t (uint32_t version); |
293 | |
294 | /** |
295 | * fdt_check_header - sanity check a device tree header |
296 | * @fdt: pointer to data which might be a flattened device tree |
297 | * |
298 | * fdt_check_header() checks that the given buffer contains what |
299 | * appears to be a flattened device tree, and that the header contains |
300 | * valid information (to the extent that can be determined from the |
301 | * header alone). |
302 | * |
303 | * returns: |
304 | * 0, if the buffer appears to contain a valid device tree |
305 | * -FDT_ERR_BADMAGIC, |
306 | * -FDT_ERR_BADVERSION, |
307 | * -FDT_ERR_BADSTATE, |
308 | * -FDT_ERR_TRUNCATED, standard meanings, as above |
309 | */ |
310 | int (const void *fdt); |
311 | |
312 | /** |
313 | * fdt_move - move a device tree around in memory |
314 | * @fdt: pointer to the device tree to move |
315 | * @buf: pointer to memory where the device is to be moved |
316 | * @bufsize: size of the memory space at buf |
317 | * |
318 | * fdt_move() relocates, if possible, the device tree blob located at |
319 | * fdt to the buffer at buf of size bufsize. The buffer may overlap |
320 | * with the existing device tree blob at fdt. Therefore, |
321 | * fdt_move(fdt, fdt, fdt_totalsize(fdt)) |
322 | * should always succeed. |
323 | * |
324 | * returns: |
325 | * 0, on success |
326 | * -FDT_ERR_NOSPACE, bufsize is insufficient to contain the device tree |
327 | * -FDT_ERR_BADMAGIC, |
328 | * -FDT_ERR_BADVERSION, |
329 | * -FDT_ERR_BADSTATE, standard meanings |
330 | */ |
331 | int fdt_move(const void *fdt, void *buf, int bufsize); |
332 | |
333 | /**********************************************************************/ |
334 | /* Read-only functions */ |
335 | /**********************************************************************/ |
336 | |
337 | int fdt_check_full(const void *fdt, size_t bufsize); |
338 | |
339 | /** |
340 | * fdt_get_string - retrieve a string from the strings block of a device tree |
341 | * @fdt: pointer to the device tree blob |
342 | * @stroffset: offset of the string within the strings block (native endian) |
343 | * @lenp: optional pointer to return the string's length |
344 | * |
345 | * fdt_get_string() retrieves a pointer to a single string from the |
346 | * strings block of the device tree blob at fdt, and optionally also |
347 | * returns the string's length in *lenp. |
348 | * |
349 | * returns: |
350 | * a pointer to the string, on success |
351 | * NULL, if stroffset is out of bounds, or doesn't point to a valid string |
352 | */ |
353 | const char *fdt_get_string(const void *fdt, int stroffset, int *lenp); |
354 | |
355 | /** |
356 | * fdt_string - retrieve a string from the strings block of a device tree |
357 | * @fdt: pointer to the device tree blob |
358 | * @stroffset: offset of the string within the strings block (native endian) |
359 | * |
360 | * fdt_string() retrieves a pointer to a single string from the |
361 | * strings block of the device tree blob at fdt. |
362 | * |
363 | * returns: |
364 | * a pointer to the string, on success |
365 | * NULL, if stroffset is out of bounds, or doesn't point to a valid string |
366 | */ |
367 | const char *fdt_string(const void *fdt, int stroffset); |
368 | |
369 | /** |
370 | * fdt_find_max_phandle - find and return the highest phandle in a tree |
371 | * @fdt: pointer to the device tree blob |
372 | * @phandle: return location for the highest phandle value found in the tree |
373 | * |
374 | * fdt_find_max_phandle() finds the highest phandle value in the given device |
375 | * tree. The value returned in @phandle is only valid if the function returns |
376 | * success. |
377 | * |
378 | * returns: |
379 | * 0 on success or a negative error code on failure |
380 | */ |
381 | int fdt_find_max_phandle(const void *fdt, uint32_t *phandle); |
382 | |
383 | /** |
384 | * fdt_get_max_phandle - retrieves the highest phandle in a tree |
385 | * @fdt: pointer to the device tree blob |
386 | * |
387 | * fdt_get_max_phandle retrieves the highest phandle in the given |
388 | * device tree. This will ignore badly formatted phandles, or phandles |
389 | * with a value of 0 or -1. |
390 | * |
391 | * This function is deprecated in favour of fdt_find_max_phandle(). |
392 | * |
393 | * returns: |
394 | * the highest phandle on success |
395 | * 0, if no phandle was found in the device tree |
396 | * -1, if an error occurred |
397 | */ |
398 | static inline uint32_t fdt_get_max_phandle(const void *fdt) |
399 | { |
400 | uint32_t phandle; |
401 | int err; |
402 | |
403 | err = fdt_find_max_phandle(fdt, phandle: &phandle); |
404 | if (err < 0) |
405 | return (uint32_t)-1; |
406 | |
407 | return phandle; |
408 | } |
409 | |
410 | /** |
411 | * fdt_generate_phandle - return a new, unused phandle for a device tree blob |
412 | * @fdt: pointer to the device tree blob |
413 | * @phandle: return location for the new phandle |
414 | * |
415 | * Walks the device tree blob and looks for the highest phandle value. On |
416 | * success, the new, unused phandle value (one higher than the previously |
417 | * highest phandle value in the device tree blob) will be returned in the |
418 | * @phandle parameter. |
419 | * |
420 | * Return: 0 on success or a negative error-code on failure |
421 | */ |
422 | int fdt_generate_phandle(const void *fdt, uint32_t *phandle); |
423 | |
424 | /** |
425 | * fdt_num_mem_rsv - retrieve the number of memory reserve map entries |
426 | * @fdt: pointer to the device tree blob |
427 | * |
428 | * Returns the number of entries in the device tree blob's memory |
429 | * reservation map. This does not include the terminating 0,0 entry |
430 | * or any other (0,0) entries reserved for expansion. |
431 | * |
432 | * returns: |
433 | * the number of entries |
434 | */ |
435 | int fdt_num_mem_rsv(const void *fdt); |
436 | |
437 | /** |
438 | * fdt_get_mem_rsv - retrieve one memory reserve map entry |
439 | * @fdt: pointer to the device tree blob |
440 | * @n: index of reserve map entry |
441 | * @address: pointer to 64-bit variable to hold the start address |
442 | * @size: pointer to 64-bit variable to hold the size of the entry |
443 | * |
444 | * On success, @address and @size will contain the address and size of |
445 | * the n-th reserve map entry from the device tree blob, in |
446 | * native-endian format. |
447 | * |
448 | * returns: |
449 | * 0, on success |
450 | * -FDT_ERR_BADMAGIC, |
451 | * -FDT_ERR_BADVERSION, |
452 | * -FDT_ERR_BADSTATE, standard meanings |
453 | */ |
454 | int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size); |
455 | |
456 | /** |
457 | * fdt_subnode_offset_namelen - find a subnode based on substring |
458 | * @fdt: pointer to the device tree blob |
459 | * @parentoffset: structure block offset of a node |
460 | * @name: name of the subnode to locate |
461 | * @namelen: number of characters of name to consider |
462 | * |
463 | * Identical to fdt_subnode_offset(), but only examine the first |
464 | * namelen characters of name for matching the subnode name. This is |
465 | * useful for finding subnodes based on a portion of a larger string, |
466 | * such as a full path. |
467 | * |
468 | * Return: offset of the subnode or -FDT_ERR_NOTFOUND if name not found. |
469 | */ |
470 | #ifndef SWIG /* Not available in Python */ |
471 | int fdt_subnode_offset_namelen(const void *fdt, int parentoffset, |
472 | const char *name, int namelen); |
473 | #endif |
474 | /** |
475 | * fdt_subnode_offset - find a subnode of a given node |
476 | * @fdt: pointer to the device tree blob |
477 | * @parentoffset: structure block offset of a node |
478 | * @name: name of the subnode to locate |
479 | * |
480 | * fdt_subnode_offset() finds a subnode of the node at structure block |
481 | * offset parentoffset with the given name. name may include a unit |
482 | * address, in which case fdt_subnode_offset() will find the subnode |
483 | * with that unit address, or the unit address may be omitted, in |
484 | * which case fdt_subnode_offset() will find an arbitrary subnode |
485 | * whose name excluding unit address matches the given name. |
486 | * |
487 | * returns: |
488 | * structure block offset of the requested subnode (>=0), on success |
489 | * -FDT_ERR_NOTFOUND, if the requested subnode does not exist |
490 | * -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE |
491 | * tag |
492 | * -FDT_ERR_BADMAGIC, |
493 | * -FDT_ERR_BADVERSION, |
494 | * -FDT_ERR_BADSTATE, |
495 | * -FDT_ERR_BADSTRUCTURE, |
496 | * -FDT_ERR_TRUNCATED, standard meanings. |
497 | */ |
498 | int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name); |
499 | |
500 | /** |
501 | * fdt_path_offset_namelen - find a tree node by its full path |
502 | * @fdt: pointer to the device tree blob |
503 | * @path: full path of the node to locate |
504 | * @namelen: number of characters of path to consider |
505 | * |
506 | * Identical to fdt_path_offset(), but only consider the first namelen |
507 | * characters of path as the path name. |
508 | * |
509 | * Return: offset of the node or negative libfdt error value otherwise |
510 | */ |
511 | #ifndef SWIG /* Not available in Python */ |
512 | int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen); |
513 | #endif |
514 | |
515 | /** |
516 | * fdt_path_offset - find a tree node by its full path |
517 | * @fdt: pointer to the device tree blob |
518 | * @path: full path of the node to locate |
519 | * |
520 | * fdt_path_offset() finds a node of a given path in the device tree. |
521 | * Each path component may omit the unit address portion, but the |
522 | * results of this are undefined if any such path component is |
523 | * ambiguous (that is if there are multiple nodes at the relevant |
524 | * level matching the given component, differentiated only by unit |
525 | * address). |
526 | * |
527 | * returns: |
528 | * structure block offset of the node with the requested path (>=0), on |
529 | * success |
530 | * -FDT_ERR_BADPATH, given path does not begin with '/' or is invalid |
531 | * -FDT_ERR_NOTFOUND, if the requested node does not exist |
532 | * -FDT_ERR_BADMAGIC, |
533 | * -FDT_ERR_BADVERSION, |
534 | * -FDT_ERR_BADSTATE, |
535 | * -FDT_ERR_BADSTRUCTURE, |
536 | * -FDT_ERR_TRUNCATED, standard meanings. |
537 | */ |
538 | int fdt_path_offset(const void *fdt, const char *path); |
539 | |
540 | /** |
541 | * fdt_get_name - retrieve the name of a given node |
542 | * @fdt: pointer to the device tree blob |
543 | * @nodeoffset: structure block offset of the starting node |
544 | * @lenp: pointer to an integer variable (will be overwritten) or NULL |
545 | * |
546 | * fdt_get_name() retrieves the name (including unit address) of the |
547 | * device tree node at structure block offset nodeoffset. If lenp is |
548 | * non-NULL, the length of this name is also returned, in the integer |
549 | * pointed to by lenp. |
550 | * |
551 | * returns: |
552 | * pointer to the node's name, on success |
553 | * If lenp is non-NULL, *lenp contains the length of that name |
554 | * (>=0) |
555 | * NULL, on error |
556 | * if lenp is non-NULL *lenp contains an error code (<0): |
557 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE |
558 | * tag |
559 | * -FDT_ERR_BADMAGIC, |
560 | * -FDT_ERR_BADVERSION, |
561 | * -FDT_ERR_BADSTATE, standard meanings |
562 | */ |
563 | const char *fdt_get_name(const void *fdt, int nodeoffset, int *lenp); |
564 | |
565 | /** |
566 | * fdt_first_property_offset - find the offset of a node's first property |
567 | * @fdt: pointer to the device tree blob |
568 | * @nodeoffset: structure block offset of a node |
569 | * |
570 | * fdt_first_property_offset() finds the first property of the node at |
571 | * the given structure block offset. |
572 | * |
573 | * returns: |
574 | * structure block offset of the property (>=0), on success |
575 | * -FDT_ERR_NOTFOUND, if the requested node has no properties |
576 | * -FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_BEGIN_NODE tag |
577 | * -FDT_ERR_BADMAGIC, |
578 | * -FDT_ERR_BADVERSION, |
579 | * -FDT_ERR_BADSTATE, |
580 | * -FDT_ERR_BADSTRUCTURE, |
581 | * -FDT_ERR_TRUNCATED, standard meanings. |
582 | */ |
583 | int fdt_first_property_offset(const void *fdt, int nodeoffset); |
584 | |
585 | /** |
586 | * fdt_next_property_offset - step through a node's properties |
587 | * @fdt: pointer to the device tree blob |
588 | * @offset: structure block offset of a property |
589 | * |
590 | * fdt_next_property_offset() finds the property immediately after the |
591 | * one at the given structure block offset. This will be a property |
592 | * of the same node as the given property. |
593 | * |
594 | * returns: |
595 | * structure block offset of the next property (>=0), on success |
596 | * -FDT_ERR_NOTFOUND, if the given property is the last in its node |
597 | * -FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_PROP tag |
598 | * -FDT_ERR_BADMAGIC, |
599 | * -FDT_ERR_BADVERSION, |
600 | * -FDT_ERR_BADSTATE, |
601 | * -FDT_ERR_BADSTRUCTURE, |
602 | * -FDT_ERR_TRUNCATED, standard meanings. |
603 | */ |
604 | int fdt_next_property_offset(const void *fdt, int offset); |
605 | |
606 | /** |
607 | * fdt_for_each_property_offset - iterate over all properties of a node |
608 | * |
609 | * @property: property offset (int, lvalue) |
610 | * @fdt: FDT blob (const void *) |
611 | * @node: node offset (int) |
612 | * |
613 | * This is actually a wrapper around a for loop and would be used like so: |
614 | * |
615 | * fdt_for_each_property_offset(property, fdt, node) { |
616 | * Use property |
617 | * ... |
618 | * } |
619 | * |
620 | * if ((property < 0) && (property != -FDT_ERR_NOTFOUND)) { |
621 | * Error handling |
622 | * } |
623 | * |
624 | * Note that this is implemented as a macro and property is used as |
625 | * iterator in the loop. The node variable can be constant or even a |
626 | * literal. |
627 | */ |
628 | #define fdt_for_each_property_offset(property, fdt, node) \ |
629 | for (property = fdt_first_property_offset(fdt, node); \ |
630 | property >= 0; \ |
631 | property = fdt_next_property_offset(fdt, property)) |
632 | |
633 | /** |
634 | * fdt_get_property_by_offset - retrieve the property at a given offset |
635 | * @fdt: pointer to the device tree blob |
636 | * @offset: offset of the property to retrieve |
637 | * @lenp: pointer to an integer variable (will be overwritten) or NULL |
638 | * |
639 | * fdt_get_property_by_offset() retrieves a pointer to the |
640 | * fdt_property structure within the device tree blob at the given |
641 | * offset. If lenp is non-NULL, the length of the property value is |
642 | * also returned, in the integer pointed to by lenp. |
643 | * |
644 | * Note that this code only works on device tree versions >= 16. fdt_getprop() |
645 | * works on all versions. |
646 | * |
647 | * returns: |
648 | * pointer to the structure representing the property |
649 | * if lenp is non-NULL, *lenp contains the length of the property |
650 | * value (>=0) |
651 | * NULL, on error |
652 | * if lenp is non-NULL, *lenp contains an error code (<0): |
653 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag |
654 | * -FDT_ERR_BADMAGIC, |
655 | * -FDT_ERR_BADVERSION, |
656 | * -FDT_ERR_BADSTATE, |
657 | * -FDT_ERR_BADSTRUCTURE, |
658 | * -FDT_ERR_TRUNCATED, standard meanings |
659 | */ |
660 | const struct fdt_property *fdt_get_property_by_offset(const void *fdt, |
661 | int offset, |
662 | int *lenp); |
663 | static inline struct fdt_property *fdt_get_property_by_offset_w(void *fdt, |
664 | int offset, |
665 | int *lenp) |
666 | { |
667 | return (struct fdt_property *)(uintptr_t) |
668 | fdt_get_property_by_offset(fdt, offset, lenp); |
669 | } |
670 | |
671 | /** |
672 | * fdt_get_property_namelen - find a property based on substring |
673 | * @fdt: pointer to the device tree blob |
674 | * @nodeoffset: offset of the node whose property to find |
675 | * @name: name of the property to find |
676 | * @namelen: number of characters of name to consider |
677 | * @lenp: pointer to an integer variable (will be overwritten) or NULL |
678 | * |
679 | * Identical to fdt_get_property(), but only examine the first namelen |
680 | * characters of name for matching the property name. |
681 | * |
682 | * Return: pointer to the structure representing the property, or NULL |
683 | * if not found |
684 | */ |
685 | #ifndef SWIG /* Not available in Python */ |
686 | const struct fdt_property *fdt_get_property_namelen(const void *fdt, |
687 | int nodeoffset, |
688 | const char *name, |
689 | int namelen, int *lenp); |
690 | #endif |
691 | |
692 | /** |
693 | * fdt_get_property - find a given property in a given node |
694 | * @fdt: pointer to the device tree blob |
695 | * @nodeoffset: offset of the node whose property to find |
696 | * @name: name of the property to find |
697 | * @lenp: pointer to an integer variable (will be overwritten) or NULL |
698 | * |
699 | * fdt_get_property() retrieves a pointer to the fdt_property |
700 | * structure within the device tree blob corresponding to the property |
701 | * named 'name' of the node at offset nodeoffset. If lenp is |
702 | * non-NULL, the length of the property value is also returned, in the |
703 | * integer pointed to by lenp. |
704 | * |
705 | * returns: |
706 | * pointer to the structure representing the property |
707 | * if lenp is non-NULL, *lenp contains the length of the property |
708 | * value (>=0) |
709 | * NULL, on error |
710 | * if lenp is non-NULL, *lenp contains an error code (<0): |
711 | * -FDT_ERR_NOTFOUND, node does not have named property |
712 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE |
713 | * tag |
714 | * -FDT_ERR_BADMAGIC, |
715 | * -FDT_ERR_BADVERSION, |
716 | * -FDT_ERR_BADSTATE, |
717 | * -FDT_ERR_BADSTRUCTURE, |
718 | * -FDT_ERR_TRUNCATED, standard meanings |
719 | */ |
720 | const struct fdt_property *fdt_get_property(const void *fdt, int nodeoffset, |
721 | const char *name, int *lenp); |
722 | static inline struct fdt_property *fdt_get_property_w(void *fdt, int nodeoffset, |
723 | const char *name, |
724 | int *lenp) |
725 | { |
726 | return (struct fdt_property *)(uintptr_t) |
727 | fdt_get_property(fdt, nodeoffset, name, lenp); |
728 | } |
729 | |
730 | /** |
731 | * fdt_getprop_by_offset - retrieve the value of a property at a given offset |
732 | * @fdt: pointer to the device tree blob |
733 | * @offset: offset of the property to read |
734 | * @namep: pointer to a string variable (will be overwritten) or NULL |
735 | * @lenp: pointer to an integer variable (will be overwritten) or NULL |
736 | * |
737 | * fdt_getprop_by_offset() retrieves a pointer to the value of the |
738 | * property at structure block offset 'offset' (this will be a pointer |
739 | * to within the device blob itself, not a copy of the value). If |
740 | * lenp is non-NULL, the length of the property value is also |
741 | * returned, in the integer pointed to by lenp. If namep is non-NULL, |
742 | * the property's namne will also be returned in the char * pointed to |
743 | * by namep (this will be a pointer to within the device tree's string |
744 | * block, not a new copy of the name). |
745 | * |
746 | * returns: |
747 | * pointer to the property's value |
748 | * if lenp is non-NULL, *lenp contains the length of the property |
749 | * value (>=0) |
750 | * if namep is non-NULL *namep contiains a pointer to the property |
751 | * name. |
752 | * NULL, on error |
753 | * if lenp is non-NULL, *lenp contains an error code (<0): |
754 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag |
755 | * -FDT_ERR_BADMAGIC, |
756 | * -FDT_ERR_BADVERSION, |
757 | * -FDT_ERR_BADSTATE, |
758 | * -FDT_ERR_BADSTRUCTURE, |
759 | * -FDT_ERR_TRUNCATED, standard meanings |
760 | */ |
761 | #ifndef SWIG /* This function is not useful in Python */ |
762 | const void *fdt_getprop_by_offset(const void *fdt, int offset, |
763 | const char **namep, int *lenp); |
764 | #endif |
765 | |
766 | /** |
767 | * fdt_getprop_namelen - get property value based on substring |
768 | * @fdt: pointer to the device tree blob |
769 | * @nodeoffset: offset of the node whose property to find |
770 | * @name: name of the property to find |
771 | * @namelen: number of characters of name to consider |
772 | * @lenp: pointer to an integer variable (will be overwritten) or NULL |
773 | * |
774 | * Identical to fdt_getprop(), but only examine the first namelen |
775 | * characters of name for matching the property name. |
776 | * |
777 | * Return: pointer to the property's value or NULL on error |
778 | */ |
779 | #ifndef SWIG /* Not available in Python */ |
780 | const void *fdt_getprop_namelen(const void *fdt, int nodeoffset, |
781 | const char *name, int namelen, int *lenp); |
782 | static inline void *fdt_getprop_namelen_w(void *fdt, int nodeoffset, |
783 | const char *name, int namelen, |
784 | int *lenp) |
785 | { |
786 | return (void *)(uintptr_t)fdt_getprop_namelen(fdt, nodeoffset, name, |
787 | namelen, lenp); |
788 | } |
789 | #endif |
790 | |
791 | /** |
792 | * fdt_getprop - retrieve the value of a given property |
793 | * @fdt: pointer to the device tree blob |
794 | * @nodeoffset: offset of the node whose property to find |
795 | * @name: name of the property to find |
796 | * @lenp: pointer to an integer variable (will be overwritten) or NULL |
797 | * |
798 | * fdt_getprop() retrieves a pointer to the value of the property |
799 | * named @name of the node at offset @nodeoffset (this will be a |
800 | * pointer to within the device blob itself, not a copy of the value). |
801 | * If @lenp is non-NULL, the length of the property value is also |
802 | * returned, in the integer pointed to by @lenp. |
803 | * |
804 | * returns: |
805 | * pointer to the property's value |
806 | * if lenp is non-NULL, *lenp contains the length of the property |
807 | * value (>=0) |
808 | * NULL, on error |
809 | * if lenp is non-NULL, *lenp contains an error code (<0): |
810 | * -FDT_ERR_NOTFOUND, node does not have named property |
811 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE |
812 | * tag |
813 | * -FDT_ERR_BADMAGIC, |
814 | * -FDT_ERR_BADVERSION, |
815 | * -FDT_ERR_BADSTATE, |
816 | * -FDT_ERR_BADSTRUCTURE, |
817 | * -FDT_ERR_TRUNCATED, standard meanings |
818 | */ |
819 | const void *fdt_getprop(const void *fdt, int nodeoffset, |
820 | const char *name, int *lenp); |
821 | static inline void *fdt_getprop_w(void *fdt, int nodeoffset, |
822 | const char *name, int *lenp) |
823 | { |
824 | return (void *)(uintptr_t)fdt_getprop(fdt, nodeoffset, name, lenp); |
825 | } |
826 | |
827 | /** |
828 | * fdt_get_phandle - retrieve the phandle of a given node |
829 | * @fdt: pointer to the device tree blob |
830 | * @nodeoffset: structure block offset of the node |
831 | * |
832 | * fdt_get_phandle() retrieves the phandle of the device tree node at |
833 | * structure block offset nodeoffset. |
834 | * |
835 | * returns: |
836 | * the phandle of the node at nodeoffset, on success (!= 0, != -1) |
837 | * 0, if the node has no phandle, or another error occurs |
838 | */ |
839 | uint32_t fdt_get_phandle(const void *fdt, int nodeoffset); |
840 | |
841 | /** |
842 | * fdt_get_alias_namelen - get alias based on substring |
843 | * @fdt: pointer to the device tree blob |
844 | * @name: name of the alias th look up |
845 | * @namelen: number of characters of name to consider |
846 | * |
847 | * Identical to fdt_get_alias(), but only examine the first @namelen |
848 | * characters of @name for matching the alias name. |
849 | * |
850 | * Return: a pointer to the expansion of the alias named @name, if it exists, |
851 | * NULL otherwise |
852 | */ |
853 | #ifndef SWIG /* Not available in Python */ |
854 | const char *fdt_get_alias_namelen(const void *fdt, |
855 | const char *name, int namelen); |
856 | #endif |
857 | |
858 | /** |
859 | * fdt_get_alias - retrieve the path referenced by a given alias |
860 | * @fdt: pointer to the device tree blob |
861 | * @name: name of the alias th look up |
862 | * |
863 | * fdt_get_alias() retrieves the value of a given alias. That is, the |
864 | * value of the property named @name in the node /aliases. |
865 | * |
866 | * returns: |
867 | * a pointer to the expansion of the alias named 'name', if it exists |
868 | * NULL, if the given alias or the /aliases node does not exist |
869 | */ |
870 | const char *fdt_get_alias(const void *fdt, const char *name); |
871 | |
872 | /** |
873 | * fdt_get_path - determine the full path of a node |
874 | * @fdt: pointer to the device tree blob |
875 | * @nodeoffset: offset of the node whose path to find |
876 | * @buf: character buffer to contain the returned path (will be overwritten) |
877 | * @buflen: size of the character buffer at buf |
878 | * |
879 | * fdt_get_path() computes the full path of the node at offset |
880 | * nodeoffset, and records that path in the buffer at buf. |
881 | * |
882 | * NOTE: This function is expensive, as it must scan the device tree |
883 | * structure from the start to nodeoffset. |
884 | * |
885 | * returns: |
886 | * 0, on success |
887 | * buf contains the absolute path of the node at |
888 | * nodeoffset, as a NUL-terminated string. |
889 | * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag |
890 | * -FDT_ERR_NOSPACE, the path of the given node is longer than (bufsize-1) |
891 | * characters and will not fit in the given buffer. |
892 | * -FDT_ERR_BADMAGIC, |
893 | * -FDT_ERR_BADVERSION, |
894 | * -FDT_ERR_BADSTATE, |
895 | * -FDT_ERR_BADSTRUCTURE, standard meanings |
896 | */ |
897 | int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen); |
898 | |
899 | /** |
900 | * fdt_supernode_atdepth_offset - find a specific ancestor of a node |
901 | * @fdt: pointer to the device tree blob |
902 | * @nodeoffset: offset of the node whose parent to find |
903 | * @supernodedepth: depth of the ancestor to find |
904 | * @nodedepth: pointer to an integer variable (will be overwritten) or NULL |
905 | * |
906 | * fdt_supernode_atdepth_offset() finds an ancestor of the given node |
907 | * at a specific depth from the root (where the root itself has depth |
908 | * 0, its immediate subnodes depth 1 and so forth). So |
909 | * fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, NULL); |
910 | * will always return 0, the offset of the root node. If the node at |
911 | * nodeoffset has depth D, then: |
912 | * fdt_supernode_atdepth_offset(fdt, nodeoffset, D, NULL); |
913 | * will return nodeoffset itself. |
914 | * |
915 | * NOTE: This function is expensive, as it must scan the device tree |
916 | * structure from the start to nodeoffset. |
917 | * |
918 | * returns: |
919 | * structure block offset of the node at node offset's ancestor |
920 | * of depth supernodedepth (>=0), on success |
921 | * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag |
922 | * -FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of |
923 | * nodeoffset |
924 | * -FDT_ERR_BADMAGIC, |
925 | * -FDT_ERR_BADVERSION, |
926 | * -FDT_ERR_BADSTATE, |
927 | * -FDT_ERR_BADSTRUCTURE, standard meanings |
928 | */ |
929 | int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset, |
930 | int supernodedepth, int *nodedepth); |
931 | |
932 | /** |
933 | * fdt_node_depth - find the depth of a given node |
934 | * @fdt: pointer to the device tree blob |
935 | * @nodeoffset: offset of the node whose parent to find |
936 | * |
937 | * fdt_node_depth() finds the depth of a given node. The root node |
938 | * has depth 0, its immediate subnodes depth 1 and so forth. |
939 | * |
940 | * NOTE: This function is expensive, as it must scan the device tree |
941 | * structure from the start to nodeoffset. |
942 | * |
943 | * returns: |
944 | * depth of the node at nodeoffset (>=0), on success |
945 | * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag |
946 | * -FDT_ERR_BADMAGIC, |
947 | * -FDT_ERR_BADVERSION, |
948 | * -FDT_ERR_BADSTATE, |
949 | * -FDT_ERR_BADSTRUCTURE, standard meanings |
950 | */ |
951 | int fdt_node_depth(const void *fdt, int nodeoffset); |
952 | |
953 | /** |
954 | * fdt_parent_offset - find the parent of a given node |
955 | * @fdt: pointer to the device tree blob |
956 | * @nodeoffset: offset of the node whose parent to find |
957 | * |
958 | * fdt_parent_offset() locates the parent node of a given node (that |
959 | * is, it finds the offset of the node which contains the node at |
960 | * nodeoffset as a subnode). |
961 | * |
962 | * NOTE: This function is expensive, as it must scan the device tree |
963 | * structure from the start to nodeoffset, *twice*. |
964 | * |
965 | * returns: |
966 | * structure block offset of the parent of the node at nodeoffset |
967 | * (>=0), on success |
968 | * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag |
969 | * -FDT_ERR_BADMAGIC, |
970 | * -FDT_ERR_BADVERSION, |
971 | * -FDT_ERR_BADSTATE, |
972 | * -FDT_ERR_BADSTRUCTURE, standard meanings |
973 | */ |
974 | int fdt_parent_offset(const void *fdt, int nodeoffset); |
975 | |
976 | /** |
977 | * fdt_node_offset_by_prop_value - find nodes with a given property value |
978 | * @fdt: pointer to the device tree blob |
979 | * @startoffset: only find nodes after this offset |
980 | * @propname: property name to check |
981 | * @propval: property value to search for |
982 | * @proplen: length of the value in propval |
983 | * |
984 | * fdt_node_offset_by_prop_value() returns the offset of the first |
985 | * node after startoffset, which has a property named propname whose |
986 | * value is of length proplen and has value equal to propval; or if |
987 | * startoffset is -1, the very first such node in the tree. |
988 | * |
989 | * To iterate through all nodes matching the criterion, the following |
990 | * idiom can be used: |
991 | * offset = fdt_node_offset_by_prop_value(fdt, -1, propname, |
992 | * propval, proplen); |
993 | * while (offset != -FDT_ERR_NOTFOUND) { |
994 | * // other code here |
995 | * offset = fdt_node_offset_by_prop_value(fdt, offset, propname, |
996 | * propval, proplen); |
997 | * } |
998 | * |
999 | * Note the -1 in the first call to the function, if 0 is used here |
1000 | * instead, the function will never locate the root node, even if it |
1001 | * matches the criterion. |
1002 | * |
1003 | * returns: |
1004 | * structure block offset of the located node (>= 0, >startoffset), |
1005 | * on success |
1006 | * -FDT_ERR_NOTFOUND, no node matching the criterion exists in the |
1007 | * tree after startoffset |
1008 | * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag |
1009 | * -FDT_ERR_BADMAGIC, |
1010 | * -FDT_ERR_BADVERSION, |
1011 | * -FDT_ERR_BADSTATE, |
1012 | * -FDT_ERR_BADSTRUCTURE, standard meanings |
1013 | */ |
1014 | int fdt_node_offset_by_prop_value(const void *fdt, int startoffset, |
1015 | const char *propname, |
1016 | const void *propval, int proplen); |
1017 | |
1018 | /** |
1019 | * fdt_node_offset_by_phandle - find the node with a given phandle |
1020 | * @fdt: pointer to the device tree blob |
1021 | * @phandle: phandle value |
1022 | * |
1023 | * fdt_node_offset_by_phandle() returns the offset of the node |
1024 | * which has the given phandle value. If there is more than one node |
1025 | * in the tree with the given phandle (an invalid tree), results are |
1026 | * undefined. |
1027 | * |
1028 | * returns: |
1029 | * structure block offset of the located node (>= 0), on success |
1030 | * -FDT_ERR_NOTFOUND, no node with that phandle exists |
1031 | * -FDT_ERR_BADPHANDLE, given phandle value was invalid (0 or -1) |
1032 | * -FDT_ERR_BADMAGIC, |
1033 | * -FDT_ERR_BADVERSION, |
1034 | * -FDT_ERR_BADSTATE, |
1035 | * -FDT_ERR_BADSTRUCTURE, standard meanings |
1036 | */ |
1037 | int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle); |
1038 | |
1039 | /** |
1040 | * fdt_node_check_compatible - check a node's compatible property |
1041 | * @fdt: pointer to the device tree blob |
1042 | * @nodeoffset: offset of a tree node |
1043 | * @compatible: string to match against |
1044 | * |
1045 | * fdt_node_check_compatible() returns 0 if the given node contains a |
1046 | * @compatible property with the given string as one of its elements, |
1047 | * it returns non-zero otherwise, or on error. |
1048 | * |
1049 | * returns: |
1050 | * 0, if the node has a 'compatible' property listing the given string |
1051 | * 1, if the node has a 'compatible' property, but it does not list |
1052 | * the given string |
1053 | * -FDT_ERR_NOTFOUND, if the given node has no 'compatible' property |
1054 | * -FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag |
1055 | * -FDT_ERR_BADMAGIC, |
1056 | * -FDT_ERR_BADVERSION, |
1057 | * -FDT_ERR_BADSTATE, |
1058 | * -FDT_ERR_BADSTRUCTURE, standard meanings |
1059 | */ |
1060 | int fdt_node_check_compatible(const void *fdt, int nodeoffset, |
1061 | const char *compatible); |
1062 | |
1063 | /** |
1064 | * fdt_node_offset_by_compatible - find nodes with a given 'compatible' value |
1065 | * @fdt: pointer to the device tree blob |
1066 | * @startoffset: only find nodes after this offset |
1067 | * @compatible: 'compatible' string to match against |
1068 | * |
1069 | * fdt_node_offset_by_compatible() returns the offset of the first |
1070 | * node after startoffset, which has a 'compatible' property which |
1071 | * lists the given compatible string; or if startoffset is -1, the |
1072 | * very first such node in the tree. |
1073 | * |
1074 | * To iterate through all nodes matching the criterion, the following |
1075 | * idiom can be used: |
1076 | * offset = fdt_node_offset_by_compatible(fdt, -1, compatible); |
1077 | * while (offset != -FDT_ERR_NOTFOUND) { |
1078 | * // other code here |
1079 | * offset = fdt_node_offset_by_compatible(fdt, offset, compatible); |
1080 | * } |
1081 | * |
1082 | * Note the -1 in the first call to the function, if 0 is used here |
1083 | * instead, the function will never locate the root node, even if it |
1084 | * matches the criterion. |
1085 | * |
1086 | * returns: |
1087 | * structure block offset of the located node (>= 0, >startoffset), |
1088 | * on success |
1089 | * -FDT_ERR_NOTFOUND, no node matching the criterion exists in the |
1090 | * tree after startoffset |
1091 | * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag |
1092 | * -FDT_ERR_BADMAGIC, |
1093 | * -FDT_ERR_BADVERSION, |
1094 | * -FDT_ERR_BADSTATE, |
1095 | * -FDT_ERR_BADSTRUCTURE, standard meanings |
1096 | */ |
1097 | int fdt_node_offset_by_compatible(const void *fdt, int startoffset, |
1098 | const char *compatible); |
1099 | |
1100 | /** |
1101 | * fdt_stringlist_contains - check a string list property for a string |
1102 | * @strlist: Property containing a list of strings to check |
1103 | * @listlen: Length of property |
1104 | * @str: String to search for |
1105 | * |
1106 | * This is a utility function provided for convenience. The list contains |
1107 | * one or more strings, each terminated by \0, as is found in a device tree |
1108 | * "compatible" property. |
1109 | * |
1110 | * Return: 1 if the string is found in the list, 0 not found, or invalid list |
1111 | */ |
1112 | int fdt_stringlist_contains(const char *strlist, int listlen, const char *str); |
1113 | |
1114 | /** |
1115 | * fdt_stringlist_count - count the number of strings in a string list |
1116 | * @fdt: pointer to the device tree blob |
1117 | * @nodeoffset: offset of a tree node |
1118 | * @property: name of the property containing the string list |
1119 | * |
1120 | * Return: |
1121 | * the number of strings in the given property |
1122 | * -FDT_ERR_BADVALUE if the property value is not NUL-terminated |
1123 | * -FDT_ERR_NOTFOUND if the property does not exist |
1124 | */ |
1125 | int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property); |
1126 | |
1127 | /** |
1128 | * fdt_stringlist_search - find a string in a string list and return its index |
1129 | * @fdt: pointer to the device tree blob |
1130 | * @nodeoffset: offset of a tree node |
1131 | * @property: name of the property containing the string list |
1132 | * @string: string to look up in the string list |
1133 | * |
1134 | * Note that it is possible for this function to succeed on property values |
1135 | * that are not NUL-terminated. That's because the function will stop after |
1136 | * finding the first occurrence of @string. This can for example happen with |
1137 | * small-valued cell properties, such as #address-cells, when searching for |
1138 | * the empty string. |
1139 | * |
1140 | * return: |
1141 | * the index of the string in the list of strings |
1142 | * -FDT_ERR_BADVALUE if the property value is not NUL-terminated |
1143 | * -FDT_ERR_NOTFOUND if the property does not exist or does not contain |
1144 | * the given string |
1145 | */ |
1146 | int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property, |
1147 | const char *string); |
1148 | |
1149 | /** |
1150 | * fdt_stringlist_get() - obtain the string at a given index in a string list |
1151 | * @fdt: pointer to the device tree blob |
1152 | * @nodeoffset: offset of a tree node |
1153 | * @property: name of the property containing the string list |
1154 | * @index: index of the string to return |
1155 | * @lenp: return location for the string length or an error code on failure |
1156 | * |
1157 | * Note that this will successfully extract strings from properties with |
1158 | * non-NUL-terminated values. For example on small-valued cell properties |
1159 | * this function will return the empty string. |
1160 | * |
1161 | * If non-NULL, the length of the string (on success) or a negative error-code |
1162 | * (on failure) will be stored in the integer pointer to by lenp. |
1163 | * |
1164 | * Return: |
1165 | * A pointer to the string at the given index in the string list or NULL on |
1166 | * failure. On success the length of the string will be stored in the memory |
1167 | * location pointed to by the lenp parameter, if non-NULL. On failure one of |
1168 | * the following negative error codes will be returned in the lenp parameter |
1169 | * (if non-NULL): |
1170 | * -FDT_ERR_BADVALUE if the property value is not NUL-terminated |
1171 | * -FDT_ERR_NOTFOUND if the property does not exist |
1172 | */ |
1173 | const char *fdt_stringlist_get(const void *fdt, int nodeoffset, |
1174 | const char *property, int index, |
1175 | int *lenp); |
1176 | |
1177 | /**********************************************************************/ |
1178 | /* Read-only functions (addressing related) */ |
1179 | /**********************************************************************/ |
1180 | |
1181 | /** |
1182 | * FDT_MAX_NCELLS - maximum value for #address-cells and #size-cells |
1183 | * |
1184 | * This is the maximum value for #address-cells, #size-cells and |
1185 | * similar properties that will be processed by libfdt. IEE1275 |
1186 | * requires that OF implementations handle values up to 4. |
1187 | * Implementations may support larger values, but in practice higher |
1188 | * values aren't used. |
1189 | */ |
1190 | #define FDT_MAX_NCELLS 4 |
1191 | |
1192 | /** |
1193 | * fdt_address_cells - retrieve address size for a bus represented in the tree |
1194 | * @fdt: pointer to the device tree blob |
1195 | * @nodeoffset: offset of the node to find the address size for |
1196 | * |
1197 | * When the node has a valid #address-cells property, returns its value. |
1198 | * |
1199 | * returns: |
1200 | * 0 <= n < FDT_MAX_NCELLS, on success |
1201 | * 2, if the node has no #address-cells property |
1202 | * -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid |
1203 | * #address-cells property |
1204 | * -FDT_ERR_BADMAGIC, |
1205 | * -FDT_ERR_BADVERSION, |
1206 | * -FDT_ERR_BADSTATE, |
1207 | * -FDT_ERR_BADSTRUCTURE, |
1208 | * -FDT_ERR_TRUNCATED, standard meanings |
1209 | */ |
1210 | int fdt_address_cells(const void *fdt, int nodeoffset); |
1211 | |
1212 | /** |
1213 | * fdt_size_cells - retrieve address range size for a bus represented in the |
1214 | * tree |
1215 | * @fdt: pointer to the device tree blob |
1216 | * @nodeoffset: offset of the node to find the address range size for |
1217 | * |
1218 | * When the node has a valid #size-cells property, returns its value. |
1219 | * |
1220 | * returns: |
1221 | * 0 <= n < FDT_MAX_NCELLS, on success |
1222 | * 1, if the node has no #size-cells property |
1223 | * -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid |
1224 | * #size-cells property |
1225 | * -FDT_ERR_BADMAGIC, |
1226 | * -FDT_ERR_BADVERSION, |
1227 | * -FDT_ERR_BADSTATE, |
1228 | * -FDT_ERR_BADSTRUCTURE, |
1229 | * -FDT_ERR_TRUNCATED, standard meanings |
1230 | */ |
1231 | int fdt_size_cells(const void *fdt, int nodeoffset); |
1232 | |
1233 | |
1234 | /**********************************************************************/ |
1235 | /* Write-in-place functions */ |
1236 | /**********************************************************************/ |
1237 | |
1238 | /** |
1239 | * fdt_setprop_inplace_namelen_partial - change a property's value, |
1240 | * but not its size |
1241 | * @fdt: pointer to the device tree blob |
1242 | * @nodeoffset: offset of the node whose property to change |
1243 | * @name: name of the property to change |
1244 | * @namelen: number of characters of name to consider |
1245 | * @idx: index of the property to change in the array |
1246 | * @val: pointer to data to replace the property value with |
1247 | * @len: length of the property value |
1248 | * |
1249 | * Identical to fdt_setprop_inplace(), but modifies the given property |
1250 | * starting from the given index, and using only the first characters |
1251 | * of the name. It is useful when you want to manipulate only one value of |
1252 | * an array and you have a string that doesn't end with \0. |
1253 | * |
1254 | * Return: 0 on success, negative libfdt error value otherwise |
1255 | */ |
1256 | #ifndef SWIG /* Not available in Python */ |
1257 | int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset, |
1258 | const char *name, int namelen, |
1259 | uint32_t idx, const void *val, |
1260 | int len); |
1261 | #endif |
1262 | |
1263 | /** |
1264 | * fdt_setprop_inplace - change a property's value, but not its size |
1265 | * @fdt: pointer to the device tree blob |
1266 | * @nodeoffset: offset of the node whose property to change |
1267 | * @name: name of the property to change |
1268 | * @val: pointer to data to replace the property value with |
1269 | * @len: length of the property value |
1270 | * |
1271 | * fdt_setprop_inplace() replaces the value of a given property with |
1272 | * the data in val, of length len. This function cannot change the |
1273 | * size of a property, and so will only work if len is equal to the |
1274 | * current length of the property. |
1275 | * |
1276 | * This function will alter only the bytes in the blob which contain |
1277 | * the given property value, and will not alter or move any other part |
1278 | * of the tree. |
1279 | * |
1280 | * returns: |
1281 | * 0, on success |
1282 | * -FDT_ERR_NOSPACE, if len is not equal to the property's current length |
1283 | * -FDT_ERR_NOTFOUND, node does not have the named property |
1284 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1285 | * -FDT_ERR_BADMAGIC, |
1286 | * -FDT_ERR_BADVERSION, |
1287 | * -FDT_ERR_BADSTATE, |
1288 | * -FDT_ERR_BADSTRUCTURE, |
1289 | * -FDT_ERR_TRUNCATED, standard meanings |
1290 | */ |
1291 | #ifndef SWIG /* Not available in Python */ |
1292 | int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name, |
1293 | const void *val, int len); |
1294 | #endif |
1295 | |
1296 | /** |
1297 | * fdt_setprop_inplace_u32 - change the value of a 32-bit integer property |
1298 | * @fdt: pointer to the device tree blob |
1299 | * @nodeoffset: offset of the node whose property to change |
1300 | * @name: name of the property to change |
1301 | * @val: 32-bit integer value to replace the property with |
1302 | * |
1303 | * fdt_setprop_inplace_u32() replaces the value of a given property |
1304 | * with the 32-bit integer value in val, converting val to big-endian |
1305 | * if necessary. This function cannot change the size of a property, |
1306 | * and so will only work if the property already exists and has length |
1307 | * 4. |
1308 | * |
1309 | * This function will alter only the bytes in the blob which contain |
1310 | * the given property value, and will not alter or move any other part |
1311 | * of the tree. |
1312 | * |
1313 | * returns: |
1314 | * 0, on success |
1315 | * -FDT_ERR_NOSPACE, if the property's length is not equal to 4 |
1316 | * -FDT_ERR_NOTFOUND, node does not have the named property |
1317 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1318 | * -FDT_ERR_BADMAGIC, |
1319 | * -FDT_ERR_BADVERSION, |
1320 | * -FDT_ERR_BADSTATE, |
1321 | * -FDT_ERR_BADSTRUCTURE, |
1322 | * -FDT_ERR_TRUNCATED, standard meanings |
1323 | */ |
1324 | static inline int fdt_setprop_inplace_u32(void *fdt, int nodeoffset, |
1325 | const char *name, uint32_t val) |
1326 | { |
1327 | fdt32_t tmp = cpu_to_fdt32(val); |
1328 | return fdt_setprop_inplace(fdt, nodeoffset, name, val: &tmp, len: sizeof(tmp)); |
1329 | } |
1330 | |
1331 | /** |
1332 | * fdt_setprop_inplace_u64 - change the value of a 64-bit integer property |
1333 | * @fdt: pointer to the device tree blob |
1334 | * @nodeoffset: offset of the node whose property to change |
1335 | * @name: name of the property to change |
1336 | * @val: 64-bit integer value to replace the property with |
1337 | * |
1338 | * fdt_setprop_inplace_u64() replaces the value of a given property |
1339 | * with the 64-bit integer value in val, converting val to big-endian |
1340 | * if necessary. This function cannot change the size of a property, |
1341 | * and so will only work if the property already exists and has length |
1342 | * 8. |
1343 | * |
1344 | * This function will alter only the bytes in the blob which contain |
1345 | * the given property value, and will not alter or move any other part |
1346 | * of the tree. |
1347 | * |
1348 | * returns: |
1349 | * 0, on success |
1350 | * -FDT_ERR_NOSPACE, if the property's length is not equal to 8 |
1351 | * -FDT_ERR_NOTFOUND, node does not have the named property |
1352 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1353 | * -FDT_ERR_BADMAGIC, |
1354 | * -FDT_ERR_BADVERSION, |
1355 | * -FDT_ERR_BADSTATE, |
1356 | * -FDT_ERR_BADSTRUCTURE, |
1357 | * -FDT_ERR_TRUNCATED, standard meanings |
1358 | */ |
1359 | static inline int fdt_setprop_inplace_u64(void *fdt, int nodeoffset, |
1360 | const char *name, uint64_t val) |
1361 | { |
1362 | fdt64_t tmp = cpu_to_fdt64(val); |
1363 | return fdt_setprop_inplace(fdt, nodeoffset, name, val: &tmp, len: sizeof(tmp)); |
1364 | } |
1365 | |
1366 | /** |
1367 | * fdt_setprop_inplace_cell - change the value of a single-cell property |
1368 | * @fdt: pointer to the device tree blob |
1369 | * @nodeoffset: offset of the node containing the property |
1370 | * @name: name of the property to change the value of |
1371 | * @val: new value of the 32-bit cell |
1372 | * |
1373 | * This is an alternative name for fdt_setprop_inplace_u32() |
1374 | * Return: 0 on success, negative libfdt error number otherwise. |
1375 | */ |
1376 | static inline int fdt_setprop_inplace_cell(void *fdt, int nodeoffset, |
1377 | const char *name, uint32_t val) |
1378 | { |
1379 | return fdt_setprop_inplace_u32(fdt, nodeoffset, name, val); |
1380 | } |
1381 | |
1382 | /** |
1383 | * fdt_nop_property - replace a property with nop tags |
1384 | * @fdt: pointer to the device tree blob |
1385 | * @nodeoffset: offset of the node whose property to nop |
1386 | * @name: name of the property to nop |
1387 | * |
1388 | * fdt_nop_property() will replace a given property's representation |
1389 | * in the blob with FDT_NOP tags, effectively removing it from the |
1390 | * tree. |
1391 | * |
1392 | * This function will alter only the bytes in the blob which contain |
1393 | * the property, and will not alter or move any other part of the |
1394 | * tree. |
1395 | * |
1396 | * returns: |
1397 | * 0, on success |
1398 | * -FDT_ERR_NOTFOUND, node does not have the named property |
1399 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1400 | * -FDT_ERR_BADMAGIC, |
1401 | * -FDT_ERR_BADVERSION, |
1402 | * -FDT_ERR_BADSTATE, |
1403 | * -FDT_ERR_BADSTRUCTURE, |
1404 | * -FDT_ERR_TRUNCATED, standard meanings |
1405 | */ |
1406 | int fdt_nop_property(void *fdt, int nodeoffset, const char *name); |
1407 | |
1408 | /** |
1409 | * fdt_nop_node - replace a node (subtree) with nop tags |
1410 | * @fdt: pointer to the device tree blob |
1411 | * @nodeoffset: offset of the node to nop |
1412 | * |
1413 | * fdt_nop_node() will replace a given node's representation in the |
1414 | * blob, including all its subnodes, if any, with FDT_NOP tags, |
1415 | * effectively removing it from the tree. |
1416 | * |
1417 | * This function will alter only the bytes in the blob which contain |
1418 | * the node and its properties and subnodes, and will not alter or |
1419 | * move any other part of the tree. |
1420 | * |
1421 | * returns: |
1422 | * 0, on success |
1423 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1424 | * -FDT_ERR_BADMAGIC, |
1425 | * -FDT_ERR_BADVERSION, |
1426 | * -FDT_ERR_BADSTATE, |
1427 | * -FDT_ERR_BADSTRUCTURE, |
1428 | * -FDT_ERR_TRUNCATED, standard meanings |
1429 | */ |
1430 | int fdt_nop_node(void *fdt, int nodeoffset); |
1431 | |
1432 | /**********************************************************************/ |
1433 | /* Sequential write functions */ |
1434 | /**********************************************************************/ |
1435 | |
1436 | /* fdt_create_with_flags flags */ |
1437 | #define FDT_CREATE_FLAG_NO_NAME_DEDUP 0x1 |
1438 | /* FDT_CREATE_FLAG_NO_NAME_DEDUP: Do not try to de-duplicate property |
1439 | * names in the fdt. This can result in faster creation times, but |
1440 | * a larger fdt. */ |
1441 | |
1442 | #define FDT_CREATE_FLAGS_ALL (FDT_CREATE_FLAG_NO_NAME_DEDUP) |
1443 | |
1444 | /** |
1445 | * fdt_create_with_flags - begin creation of a new fdt |
1446 | * @buf: pointer to memory allocated where fdt will be created |
1447 | * @bufsize: size of the memory space at fdt |
1448 | * @flags: a valid combination of FDT_CREATE_FLAG_ flags, or 0. |
1449 | * |
1450 | * fdt_create_with_flags() begins the process of creating a new fdt with |
1451 | * the sequential write interface. |
1452 | * |
1453 | * fdt creation process must end with fdt_finished() to produce a valid fdt. |
1454 | * |
1455 | * returns: |
1456 | * 0, on success |
1457 | * -FDT_ERR_NOSPACE, bufsize is insufficient for a minimal fdt |
1458 | * -FDT_ERR_BADFLAGS, flags is not valid |
1459 | */ |
1460 | int fdt_create_with_flags(void *buf, int bufsize, uint32_t flags); |
1461 | |
1462 | /** |
1463 | * fdt_create - begin creation of a new fdt |
1464 | * @buf: pointer to memory allocated where fdt will be created |
1465 | * @bufsize: size of the memory space at fdt |
1466 | * |
1467 | * fdt_create() is equivalent to fdt_create_with_flags() with flags=0. |
1468 | * |
1469 | * returns: |
1470 | * 0, on success |
1471 | * -FDT_ERR_NOSPACE, bufsize is insufficient for a minimal fdt |
1472 | */ |
1473 | int fdt_create(void *buf, int bufsize); |
1474 | |
1475 | int fdt_resize(void *fdt, void *buf, int bufsize); |
1476 | int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size); |
1477 | int fdt_finish_reservemap(void *fdt); |
1478 | int fdt_begin_node(void *fdt, const char *name); |
1479 | int fdt_property(void *fdt, const char *name, const void *val, int len); |
1480 | static inline int fdt_property_u32(void *fdt, const char *name, uint32_t val) |
1481 | { |
1482 | fdt32_t tmp = cpu_to_fdt32(val); |
1483 | return fdt_property(fdt, name, val: &tmp, len: sizeof(tmp)); |
1484 | } |
1485 | static inline int fdt_property_u64(void *fdt, const char *name, uint64_t val) |
1486 | { |
1487 | fdt64_t tmp = cpu_to_fdt64(val); |
1488 | return fdt_property(fdt, name, val: &tmp, len: sizeof(tmp)); |
1489 | } |
1490 | |
1491 | #ifndef SWIG /* Not available in Python */ |
1492 | static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val) |
1493 | { |
1494 | return fdt_property_u32(fdt, name, val); |
1495 | } |
1496 | #endif |
1497 | |
1498 | /** |
1499 | * fdt_property_placeholder - add a new property and return a ptr to its value |
1500 | * |
1501 | * @fdt: pointer to the device tree blob |
1502 | * @name: name of property to add |
1503 | * @len: length of property value in bytes |
1504 | * @valp: returns a pointer to where where the value should be placed |
1505 | * |
1506 | * returns: |
1507 | * 0, on success |
1508 | * -FDT_ERR_BADMAGIC, |
1509 | * -FDT_ERR_NOSPACE, standard meanings |
1510 | */ |
1511 | int fdt_property_placeholder(void *fdt, const char *name, int len, void **valp); |
1512 | |
1513 | #define fdt_property_string(fdt, name, str) \ |
1514 | fdt_property(fdt, name, str, strlen(str)+1) |
1515 | int fdt_end_node(void *fdt); |
1516 | int fdt_finish(void *fdt); |
1517 | |
1518 | /**********************************************************************/ |
1519 | /* Read-write functions */ |
1520 | /**********************************************************************/ |
1521 | |
1522 | int fdt_create_empty_tree(void *buf, int bufsize); |
1523 | int fdt_open_into(const void *fdt, void *buf, int bufsize); |
1524 | int fdt_pack(void *fdt); |
1525 | |
1526 | /** |
1527 | * fdt_add_mem_rsv - add one memory reserve map entry |
1528 | * @fdt: pointer to the device tree blob |
1529 | * @address: 64-bit start address of the reserve map entry |
1530 | * @size: 64-bit size of the reserved region |
1531 | * |
1532 | * Adds a reserve map entry to the given blob reserving a region at |
1533 | * address address of length size. |
1534 | * |
1535 | * This function will insert data into the reserve map and will |
1536 | * therefore change the indexes of some entries in the table. |
1537 | * |
1538 | * returns: |
1539 | * 0, on success |
1540 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1541 | * contain the new reservation entry |
1542 | * -FDT_ERR_BADMAGIC, |
1543 | * -FDT_ERR_BADVERSION, |
1544 | * -FDT_ERR_BADSTATE, |
1545 | * -FDT_ERR_BADSTRUCTURE, |
1546 | * -FDT_ERR_BADLAYOUT, |
1547 | * -FDT_ERR_TRUNCATED, standard meanings |
1548 | */ |
1549 | int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size); |
1550 | |
1551 | /** |
1552 | * fdt_del_mem_rsv - remove a memory reserve map entry |
1553 | * @fdt: pointer to the device tree blob |
1554 | * @n: entry to remove |
1555 | * |
1556 | * fdt_del_mem_rsv() removes the n-th memory reserve map entry from |
1557 | * the blob. |
1558 | * |
1559 | * This function will delete data from the reservation table and will |
1560 | * therefore change the indexes of some entries in the table. |
1561 | * |
1562 | * returns: |
1563 | * 0, on success |
1564 | * -FDT_ERR_NOTFOUND, there is no entry of the given index (i.e. there |
1565 | * are less than n+1 reserve map entries) |
1566 | * -FDT_ERR_BADMAGIC, |
1567 | * -FDT_ERR_BADVERSION, |
1568 | * -FDT_ERR_BADSTATE, |
1569 | * -FDT_ERR_BADSTRUCTURE, |
1570 | * -FDT_ERR_BADLAYOUT, |
1571 | * -FDT_ERR_TRUNCATED, standard meanings |
1572 | */ |
1573 | int fdt_del_mem_rsv(void *fdt, int n); |
1574 | |
1575 | /** |
1576 | * fdt_set_name - change the name of a given node |
1577 | * @fdt: pointer to the device tree blob |
1578 | * @nodeoffset: structure block offset of a node |
1579 | * @name: name to give the node |
1580 | * |
1581 | * fdt_set_name() replaces the name (including unit address, if any) |
1582 | * of the given node with the given string. NOTE: this function can't |
1583 | * efficiently check if the new name is unique amongst the given |
1584 | * node's siblings; results are undefined if this function is invoked |
1585 | * with a name equal to one of the given node's siblings. |
1586 | * |
1587 | * This function may insert or delete data from the blob, and will |
1588 | * therefore change the offsets of some existing nodes. |
1589 | * |
1590 | * returns: |
1591 | * 0, on success |
1592 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob |
1593 | * to contain the new name |
1594 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1595 | * -FDT_ERR_BADMAGIC, |
1596 | * -FDT_ERR_BADVERSION, |
1597 | * -FDT_ERR_BADSTATE, standard meanings |
1598 | */ |
1599 | int fdt_set_name(void *fdt, int nodeoffset, const char *name); |
1600 | |
1601 | /** |
1602 | * fdt_setprop - create or change a property |
1603 | * @fdt: pointer to the device tree blob |
1604 | * @nodeoffset: offset of the node whose property to change |
1605 | * @name: name of the property to change |
1606 | * @val: pointer to data to set the property value to |
1607 | * @len: length of the property value |
1608 | * |
1609 | * fdt_setprop() sets the value of the named property in the given |
1610 | * node to the given value and length, creating the property if it |
1611 | * does not already exist. |
1612 | * |
1613 | * This function may insert or delete data from the blob, and will |
1614 | * therefore change the offsets of some existing nodes. |
1615 | * |
1616 | * returns: |
1617 | * 0, on success |
1618 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1619 | * contain the new property value |
1620 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1621 | * -FDT_ERR_BADLAYOUT, |
1622 | * -FDT_ERR_BADMAGIC, |
1623 | * -FDT_ERR_BADVERSION, |
1624 | * -FDT_ERR_BADSTATE, |
1625 | * -FDT_ERR_BADSTRUCTURE, |
1626 | * -FDT_ERR_BADLAYOUT, |
1627 | * -FDT_ERR_TRUNCATED, standard meanings |
1628 | */ |
1629 | int fdt_setprop(void *fdt, int nodeoffset, const char *name, |
1630 | const void *val, int len); |
1631 | |
1632 | /** |
1633 | * fdt_setprop_placeholder - allocate space for a property |
1634 | * @fdt: pointer to the device tree blob |
1635 | * @nodeoffset: offset of the node whose property to change |
1636 | * @name: name of the property to change |
1637 | * @len: length of the property value |
1638 | * @prop_data: return pointer to property data |
1639 | * |
1640 | * fdt_setprop_placeholer() allocates the named property in the given node. |
1641 | * If the property exists it is resized. In either case a pointer to the |
1642 | * property data is returned. |
1643 | * |
1644 | * This function may insert or delete data from the blob, and will |
1645 | * therefore change the offsets of some existing nodes. |
1646 | * |
1647 | * returns: |
1648 | * 0, on success |
1649 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1650 | * contain the new property value |
1651 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1652 | * -FDT_ERR_BADLAYOUT, |
1653 | * -FDT_ERR_BADMAGIC, |
1654 | * -FDT_ERR_BADVERSION, |
1655 | * -FDT_ERR_BADSTATE, |
1656 | * -FDT_ERR_BADSTRUCTURE, |
1657 | * -FDT_ERR_BADLAYOUT, |
1658 | * -FDT_ERR_TRUNCATED, standard meanings |
1659 | */ |
1660 | int fdt_setprop_placeholder(void *fdt, int nodeoffset, const char *name, |
1661 | int len, void **prop_data); |
1662 | |
1663 | /** |
1664 | * fdt_setprop_u32 - set a property to a 32-bit integer |
1665 | * @fdt: pointer to the device tree blob |
1666 | * @nodeoffset: offset of the node whose property to change |
1667 | * @name: name of the property to change |
1668 | * @val: 32-bit integer value for the property (native endian) |
1669 | * |
1670 | * fdt_setprop_u32() sets the value of the named property in the given |
1671 | * node to the given 32-bit integer value (converting to big-endian if |
1672 | * necessary), or creates a new property with that value if it does |
1673 | * not already exist. |
1674 | * |
1675 | * This function may insert or delete data from the blob, and will |
1676 | * therefore change the offsets of some existing nodes. |
1677 | * |
1678 | * returns: |
1679 | * 0, on success |
1680 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1681 | * contain the new property value |
1682 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1683 | * -FDT_ERR_BADLAYOUT, |
1684 | * -FDT_ERR_BADMAGIC, |
1685 | * -FDT_ERR_BADVERSION, |
1686 | * -FDT_ERR_BADSTATE, |
1687 | * -FDT_ERR_BADSTRUCTURE, |
1688 | * -FDT_ERR_BADLAYOUT, |
1689 | * -FDT_ERR_TRUNCATED, standard meanings |
1690 | */ |
1691 | static inline int fdt_setprop_u32(void *fdt, int nodeoffset, const char *name, |
1692 | uint32_t val) |
1693 | { |
1694 | fdt32_t tmp = cpu_to_fdt32(val); |
1695 | return fdt_setprop(fdt, nodeoffset, name, val: &tmp, len: sizeof(tmp)); |
1696 | } |
1697 | |
1698 | /** |
1699 | * fdt_setprop_u64 - set a property to a 64-bit integer |
1700 | * @fdt: pointer to the device tree blob |
1701 | * @nodeoffset: offset of the node whose property to change |
1702 | * @name: name of the property to change |
1703 | * @val: 64-bit integer value for the property (native endian) |
1704 | * |
1705 | * fdt_setprop_u64() sets the value of the named property in the given |
1706 | * node to the given 64-bit integer value (converting to big-endian if |
1707 | * necessary), or creates a new property with that value if it does |
1708 | * not already exist. |
1709 | * |
1710 | * This function may insert or delete data from the blob, and will |
1711 | * therefore change the offsets of some existing nodes. |
1712 | * |
1713 | * returns: |
1714 | * 0, on success |
1715 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1716 | * contain the new property value |
1717 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1718 | * -FDT_ERR_BADLAYOUT, |
1719 | * -FDT_ERR_BADMAGIC, |
1720 | * -FDT_ERR_BADVERSION, |
1721 | * -FDT_ERR_BADSTATE, |
1722 | * -FDT_ERR_BADSTRUCTURE, |
1723 | * -FDT_ERR_BADLAYOUT, |
1724 | * -FDT_ERR_TRUNCATED, standard meanings |
1725 | */ |
1726 | static inline int fdt_setprop_u64(void *fdt, int nodeoffset, const char *name, |
1727 | uint64_t val) |
1728 | { |
1729 | fdt64_t tmp = cpu_to_fdt64(val); |
1730 | return fdt_setprop(fdt, nodeoffset, name, val: &tmp, len: sizeof(tmp)); |
1731 | } |
1732 | |
1733 | /** |
1734 | * fdt_setprop_cell - set a property to a single cell value |
1735 | * @fdt: pointer to the device tree blob |
1736 | * @nodeoffset: offset of the node whose property to change |
1737 | * @name: name of the property to change |
1738 | * @val: 32-bit integer value for the property (native endian) |
1739 | * |
1740 | * This is an alternative name for fdt_setprop_u32() |
1741 | * |
1742 | * Return: 0 on success, negative libfdt error value otherwise. |
1743 | */ |
1744 | static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name, |
1745 | uint32_t val) |
1746 | { |
1747 | return fdt_setprop_u32(fdt, nodeoffset, name, val); |
1748 | } |
1749 | |
1750 | /** |
1751 | * fdt_setprop_string - set a property to a string value |
1752 | * @fdt: pointer to the device tree blob |
1753 | * @nodeoffset: offset of the node whose property to change |
1754 | * @name: name of the property to change |
1755 | * @str: string value for the property |
1756 | * |
1757 | * fdt_setprop_string() sets the value of the named property in the |
1758 | * given node to the given string value (using the length of the |
1759 | * string to determine the new length of the property), or creates a |
1760 | * new property with that value if it does not already exist. |
1761 | * |
1762 | * This function may insert or delete data from the blob, and will |
1763 | * therefore change the offsets of some existing nodes. |
1764 | * |
1765 | * returns: |
1766 | * 0, on success |
1767 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1768 | * contain the new property value |
1769 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1770 | * -FDT_ERR_BADLAYOUT, |
1771 | * -FDT_ERR_BADMAGIC, |
1772 | * -FDT_ERR_BADVERSION, |
1773 | * -FDT_ERR_BADSTATE, |
1774 | * -FDT_ERR_BADSTRUCTURE, |
1775 | * -FDT_ERR_BADLAYOUT, |
1776 | * -FDT_ERR_TRUNCATED, standard meanings |
1777 | */ |
1778 | #define fdt_setprop_string(fdt, nodeoffset, name, str) \ |
1779 | fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1) |
1780 | |
1781 | |
1782 | /** |
1783 | * fdt_setprop_empty - set a property to an empty value |
1784 | * @fdt: pointer to the device tree blob |
1785 | * @nodeoffset: offset of the node whose property to change |
1786 | * @name: name of the property to change |
1787 | * |
1788 | * fdt_setprop_empty() sets the value of the named property in the |
1789 | * given node to an empty (zero length) value, or creates a new empty |
1790 | * property if it does not already exist. |
1791 | * |
1792 | * This function may insert or delete data from the blob, and will |
1793 | * therefore change the offsets of some existing nodes. |
1794 | * |
1795 | * returns: |
1796 | * 0, on success |
1797 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1798 | * contain the new property value |
1799 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1800 | * -FDT_ERR_BADLAYOUT, |
1801 | * -FDT_ERR_BADMAGIC, |
1802 | * -FDT_ERR_BADVERSION, |
1803 | * -FDT_ERR_BADSTATE, |
1804 | * -FDT_ERR_BADSTRUCTURE, |
1805 | * -FDT_ERR_BADLAYOUT, |
1806 | * -FDT_ERR_TRUNCATED, standard meanings |
1807 | */ |
1808 | #define fdt_setprop_empty(fdt, nodeoffset, name) \ |
1809 | fdt_setprop((fdt), (nodeoffset), (name), NULL, 0) |
1810 | |
1811 | /** |
1812 | * fdt_appendprop - append to or create a property |
1813 | * @fdt: pointer to the device tree blob |
1814 | * @nodeoffset: offset of the node whose property to change |
1815 | * @name: name of the property to append to |
1816 | * @val: pointer to data to append to the property value |
1817 | * @len: length of the data to append to the property value |
1818 | * |
1819 | * fdt_appendprop() appends the value to the named property in the |
1820 | * given node, creating the property if it does not already exist. |
1821 | * |
1822 | * This function may insert data into the blob, and will therefore |
1823 | * change the offsets of some existing nodes. |
1824 | * |
1825 | * returns: |
1826 | * 0, on success |
1827 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1828 | * contain the new property value |
1829 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1830 | * -FDT_ERR_BADLAYOUT, |
1831 | * -FDT_ERR_BADMAGIC, |
1832 | * -FDT_ERR_BADVERSION, |
1833 | * -FDT_ERR_BADSTATE, |
1834 | * -FDT_ERR_BADSTRUCTURE, |
1835 | * -FDT_ERR_BADLAYOUT, |
1836 | * -FDT_ERR_TRUNCATED, standard meanings |
1837 | */ |
1838 | int fdt_appendprop(void *fdt, int nodeoffset, const char *name, |
1839 | const void *val, int len); |
1840 | |
1841 | /** |
1842 | * fdt_appendprop_u32 - append a 32-bit integer value to a property |
1843 | * @fdt: pointer to the device tree blob |
1844 | * @nodeoffset: offset of the node whose property to change |
1845 | * @name: name of the property to change |
1846 | * @val: 32-bit integer value to append to the property (native endian) |
1847 | * |
1848 | * fdt_appendprop_u32() appends the given 32-bit integer value |
1849 | * (converting to big-endian if necessary) to the value of the named |
1850 | * property in the given node, or creates a new property with that |
1851 | * value if it does not already exist. |
1852 | * |
1853 | * This function may insert data into the blob, and will therefore |
1854 | * change the offsets of some existing nodes. |
1855 | * |
1856 | * returns: |
1857 | * 0, on success |
1858 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1859 | * contain the new property value |
1860 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1861 | * -FDT_ERR_BADLAYOUT, |
1862 | * -FDT_ERR_BADMAGIC, |
1863 | * -FDT_ERR_BADVERSION, |
1864 | * -FDT_ERR_BADSTATE, |
1865 | * -FDT_ERR_BADSTRUCTURE, |
1866 | * -FDT_ERR_BADLAYOUT, |
1867 | * -FDT_ERR_TRUNCATED, standard meanings |
1868 | */ |
1869 | static inline int fdt_appendprop_u32(void *fdt, int nodeoffset, |
1870 | const char *name, uint32_t val) |
1871 | { |
1872 | fdt32_t tmp = cpu_to_fdt32(val); |
1873 | return fdt_appendprop(fdt, nodeoffset, name, val: &tmp, len: sizeof(tmp)); |
1874 | } |
1875 | |
1876 | /** |
1877 | * fdt_appendprop_u64 - append a 64-bit integer value to a property |
1878 | * @fdt: pointer to the device tree blob |
1879 | * @nodeoffset: offset of the node whose property to change |
1880 | * @name: name of the property to change |
1881 | * @val: 64-bit integer value to append to the property (native endian) |
1882 | * |
1883 | * fdt_appendprop_u64() appends the given 64-bit integer value |
1884 | * (converting to big-endian if necessary) to the value of the named |
1885 | * property in the given node, or creates a new property with that |
1886 | * value if it does not already exist. |
1887 | * |
1888 | * This function may insert data into the blob, and will therefore |
1889 | * change the offsets of some existing nodes. |
1890 | * |
1891 | * returns: |
1892 | * 0, on success |
1893 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1894 | * contain the new property value |
1895 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1896 | * -FDT_ERR_BADLAYOUT, |
1897 | * -FDT_ERR_BADMAGIC, |
1898 | * -FDT_ERR_BADVERSION, |
1899 | * -FDT_ERR_BADSTATE, |
1900 | * -FDT_ERR_BADSTRUCTURE, |
1901 | * -FDT_ERR_BADLAYOUT, |
1902 | * -FDT_ERR_TRUNCATED, standard meanings |
1903 | */ |
1904 | static inline int fdt_appendprop_u64(void *fdt, int nodeoffset, |
1905 | const char *name, uint64_t val) |
1906 | { |
1907 | fdt64_t tmp = cpu_to_fdt64(val); |
1908 | return fdt_appendprop(fdt, nodeoffset, name, val: &tmp, len: sizeof(tmp)); |
1909 | } |
1910 | |
1911 | /** |
1912 | * fdt_appendprop_cell - append a single cell value to a property |
1913 | * @fdt: pointer to the device tree blob |
1914 | * @nodeoffset: offset of the node whose property to change |
1915 | * @name: name of the property to change |
1916 | * @val: 32-bit integer value to append to the property (native endian) |
1917 | * |
1918 | * This is an alternative name for fdt_appendprop_u32() |
1919 | * |
1920 | * Return: 0 on success, negative libfdt error value otherwise. |
1921 | */ |
1922 | static inline int fdt_appendprop_cell(void *fdt, int nodeoffset, |
1923 | const char *name, uint32_t val) |
1924 | { |
1925 | return fdt_appendprop_u32(fdt, nodeoffset, name, val); |
1926 | } |
1927 | |
1928 | /** |
1929 | * fdt_appendprop_string - append a string to a property |
1930 | * @fdt: pointer to the device tree blob |
1931 | * @nodeoffset: offset of the node whose property to change |
1932 | * @name: name of the property to change |
1933 | * @str: string value to append to the property |
1934 | * |
1935 | * fdt_appendprop_string() appends the given string to the value of |
1936 | * the named property in the given node, or creates a new property |
1937 | * with that value if it does not already exist. |
1938 | * |
1939 | * This function may insert data into the blob, and will therefore |
1940 | * change the offsets of some existing nodes. |
1941 | * |
1942 | * returns: |
1943 | * 0, on success |
1944 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1945 | * contain the new property value |
1946 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1947 | * -FDT_ERR_BADLAYOUT, |
1948 | * -FDT_ERR_BADMAGIC, |
1949 | * -FDT_ERR_BADVERSION, |
1950 | * -FDT_ERR_BADSTATE, |
1951 | * -FDT_ERR_BADSTRUCTURE, |
1952 | * -FDT_ERR_BADLAYOUT, |
1953 | * -FDT_ERR_TRUNCATED, standard meanings |
1954 | */ |
1955 | #define fdt_appendprop_string(fdt, nodeoffset, name, str) \ |
1956 | fdt_appendprop((fdt), (nodeoffset), (name), (str), strlen(str)+1) |
1957 | |
1958 | /** |
1959 | * fdt_appendprop_addrrange - append a address range property |
1960 | * @fdt: pointer to the device tree blob |
1961 | * @parent: offset of the parent node |
1962 | * @nodeoffset: offset of the node to add a property at |
1963 | * @name: name of property |
1964 | * @addr: start address of a given range |
1965 | * @size: size of a given range |
1966 | * |
1967 | * fdt_appendprop_addrrange() appends an address range value (start |
1968 | * address and size) to the value of the named property in the given |
1969 | * node, or creates a new property with that value if it does not |
1970 | * already exist. |
1971 | * If "name" is not specified, a default "reg" is used. |
1972 | * Cell sizes are determined by parent's #address-cells and #size-cells. |
1973 | * |
1974 | * This function may insert data into the blob, and will therefore |
1975 | * change the offsets of some existing nodes. |
1976 | * |
1977 | * returns: |
1978 | * 0, on success |
1979 | * -FDT_ERR_BADLAYOUT, |
1980 | * -FDT_ERR_BADMAGIC, |
1981 | * -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid |
1982 | * #address-cells property |
1983 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
1984 | * -FDT_ERR_BADSTATE, |
1985 | * -FDT_ERR_BADSTRUCTURE, |
1986 | * -FDT_ERR_BADVERSION, |
1987 | * -FDT_ERR_BADVALUE, addr or size doesn't fit to respective cells size |
1988 | * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to |
1989 | * contain a new property |
1990 | * -FDT_ERR_TRUNCATED, standard meanings |
1991 | */ |
1992 | int fdt_appendprop_addrrange(void *fdt, int parent, int nodeoffset, |
1993 | const char *name, uint64_t addr, uint64_t size); |
1994 | |
1995 | /** |
1996 | * fdt_delprop - delete a property |
1997 | * @fdt: pointer to the device tree blob |
1998 | * @nodeoffset: offset of the node whose property to nop |
1999 | * @name: name of the property to nop |
2000 | * |
2001 | * fdt_del_property() will delete the given property. |
2002 | * |
2003 | * This function will delete data from the blob, and will therefore |
2004 | * change the offsets of some existing nodes. |
2005 | * |
2006 | * returns: |
2007 | * 0, on success |
2008 | * -FDT_ERR_NOTFOUND, node does not have the named property |
2009 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
2010 | * -FDT_ERR_BADLAYOUT, |
2011 | * -FDT_ERR_BADMAGIC, |
2012 | * -FDT_ERR_BADVERSION, |
2013 | * -FDT_ERR_BADSTATE, |
2014 | * -FDT_ERR_BADSTRUCTURE, |
2015 | * -FDT_ERR_TRUNCATED, standard meanings |
2016 | */ |
2017 | int fdt_delprop(void *fdt, int nodeoffset, const char *name); |
2018 | |
2019 | /** |
2020 | * fdt_add_subnode_namelen - creates a new node based on substring |
2021 | * @fdt: pointer to the device tree blob |
2022 | * @parentoffset: structure block offset of a node |
2023 | * @name: name of the subnode to create |
2024 | * @namelen: number of characters of name to consider |
2025 | * |
2026 | * Identical to fdt_add_subnode(), but use only the first @namelen |
2027 | * characters of @name as the name of the new node. This is useful for |
2028 | * creating subnodes based on a portion of a larger string, such as a |
2029 | * full path. |
2030 | * |
2031 | * Return: structure block offset of the created subnode (>=0), |
2032 | * negative libfdt error value otherwise |
2033 | */ |
2034 | #ifndef SWIG /* Not available in Python */ |
2035 | int fdt_add_subnode_namelen(void *fdt, int parentoffset, |
2036 | const char *name, int namelen); |
2037 | #endif |
2038 | |
2039 | /** |
2040 | * fdt_add_subnode - creates a new node |
2041 | * @fdt: pointer to the device tree blob |
2042 | * @parentoffset: structure block offset of a node |
2043 | * @name: name of the subnode to locate |
2044 | * |
2045 | * fdt_add_subnode() creates a new node as a subnode of the node at |
2046 | * structure block offset parentoffset, with the given name (which |
2047 | * should include the unit address, if any). |
2048 | * |
2049 | * This function will insert data into the blob, and will therefore |
2050 | * change the offsets of some existing nodes. |
2051 | * |
2052 | * returns: |
2053 | * structure block offset of the created nodeequested subnode (>=0), on |
2054 | * success |
2055 | * -FDT_ERR_NOTFOUND, if the requested subnode does not exist |
2056 | * -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE |
2057 | * tag |
2058 | * -FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of |
2059 | * the given name |
2060 | * -FDT_ERR_NOSPACE, if there is insufficient free space in the |
2061 | * blob to contain the new node |
2062 | * -FDT_ERR_NOSPACE |
2063 | * -FDT_ERR_BADLAYOUT |
2064 | * -FDT_ERR_BADMAGIC, |
2065 | * -FDT_ERR_BADVERSION, |
2066 | * -FDT_ERR_BADSTATE, |
2067 | * -FDT_ERR_BADSTRUCTURE, |
2068 | * -FDT_ERR_TRUNCATED, standard meanings. |
2069 | */ |
2070 | int fdt_add_subnode(void *fdt, int parentoffset, const char *name); |
2071 | |
2072 | /** |
2073 | * fdt_del_node - delete a node (subtree) |
2074 | * @fdt: pointer to the device tree blob |
2075 | * @nodeoffset: offset of the node to nop |
2076 | * |
2077 | * fdt_del_node() will remove the given node, including all its |
2078 | * subnodes if any, from the blob. |
2079 | * |
2080 | * This function will delete data from the blob, and will therefore |
2081 | * change the offsets of some existing nodes. |
2082 | * |
2083 | * returns: |
2084 | * 0, on success |
2085 | * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag |
2086 | * -FDT_ERR_BADLAYOUT, |
2087 | * -FDT_ERR_BADMAGIC, |
2088 | * -FDT_ERR_BADVERSION, |
2089 | * -FDT_ERR_BADSTATE, |
2090 | * -FDT_ERR_BADSTRUCTURE, |
2091 | * -FDT_ERR_TRUNCATED, standard meanings |
2092 | */ |
2093 | int fdt_del_node(void *fdt, int nodeoffset); |
2094 | |
2095 | /** |
2096 | * fdt_overlay_apply - Applies a DT overlay on a base DT |
2097 | * @fdt: pointer to the base device tree blob |
2098 | * @fdto: pointer to the device tree overlay blob |
2099 | * |
2100 | * fdt_overlay_apply() will apply the given device tree overlay on the |
2101 | * given base device tree. |
2102 | * |
2103 | * Expect the base device tree to be modified, even if the function |
2104 | * returns an error. |
2105 | * |
2106 | * returns: |
2107 | * 0, on success |
2108 | * -FDT_ERR_NOSPACE, there's not enough space in the base device tree |
2109 | * -FDT_ERR_NOTFOUND, the overlay points to some inexistant nodes or |
2110 | * properties in the base DT |
2111 | * -FDT_ERR_BADPHANDLE, |
2112 | * -FDT_ERR_BADOVERLAY, |
2113 | * -FDT_ERR_NOPHANDLES, |
2114 | * -FDT_ERR_INTERNAL, |
2115 | * -FDT_ERR_BADLAYOUT, |
2116 | * -FDT_ERR_BADMAGIC, |
2117 | * -FDT_ERR_BADOFFSET, |
2118 | * -FDT_ERR_BADPATH, |
2119 | * -FDT_ERR_BADVERSION, |
2120 | * -FDT_ERR_BADSTRUCTURE, |
2121 | * -FDT_ERR_BADSTATE, |
2122 | * -FDT_ERR_TRUNCATED, standard meanings |
2123 | */ |
2124 | int fdt_overlay_apply(void *fdt, void *fdto); |
2125 | |
2126 | /** |
2127 | * fdt_overlay_target_offset - retrieves the offset of a fragment's target |
2128 | * @fdt: Base device tree blob |
2129 | * @fdto: Device tree overlay blob |
2130 | * @fragment_offset: node offset of the fragment in the overlay |
2131 | * @pathp: pointer which receives the path of the target (or NULL) |
2132 | * |
2133 | * fdt_overlay_target_offset() retrieves the target offset in the base |
2134 | * device tree of a fragment, no matter how the actual targeting is |
2135 | * done (through a phandle or a path) |
2136 | * |
2137 | * returns: |
2138 | * the targeted node offset in the base device tree |
2139 | * Negative error code on error |
2140 | */ |
2141 | int fdt_overlay_target_offset(const void *fdt, const void *fdto, |
2142 | int fragment_offset, char const **pathp); |
2143 | |
2144 | /**********************************************************************/ |
2145 | /* Debugging / informational functions */ |
2146 | /**********************************************************************/ |
2147 | |
2148 | const char *fdt_strerror(int errval); |
2149 | |
2150 | #ifdef __cplusplus |
2151 | } |
2152 | #endif |
2153 | |
2154 | #endif /* LIBFDT_H */ |
2155 | |