Annotation of elwix/tools/uboot_mkimage/include/libfdt.h, revision 1.1
1.1 ! misho 1: #ifndef _LIBFDT_H
! 2: #define _LIBFDT_H
! 3: /*
! 4: * libfdt - Flat Device Tree manipulation
! 5: * Copyright (C) 2006 David Gibson, IBM Corporation.
! 6: *
! 7: * libfdt is dual licensed: you can use it either under the terms of
! 8: * the GPL, or the BSD license, at your option.
! 9: *
! 10: * a) This library is free software; you can redistribute it and/or
! 11: * modify it under the terms of the GNU General Public License as
! 12: * published by the Free Software Foundation; either version 2 of the
! 13: * License, or (at your option) any later version.
! 14: *
! 15: * This library is distributed in the hope that it will be useful,
! 16: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 17: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 18: * GNU General Public License for more details.
! 19: *
! 20: * You should have received a copy of the GNU General Public
! 21: * License along with this library; if not, write to the Free
! 22: * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
! 23: * MA 02110-1301 USA
! 24: *
! 25: * Alternatively,
! 26: *
! 27: * b) Redistribution and use in source and binary forms, with or
! 28: * without modification, are permitted provided that the following
! 29: * conditions are met:
! 30: *
! 31: * 1. Redistributions of source code must retain the above
! 32: * copyright notice, this list of conditions and the following
! 33: * disclaimer.
! 34: * 2. Redistributions in binary form must reproduce the above
! 35: * copyright notice, this list of conditions and the following
! 36: * disclaimer in the documentation and/or other materials
! 37: * provided with the distribution.
! 38: *
! 39: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
! 40: * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
! 41: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
! 42: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 43: * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
! 44: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
! 45: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 46: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
! 47: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 48: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 49: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
! 50: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
! 51: * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 52: */
! 53:
! 54: #include <libfdt_env.h>
! 55: #include <fdt.h>
! 56:
! 57: #define FDT_FIRST_SUPPORTED_VERSION 0x10
! 58: #define FDT_LAST_SUPPORTED_VERSION 0x11
! 59:
! 60: /* Error codes: informative error codes */
! 61: #define FDT_ERR_NOTFOUND 1
! 62: /* FDT_ERR_NOTFOUND: The requested node or property does not exist */
! 63: #define FDT_ERR_EXISTS 2
! 64: /* FDT_ERR_EXISTS: Attemped to create a node or property which
! 65: * already exists */
! 66: #define FDT_ERR_NOSPACE 3
! 67: /* FDT_ERR_NOSPACE: Operation needed to expand the device
! 68: * tree, but its buffer did not have sufficient space to
! 69: * contain the expanded tree. Use fdt_open_into() to move the
! 70: * device tree to a buffer with more space. */
! 71:
! 72: /* Error codes: codes for bad parameters */
! 73: #define FDT_ERR_BADOFFSET 4
! 74: /* FDT_ERR_BADOFFSET: Function was passed a structure block
! 75: * offset which is out-of-bounds, or which points to an
! 76: * unsuitable part of the structure for the operation. */
! 77: #define FDT_ERR_BADPATH 5
! 78: /* FDT_ERR_BADPATH: Function was passed a badly formatted path
! 79: * (e.g. missing a leading / for a function which requires an
! 80: * absolute path) */
! 81: #define FDT_ERR_BADPHANDLE 6
! 82: /* FDT_ERR_BADPHANDLE: Function was passed an invalid phandle
! 83: * value. phandle values of 0 and -1 are not permitted. */
! 84: #define FDT_ERR_BADSTATE 7
! 85: /* FDT_ERR_BADSTATE: Function was passed an incomplete device
! 86: * tree created by the sequential-write functions, which is
! 87: * not sufficiently complete for the requested operation. */
! 88:
! 89: /* Error codes: codes for bad device tree blobs */
! 90: #define FDT_ERR_TRUNCATED 8
! 91: /* FDT_ERR_TRUNCATED: Structure block of the given device tree
! 92: * ends without an FDT_END tag. */
! 93: #define FDT_ERR_BADMAGIC 9
! 94: /* FDT_ERR_BADMAGIC: Given "device tree" appears not to be a
! 95: * device tree at all - it is missing the flattened device
! 96: * tree magic number. */
! 97: #define FDT_ERR_BADVERSION 10
! 98: /* FDT_ERR_BADVERSION: Given device tree has a version which
! 99: * can't be handled by the requested operation. For
! 100: * read-write functions, this may mean that fdt_open_into() is
! 101: * required to convert the tree to the expected version. */
! 102: #define FDT_ERR_BADSTRUCTURE 11
! 103: /* FDT_ERR_BADSTRUCTURE: Given device tree has a corrupt
! 104: * structure block or other serious error (e.g. misnested
! 105: * nodes, or subnodes preceding properties). */
! 106: #define FDT_ERR_BADLAYOUT 12
! 107: /* FDT_ERR_BADLAYOUT: For read-write functions, the given
! 108: * device tree has it's sub-blocks in an order that the
! 109: * function can't handle (memory reserve map, then structure,
! 110: * then strings). Use fdt_open_into() to reorganize the tree
! 111: * into a form suitable for the read-write operations. */
! 112:
! 113: /* "Can't happen" error indicating a bug in libfdt */
! 114: #define FDT_ERR_INTERNAL 13
! 115: /* FDT_ERR_INTERNAL: libfdt has failed an internal assertion.
! 116: * Should never be returned, if it is, it indicates a bug in
! 117: * libfdt itself. */
! 118:
! 119: #define FDT_ERR_MAX 13
! 120:
! 121: /**********************************************************************/
! 122: /* Low-level functions (you probably don't need these) */
! 123: /**********************************************************************/
! 124:
! 125: const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int checklen);
! 126: static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)
! 127: {
! 128: return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen);
! 129: }
! 130:
! 131: uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);
! 132:
! 133: /**********************************************************************/
! 134: /* Traversal functions */
! 135: /**********************************************************************/
! 136:
! 137: int fdt_next_node(const void *fdt, int offset, int *depth);
! 138:
! 139: /**********************************************************************/
! 140: /* General functions */
! 141: /**********************************************************************/
! 142:
! 143: #define fdt_get_header(fdt, field) \
! 144: (fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))
! 145: #define fdt_magic(fdt) (fdt_get_header(fdt, magic))
! 146: #define fdt_totalsize(fdt) (fdt_get_header(fdt, totalsize))
! 147: #define fdt_off_dt_struct(fdt) (fdt_get_header(fdt, off_dt_struct))
! 148: #define fdt_off_dt_strings(fdt) (fdt_get_header(fdt, off_dt_strings))
! 149: #define fdt_off_mem_rsvmap(fdt) (fdt_get_header(fdt, off_mem_rsvmap))
! 150: #define fdt_version(fdt) (fdt_get_header(fdt, version))
! 151: #define fdt_last_comp_version(fdt) (fdt_get_header(fdt, last_comp_version))
! 152: #define fdt_boot_cpuid_phys(fdt) (fdt_get_header(fdt, boot_cpuid_phys))
! 153: #define fdt_size_dt_strings(fdt) (fdt_get_header(fdt, size_dt_strings))
! 154: #define fdt_size_dt_struct(fdt) (fdt_get_header(fdt, size_dt_struct))
! 155:
! 156: #define __fdt_set_hdr(name) \
! 157: static inline void fdt_set_##name(void *fdt, uint32_t val) \
! 158: { \
! 159: struct fdt_header *fdth = (struct fdt_header*)fdt; \
! 160: fdth->name = cpu_to_fdt32(val); \
! 161: }
! 162: __fdt_set_hdr(magic);
! 163: __fdt_set_hdr(totalsize);
! 164: __fdt_set_hdr(off_dt_struct);
! 165: __fdt_set_hdr(off_dt_strings);
! 166: __fdt_set_hdr(off_mem_rsvmap);
! 167: __fdt_set_hdr(version);
! 168: __fdt_set_hdr(last_comp_version);
! 169: __fdt_set_hdr(boot_cpuid_phys);
! 170: __fdt_set_hdr(size_dt_strings);
! 171: __fdt_set_hdr(size_dt_struct);
! 172: #undef __fdt_set_hdr
! 173:
! 174: /**
! 175: * fdt_check_header - sanity check a device tree or possible device tree
! 176: * @fdt: pointer to data which might be a flattened device tree
! 177: *
! 178: * fdt_check_header() checks that the given buffer contains what
! 179: * appears to be a flattened device tree with sane information in its
! 180: * header.
! 181: *
! 182: * returns:
! 183: * 0, if the buffer appears to contain a valid device tree
! 184: * -FDT_ERR_BADMAGIC,
! 185: * -FDT_ERR_BADVERSION,
! 186: * -FDT_ERR_BADSTATE, standard meanings, as above
! 187: */
! 188: int fdt_check_header(const void *fdt);
! 189:
! 190: /**
! 191: * fdt_move - move a device tree around in memory
! 192: * @fdt: pointer to the device tree to move
! 193: * @buf: pointer to memory where the device is to be moved
! 194: * @bufsize: size of the memory space at buf
! 195: *
! 196: * fdt_move() relocates, if possible, the device tree blob located at
! 197: * fdt to the buffer at buf of size bufsize. The buffer may overlap
! 198: * with the existing device tree blob at fdt. Therefore,
! 199: * fdt_move(fdt, fdt, fdt_totalsize(fdt))
! 200: * should always succeed.
! 201: *
! 202: * returns:
! 203: * 0, on success
! 204: * -FDT_ERR_NOSPACE, bufsize is insufficient to contain the device tree
! 205: * -FDT_ERR_BADMAGIC,
! 206: * -FDT_ERR_BADVERSION,
! 207: * -FDT_ERR_BADSTATE, standard meanings
! 208: */
! 209: int fdt_move(const void *fdt, void *buf, int bufsize);
! 210:
! 211: /**********************************************************************/
! 212: /* Read-only functions */
! 213: /**********************************************************************/
! 214:
! 215: /**
! 216: * fdt_string - retrieve a string from the strings block of a device tree
! 217: * @fdt: pointer to the device tree blob
! 218: * @stroffset: offset of the string within the strings block (native endian)
! 219: *
! 220: * fdt_string() retrieves a pointer to a single string from the
! 221: * strings block of the device tree blob at fdt.
! 222: *
! 223: * returns:
! 224: * a pointer to the string, on success
! 225: * NULL, if stroffset is out of bounds
! 226: */
! 227: const char *fdt_string(const void *fdt, int stroffset);
! 228:
! 229: /**
! 230: * fdt_num_mem_rsv - retrieve the number of memory reserve map entries
! 231: * @fdt: pointer to the device tree blob
! 232: *
! 233: * Returns the number of entries in the device tree blob's memory
! 234: * reservation map. This does not include the terminating 0,0 entry
! 235: * or any other (0,0) entries reserved for expansion.
! 236: *
! 237: * returns:
! 238: * the number of entries
! 239: */
! 240: int fdt_num_mem_rsv(const void *fdt);
! 241:
! 242: /**
! 243: * fdt_get_mem_rsv - retrieve one memory reserve map entry
! 244: * @fdt: pointer to the device tree blob
! 245: * @address, @size: pointers to 64-bit variables
! 246: *
! 247: * On success, *address and *size will contain the address and size of
! 248: * the n-th reserve map entry from the device tree blob, in
! 249: * native-endian format.
! 250: *
! 251: * returns:
! 252: * 0, on success
! 253: * -FDT_ERR_BADMAGIC,
! 254: * -FDT_ERR_BADVERSION,
! 255: * -FDT_ERR_BADSTATE, standard meanings
! 256: */
! 257: int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size);
! 258:
! 259: /**
! 260: * fdt_subnode_offset_namelen - find a subnode based on substring
! 261: * @fdt: pointer to the device tree blob
! 262: * @parentoffset: structure block offset of a node
! 263: * @name: name of the subnode to locate
! 264: * @namelen: number of characters of name to consider
! 265: *
! 266: * Identical to fdt_subnode_offset(), but only examine the first
! 267: * namelen characters of name for matching the subnode name. This is
! 268: * useful for finding subnodes based on a portion of a larger string,
! 269: * such as a full path.
! 270: */
! 271: int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
! 272: const char *name, int namelen);
! 273: /**
! 274: * fdt_subnode_offset - find a subnode of a given node
! 275: * @fdt: pointer to the device tree blob
! 276: * @parentoffset: structure block offset of a node
! 277: * @name: name of the subnode to locate
! 278: *
! 279: * fdt_subnode_offset() finds a subnode of the node at structure block
! 280: * offset parentoffset with the given name. name may include a unit
! 281: * address, in which case fdt_subnode_offset() will find the subnode
! 282: * with that unit address, or the unit address may be omitted, in
! 283: * which case fdt_subnode_offset() will find an arbitrary subnode
! 284: * whose name excluding unit address matches the given name.
! 285: *
! 286: * returns:
! 287: * structure block offset of the requested subnode (>=0), on success
! 288: * -FDT_ERR_NOTFOUND, if the requested subnode does not exist
! 289: * -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag
! 290: * -FDT_ERR_BADMAGIC,
! 291: * -FDT_ERR_BADVERSION,
! 292: * -FDT_ERR_BADSTATE,
! 293: * -FDT_ERR_BADSTRUCTURE,
! 294: * -FDT_ERR_TRUNCATED, standard meanings.
! 295: */
! 296: int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name);
! 297:
! 298: /**
! 299: * fdt_path_offset - find a tree node by its full path
! 300: * @fdt: pointer to the device tree blob
! 301: * @path: full path of the node to locate
! 302: *
! 303: * fdt_path_offset() finds a node of a given path in the device tree.
! 304: * Each path component may omit the unit address portion, but the
! 305: * results of this are undefined if any such path component is
! 306: * ambiguous (that is if there are multiple nodes at the relevant
! 307: * level matching the given component, differentiated only by unit
! 308: * address).
! 309: *
! 310: * returns:
! 311: * structure block offset of the node with the requested path (>=0), on success
! 312: * -FDT_ERR_BADPATH, given path does not begin with '/' or is invalid
! 313: * -FDT_ERR_NOTFOUND, if the requested node does not exist
! 314: * -FDT_ERR_BADMAGIC,
! 315: * -FDT_ERR_BADVERSION,
! 316: * -FDT_ERR_BADSTATE,
! 317: * -FDT_ERR_BADSTRUCTURE,
! 318: * -FDT_ERR_TRUNCATED, standard meanings.
! 319: */
! 320: int fdt_path_offset(const void *fdt, const char *path);
! 321:
! 322: /**
! 323: * fdt_get_name - retrieve the name of a given node
! 324: * @fdt: pointer to the device tree blob
! 325: * @nodeoffset: structure block offset of the starting node
! 326: * @lenp: pointer to an integer variable (will be overwritten) or NULL
! 327: *
! 328: * fdt_get_name() retrieves the name (including unit address) of the
! 329: * device tree node at structure block offset nodeoffset. If lenp is
! 330: * non-NULL, the length of this name is also returned, in the integer
! 331: * pointed to by lenp.
! 332: *
! 333: * returns:
! 334: * pointer to the node's name, on success
! 335: * If lenp is non-NULL, *lenp contains the length of that name (>=0)
! 336: * NULL, on error
! 337: * if lenp is non-NULL *lenp contains an error code (<0):
! 338: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 339: * -FDT_ERR_BADMAGIC,
! 340: * -FDT_ERR_BADVERSION,
! 341: * -FDT_ERR_BADSTATE, standard meanings
! 342: */
! 343: const char *fdt_get_name(const void *fdt, int nodeoffset, int *lenp);
! 344:
! 345: /**
! 346: * fdt_get_property_namelen - find a property based on substring
! 347: * @fdt: pointer to the device tree blob
! 348: * @nodeoffset: offset of the node whose property to find
! 349: * @name: name of the property to find
! 350: * @namelen: number of characters of name to consider
! 351: * @lenp: pointer to an integer variable (will be overwritten) or NULL
! 352: *
! 353: * Identical to fdt_get_property_namelen(), but only examine the first
! 354: * namelen characters of name for matching the property name.
! 355: */
! 356: const struct fdt_property *fdt_get_property_namelen(const void *fdt,
! 357: int nodeoffset,
! 358: const char *name,
! 359: int namelen, int *lenp);
! 360:
! 361: /**
! 362: * fdt_get_property - find a given property in a given node
! 363: * @fdt: pointer to the device tree blob
! 364: * @nodeoffset: offset of the node whose property to find
! 365: * @name: name of the property to find
! 366: * @lenp: pointer to an integer variable (will be overwritten) or NULL
! 367: *
! 368: * fdt_get_property() retrieves a pointer to the fdt_property
! 369: * structure within the device tree blob corresponding to the property
! 370: * named 'name' of the node at offset nodeoffset. If lenp is
! 371: * non-NULL, the length of the property value is also returned, in the
! 372: * integer pointed to by lenp.
! 373: *
! 374: * returns:
! 375: * pointer to the structure representing the property
! 376: * if lenp is non-NULL, *lenp contains the length of the property
! 377: * value (>=0)
! 378: * NULL, on error
! 379: * if lenp is non-NULL, *lenp contains an error code (<0):
! 380: * -FDT_ERR_NOTFOUND, node does not have named property
! 381: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 382: * -FDT_ERR_BADMAGIC,
! 383: * -FDT_ERR_BADVERSION,
! 384: * -FDT_ERR_BADSTATE,
! 385: * -FDT_ERR_BADSTRUCTURE,
! 386: * -FDT_ERR_TRUNCATED, standard meanings
! 387: */
! 388: const struct fdt_property *fdt_get_property(const void *fdt, int nodeoffset,
! 389: const char *name, int *lenp);
! 390: static inline struct fdt_property *fdt_get_property_w(void *fdt, int nodeoffset,
! 391: const char *name,
! 392: int *lenp)
! 393: {
! 394: return (struct fdt_property *)(uintptr_t)
! 395: fdt_get_property(fdt, nodeoffset, name, lenp);
! 396: }
! 397:
! 398: /**
! 399: * fdt_getprop_namelen - get property value based on substring
! 400: * @fdt: pointer to the device tree blob
! 401: * @nodeoffset: offset of the node whose property to find
! 402: * @name: name of the property to find
! 403: * @namelen: number of characters of name to consider
! 404: * @lenp: pointer to an integer variable (will be overwritten) or NULL
! 405: *
! 406: * Identical to fdt_getprop(), but only examine the first namelen
! 407: * characters of name for matching the property name.
! 408: */
! 409: const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
! 410: const char *name, int namelen, int *lenp);
! 411:
! 412: /**
! 413: * fdt_getprop - retrieve the value of a given property
! 414: * @fdt: pointer to the device tree blob
! 415: * @nodeoffset: offset of the node whose property to find
! 416: * @name: name of the property to find
! 417: * @lenp: pointer to an integer variable (will be overwritten) or NULL
! 418: *
! 419: * fdt_getprop() retrieves a pointer to the value of the property
! 420: * named 'name' of the node at offset nodeoffset (this will be a
! 421: * pointer to within the device blob itself, not a copy of the value).
! 422: * If lenp is non-NULL, the length of the property value is also
! 423: * returned, in the integer pointed to by lenp.
! 424: *
! 425: * returns:
! 426: * pointer to the property's value
! 427: * if lenp is non-NULL, *lenp contains the length of the property
! 428: * value (>=0)
! 429: * NULL, on error
! 430: * if lenp is non-NULL, *lenp contains an error code (<0):
! 431: * -FDT_ERR_NOTFOUND, node does not have named property
! 432: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 433: * -FDT_ERR_BADMAGIC,
! 434: * -FDT_ERR_BADVERSION,
! 435: * -FDT_ERR_BADSTATE,
! 436: * -FDT_ERR_BADSTRUCTURE,
! 437: * -FDT_ERR_TRUNCATED, standard meanings
! 438: */
! 439: const void *fdt_getprop(const void *fdt, int nodeoffset,
! 440: const char *name, int *lenp);
! 441: static inline void *fdt_getprop_w(void *fdt, int nodeoffset,
! 442: const char *name, int *lenp)
! 443: {
! 444: return (void *)(uintptr_t)fdt_getprop(fdt, nodeoffset, name, lenp);
! 445: }
! 446:
! 447: /**
! 448: * fdt_get_phandle - retrieve the phandle of a given node
! 449: * @fdt: pointer to the device tree blob
! 450: * @nodeoffset: structure block offset of the node
! 451: *
! 452: * fdt_get_phandle() retrieves the phandle of the device tree node at
! 453: * structure block offset nodeoffset.
! 454: *
! 455: * returns:
! 456: * the phandle of the node at nodeoffset, on success (!= 0, != -1)
! 457: * 0, if the node has no phandle, or another error occurs
! 458: */
! 459: uint32_t fdt_get_phandle(const void *fdt, int nodeoffset);
! 460:
! 461: /**
! 462: * fdt_get_alias_namelen - get alias based on substring
! 463: * @fdt: pointer to the device tree blob
! 464: * @name: name of the alias th look up
! 465: * @namelen: number of characters of name to consider
! 466: *
! 467: * Identical to fdt_get_alias(), but only examine the first namelen
! 468: * characters of name for matching the alias name.
! 469: */
! 470: const char *fdt_get_alias_namelen(const void *fdt,
! 471: const char *name, int namelen);
! 472:
! 473: /**
! 474: * fdt_get_alias - retreive the path referenced by a given alias
! 475: * @fdt: pointer to the device tree blob
! 476: * @name: name of the alias th look up
! 477: *
! 478: * fdt_get_alias() retrieves the value of a given alias. That is, the
! 479: * value of the property named 'name' in the node /aliases.
! 480: *
! 481: * returns:
! 482: * a pointer to the expansion of the alias named 'name', of it exists
! 483: * NULL, if the given alias or the /aliases node does not exist
! 484: */
! 485: const char *fdt_get_alias(const void *fdt, const char *name);
! 486:
! 487: /**
! 488: * fdt_get_path - determine the full path of a node
! 489: * @fdt: pointer to the device tree blob
! 490: * @nodeoffset: offset of the node whose path to find
! 491: * @buf: character buffer to contain the returned path (will be overwritten)
! 492: * @buflen: size of the character buffer at buf
! 493: *
! 494: * fdt_get_path() computes the full path of the node at offset
! 495: * nodeoffset, and records that path in the buffer at buf.
! 496: *
! 497: * NOTE: This function is expensive, as it must scan the device tree
! 498: * structure from the start to nodeoffset.
! 499: *
! 500: * returns:
! 501: * 0, on success
! 502: * buf contains the absolute path of the node at
! 503: * nodeoffset, as a NUL-terminated string.
! 504: * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
! 505: * -FDT_ERR_NOSPACE, the path of the given node is longer than (bufsize-1)
! 506: * characters and will not fit in the given buffer.
! 507: * -FDT_ERR_BADMAGIC,
! 508: * -FDT_ERR_BADVERSION,
! 509: * -FDT_ERR_BADSTATE,
! 510: * -FDT_ERR_BADSTRUCTURE, standard meanings
! 511: */
! 512: int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen);
! 513:
! 514: /**
! 515: * fdt_supernode_atdepth_offset - find a specific ancestor of a node
! 516: * @fdt: pointer to the device tree blob
! 517: * @nodeoffset: offset of the node whose parent to find
! 518: * @supernodedepth: depth of the ancestor to find
! 519: * @nodedepth: pointer to an integer variable (will be overwritten) or NULL
! 520: *
! 521: * fdt_supernode_atdepth_offset() finds an ancestor of the given node
! 522: * at a specific depth from the root (where the root itself has depth
! 523: * 0, its immediate subnodes depth 1 and so forth). So
! 524: * fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, NULL);
! 525: * will always return 0, the offset of the root node. If the node at
! 526: * nodeoffset has depth D, then:
! 527: * fdt_supernode_atdepth_offset(fdt, nodeoffset, D, NULL);
! 528: * will return nodeoffset itself.
! 529: *
! 530: * NOTE: This function is expensive, as it must scan the device tree
! 531: * structure from the start to nodeoffset.
! 532: *
! 533: * returns:
! 534:
! 535: * structure block offset of the node at node offset's ancestor
! 536: * of depth supernodedepth (>=0), on success
! 537: * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
! 538: * -FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of nodeoffset
! 539: * -FDT_ERR_BADMAGIC,
! 540: * -FDT_ERR_BADVERSION,
! 541: * -FDT_ERR_BADSTATE,
! 542: * -FDT_ERR_BADSTRUCTURE, standard meanings
! 543: */
! 544: int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
! 545: int supernodedepth, int *nodedepth);
! 546:
! 547: /**
! 548: * fdt_node_depth - find the depth of a given node
! 549: * @fdt: pointer to the device tree blob
! 550: * @nodeoffset: offset of the node whose parent to find
! 551: *
! 552: * fdt_node_depth() finds the depth of a given node. The root node
! 553: * has depth 0, its immediate subnodes depth 1 and so forth.
! 554: *
! 555: * NOTE: This function is expensive, as it must scan the device tree
! 556: * structure from the start to nodeoffset.
! 557: *
! 558: * returns:
! 559: * depth of the node at nodeoffset (>=0), on success
! 560: * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
! 561: * -FDT_ERR_BADMAGIC,
! 562: * -FDT_ERR_BADVERSION,
! 563: * -FDT_ERR_BADSTATE,
! 564: * -FDT_ERR_BADSTRUCTURE, standard meanings
! 565: */
! 566: int fdt_node_depth(const void *fdt, int nodeoffset);
! 567:
! 568: /**
! 569: * fdt_parent_offset - find the parent of a given node
! 570: * @fdt: pointer to the device tree blob
! 571: * @nodeoffset: offset of the node whose parent to find
! 572: *
! 573: * fdt_parent_offset() locates the parent node of a given node (that
! 574: * is, it finds the offset of the node which contains the node at
! 575: * nodeoffset as a subnode).
! 576: *
! 577: * NOTE: This function is expensive, as it must scan the device tree
! 578: * structure from the start to nodeoffset, *twice*.
! 579: *
! 580: * returns:
! 581: * structure block offset of the parent of the node at nodeoffset
! 582: * (>=0), on success
! 583: * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
! 584: * -FDT_ERR_BADMAGIC,
! 585: * -FDT_ERR_BADVERSION,
! 586: * -FDT_ERR_BADSTATE,
! 587: * -FDT_ERR_BADSTRUCTURE, standard meanings
! 588: */
! 589: int fdt_parent_offset(const void *fdt, int nodeoffset);
! 590:
! 591: /**
! 592: * fdt_node_offset_by_prop_value - find nodes with a given property value
! 593: * @fdt: pointer to the device tree blob
! 594: * @startoffset: only find nodes after this offset
! 595: * @propname: property name to check
! 596: * @propval: property value to search for
! 597: * @proplen: length of the value in propval
! 598: *
! 599: * fdt_node_offset_by_prop_value() returns the offset of the first
! 600: * node after startoffset, which has a property named propname whose
! 601: * value is of length proplen and has value equal to propval; or if
! 602: * startoffset is -1, the very first such node in the tree.
! 603: *
! 604: * To iterate through all nodes matching the criterion, the following
! 605: * idiom can be used:
! 606: * offset = fdt_node_offset_by_prop_value(fdt, -1, propname,
! 607: * propval, proplen);
! 608: * while (offset != -FDT_ERR_NOTFOUND) {
! 609: * ... other code here ...
! 610: * offset = fdt_node_offset_by_prop_value(fdt, offset, propname,
! 611: * propval, proplen);
! 612: * }
! 613: *
! 614: * Note the -1 in the first call to the function, if 0 is used here
! 615: * instead, the function will never locate the root node, even if it
! 616: * matches the criterion.
! 617: *
! 618: * returns:
! 619: * structure block offset of the located node (>= 0, >startoffset),
! 620: * on success
! 621: * -FDT_ERR_NOTFOUND, no node matching the criterion exists in the
! 622: * tree after startoffset
! 623: * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
! 624: * -FDT_ERR_BADMAGIC,
! 625: * -FDT_ERR_BADVERSION,
! 626: * -FDT_ERR_BADSTATE,
! 627: * -FDT_ERR_BADSTRUCTURE, standard meanings
! 628: */
! 629: int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
! 630: const char *propname,
! 631: const void *propval, int proplen);
! 632:
! 633: /**
! 634: * fdt_node_offset_by_phandle - find the node with a given phandle
! 635: * @fdt: pointer to the device tree blob
! 636: * @phandle: phandle value
! 637: *
! 638: * fdt_node_offset_by_phandle() returns the offset of the node
! 639: * which has the given phandle value. If there is more than one node
! 640: * in the tree with the given phandle (an invalid tree), results are
! 641: * undefined.
! 642: *
! 643: * returns:
! 644: * structure block offset of the located node (>= 0), on success
! 645: * -FDT_ERR_NOTFOUND, no node with that phandle exists
! 646: * -FDT_ERR_BADPHANDLE, given phandle value was invalid (0 or -1)
! 647: * -FDT_ERR_BADMAGIC,
! 648: * -FDT_ERR_BADVERSION,
! 649: * -FDT_ERR_BADSTATE,
! 650: * -FDT_ERR_BADSTRUCTURE, standard meanings
! 651: */
! 652: int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle);
! 653:
! 654: /**
! 655: * fdt_node_check_compatible: check a node's compatible property
! 656: * @fdt: pointer to the device tree blob
! 657: * @nodeoffset: offset of a tree node
! 658: * @compatible: string to match against
! 659: *
! 660: *
! 661: * fdt_node_check_compatible() returns 0 if the given node contains a
! 662: * 'compatible' property with the given string as one of its elements,
! 663: * it returns non-zero otherwise, or on error.
! 664: *
! 665: * returns:
! 666: * 0, if the node has a 'compatible' property listing the given string
! 667: * 1, if the node has a 'compatible' property, but it does not list
! 668: * the given string
! 669: * -FDT_ERR_NOTFOUND, if the given node has no 'compatible' property
! 670: * -FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag
! 671: * -FDT_ERR_BADMAGIC,
! 672: * -FDT_ERR_BADVERSION,
! 673: * -FDT_ERR_BADSTATE,
! 674: * -FDT_ERR_BADSTRUCTURE, standard meanings
! 675: */
! 676: int fdt_node_check_compatible(const void *fdt, int nodeoffset,
! 677: const char *compatible);
! 678:
! 679: /**
! 680: * fdt_node_offset_by_compatible - find nodes with a given 'compatible' value
! 681: * @fdt: pointer to the device tree blob
! 682: * @startoffset: only find nodes after this offset
! 683: * @compatible: 'compatible' string to match against
! 684: *
! 685: * fdt_node_offset_by_compatible() returns the offset of the first
! 686: * node after startoffset, which has a 'compatible' property which
! 687: * lists the given compatible string; or if startoffset is -1, the
! 688: * very first such node in the tree.
! 689: *
! 690: * To iterate through all nodes matching the criterion, the following
! 691: * idiom can be used:
! 692: * offset = fdt_node_offset_by_compatible(fdt, -1, compatible);
! 693: * while (offset != -FDT_ERR_NOTFOUND) {
! 694: * ... other code here ...
! 695: * offset = fdt_node_offset_by_compatible(fdt, offset, compatible);
! 696: * }
! 697: *
! 698: * Note the -1 in the first call to the function, if 0 is used here
! 699: * instead, the function will never locate the root node, even if it
! 700: * matches the criterion.
! 701: *
! 702: * returns:
! 703: * structure block offset of the located node (>= 0, >startoffset),
! 704: * on success
! 705: * -FDT_ERR_NOTFOUND, no node matching the criterion exists in the
! 706: * tree after startoffset
! 707: * -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
! 708: * -FDT_ERR_BADMAGIC,
! 709: * -FDT_ERR_BADVERSION,
! 710: * -FDT_ERR_BADSTATE,
! 711: * -FDT_ERR_BADSTRUCTURE, standard meanings
! 712: */
! 713: int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
! 714: const char *compatible);
! 715:
! 716: /**********************************************************************/
! 717: /* Write-in-place functions */
! 718: /**********************************************************************/
! 719:
! 720: /**
! 721: * fdt_setprop_inplace - change a property's value, but not its size
! 722: * @fdt: pointer to the device tree blob
! 723: * @nodeoffset: offset of the node whose property to change
! 724: * @name: name of the property to change
! 725: * @val: pointer to data to replace the property value with
! 726: * @len: length of the property value
! 727: *
! 728: * fdt_setprop_inplace() replaces the value of a given property with
! 729: * the data in val, of length len. This function cannot change the
! 730: * size of a property, and so will only work if len is equal to the
! 731: * current length of the property.
! 732: *
! 733: * This function will alter only the bytes in the blob which contain
! 734: * the given property value, and will not alter or move any other part
! 735: * of the tree.
! 736: *
! 737: * returns:
! 738: * 0, on success
! 739: * -FDT_ERR_NOSPACE, if len is not equal to the property's current length
! 740: * -FDT_ERR_NOTFOUND, node does not have the named property
! 741: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 742: * -FDT_ERR_BADMAGIC,
! 743: * -FDT_ERR_BADVERSION,
! 744: * -FDT_ERR_BADSTATE,
! 745: * -FDT_ERR_BADSTRUCTURE,
! 746: * -FDT_ERR_TRUNCATED, standard meanings
! 747: */
! 748: int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
! 749: const void *val, int len);
! 750:
! 751: /**
! 752: * fdt_setprop_inplace_cell - change the value of a single-cell property
! 753: * @fdt: pointer to the device tree blob
! 754: * @nodeoffset: offset of the node whose property to change
! 755: * @name: name of the property to change
! 756: * @val: cell (32-bit integer) value to replace the property with
! 757: *
! 758: * fdt_setprop_inplace_cell() replaces the value of a given property
! 759: * with the 32-bit integer cell value in val, converting val to
! 760: * big-endian if necessary. This function cannot change the size of a
! 761: * property, and so will only work if the property already exists and
! 762: * has length 4.
! 763: *
! 764: * This function will alter only the bytes in the blob which contain
! 765: * the given property value, and will not alter or move any other part
! 766: * of the tree.
! 767: *
! 768: * returns:
! 769: * 0, on success
! 770: * -FDT_ERR_NOSPACE, if the property's length is not equal to 4
! 771: * -FDT_ERR_NOTFOUND, node does not have the named property
! 772: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 773: * -FDT_ERR_BADMAGIC,
! 774: * -FDT_ERR_BADVERSION,
! 775: * -FDT_ERR_BADSTATE,
! 776: * -FDT_ERR_BADSTRUCTURE,
! 777: * -FDT_ERR_TRUNCATED, standard meanings
! 778: */
! 779: static inline int fdt_setprop_inplace_cell(void *fdt, int nodeoffset,
! 780: const char *name, uint32_t val)
! 781: {
! 782: val = cpu_to_fdt32(val);
! 783: return fdt_setprop_inplace(fdt, nodeoffset, name, &val, sizeof(val));
! 784: }
! 785:
! 786: /**
! 787: * fdt_nop_property - replace a property with nop tags
! 788: * @fdt: pointer to the device tree blob
! 789: * @nodeoffset: offset of the node whose property to nop
! 790: * @name: name of the property to nop
! 791: *
! 792: * fdt_nop_property() will replace a given property's representation
! 793: * in the blob with FDT_NOP tags, effectively removing it from the
! 794: * tree.
! 795: *
! 796: * This function will alter only the bytes in the blob which contain
! 797: * the property, and will not alter or move any other part of the
! 798: * tree.
! 799: *
! 800: * returns:
! 801: * 0, on success
! 802: * -FDT_ERR_NOTFOUND, node does not have the named property
! 803: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 804: * -FDT_ERR_BADMAGIC,
! 805: * -FDT_ERR_BADVERSION,
! 806: * -FDT_ERR_BADSTATE,
! 807: * -FDT_ERR_BADSTRUCTURE,
! 808: * -FDT_ERR_TRUNCATED, standard meanings
! 809: */
! 810: int fdt_nop_property(void *fdt, int nodeoffset, const char *name);
! 811:
! 812: /**
! 813: * fdt_nop_node - replace a node (subtree) with nop tags
! 814: * @fdt: pointer to the device tree blob
! 815: * @nodeoffset: offset of the node to nop
! 816: *
! 817: * fdt_nop_node() will replace a given node's representation in the
! 818: * blob, including all its subnodes, if any, with FDT_NOP tags,
! 819: * effectively removing it from the tree.
! 820: *
! 821: * This function will alter only the bytes in the blob which contain
! 822: * the node and its properties and subnodes, and will not alter or
! 823: * move any other part of the tree.
! 824: *
! 825: * returns:
! 826: * 0, on success
! 827: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 828: * -FDT_ERR_BADMAGIC,
! 829: * -FDT_ERR_BADVERSION,
! 830: * -FDT_ERR_BADSTATE,
! 831: * -FDT_ERR_BADSTRUCTURE,
! 832: * -FDT_ERR_TRUNCATED, standard meanings
! 833: */
! 834: int fdt_nop_node(void *fdt, int nodeoffset);
! 835:
! 836: /**********************************************************************/
! 837: /* Sequential write functions */
! 838: /**********************************************************************/
! 839:
! 840: int fdt_create(void *buf, int bufsize);
! 841: int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size);
! 842: int fdt_finish_reservemap(void *fdt);
! 843: int fdt_begin_node(void *fdt, const char *name);
! 844: int fdt_property(void *fdt, const char *name, const void *val, int len);
! 845: static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val)
! 846: {
! 847: val = cpu_to_fdt32(val);
! 848: return fdt_property(fdt, name, &val, sizeof(val));
! 849: }
! 850: #define fdt_property_string(fdt, name, str) \
! 851: fdt_property(fdt, name, str, strlen(str)+1)
! 852: int fdt_end_node(void *fdt);
! 853: int fdt_finish(void *fdt);
! 854:
! 855: /**********************************************************************/
! 856: /* Read-write functions */
! 857: /**********************************************************************/
! 858:
! 859: int fdt_open_into(const void *fdt, void *buf, int bufsize);
! 860: int fdt_pack(void *fdt);
! 861:
! 862: /**
! 863: * fdt_add_mem_rsv - add one memory reserve map entry
! 864: * @fdt: pointer to the device tree blob
! 865: * @address, @size: 64-bit values (native endian)
! 866: *
! 867: * Adds a reserve map entry to the given blob reserving a region at
! 868: * address address of length size.
! 869: *
! 870: * This function will insert data into the reserve map and will
! 871: * therefore change the indexes of some entries in the table.
! 872: *
! 873: * returns:
! 874: * 0, on success
! 875: * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
! 876: * contain the new reservation entry
! 877: * -FDT_ERR_BADMAGIC,
! 878: * -FDT_ERR_BADVERSION,
! 879: * -FDT_ERR_BADSTATE,
! 880: * -FDT_ERR_BADSTRUCTURE,
! 881: * -FDT_ERR_BADLAYOUT,
! 882: * -FDT_ERR_TRUNCATED, standard meanings
! 883: */
! 884: int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size);
! 885:
! 886: /**
! 887: * fdt_del_mem_rsv - remove a memory reserve map entry
! 888: * @fdt: pointer to the device tree blob
! 889: * @n: entry to remove
! 890: *
! 891: * fdt_del_mem_rsv() removes the n-th memory reserve map entry from
! 892: * the blob.
! 893: *
! 894: * This function will delete data from the reservation table and will
! 895: * therefore change the indexes of some entries in the table.
! 896: *
! 897: * returns:
! 898: * 0, on success
! 899: * -FDT_ERR_NOTFOUND, there is no entry of the given index (i.e. there
! 900: * are less than n+1 reserve map entries)
! 901: * -FDT_ERR_BADMAGIC,
! 902: * -FDT_ERR_BADVERSION,
! 903: * -FDT_ERR_BADSTATE,
! 904: * -FDT_ERR_BADSTRUCTURE,
! 905: * -FDT_ERR_BADLAYOUT,
! 906: * -FDT_ERR_TRUNCATED, standard meanings
! 907: */
! 908: int fdt_del_mem_rsv(void *fdt, int n);
! 909:
! 910: /**
! 911: * fdt_set_name - change the name of a given node
! 912: * @fdt: pointer to the device tree blob
! 913: * @nodeoffset: structure block offset of a node
! 914: * @name: name to give the node
! 915: *
! 916: * fdt_set_name() replaces the name (including unit address, if any)
! 917: * of the given node with the given string. NOTE: this function can't
! 918: * efficiently check if the new name is unique amongst the given
! 919: * node's siblings; results are undefined if this function is invoked
! 920: * with a name equal to one of the given node's siblings.
! 921: *
! 922: * This function may insert or delete data from the blob, and will
! 923: * therefore change the offsets of some existing nodes.
! 924: *
! 925: * returns:
! 926: * 0, on success
! 927: * -FDT_ERR_NOSPACE, there is insufficient free space in the blob
! 928: * to contain the new name
! 929: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 930: * -FDT_ERR_BADMAGIC,
! 931: * -FDT_ERR_BADVERSION,
! 932: * -FDT_ERR_BADSTATE, standard meanings
! 933: */
! 934: int fdt_set_name(void *fdt, int nodeoffset, const char *name);
! 935:
! 936: /**
! 937: * fdt_setprop - create or change a property
! 938: * @fdt: pointer to the device tree blob
! 939: * @nodeoffset: offset of the node whose property to change
! 940: * @name: name of the property to change
! 941: * @val: pointer to data to set the property value to
! 942: * @len: length of the property value
! 943: *
! 944: * fdt_setprop() sets the value of the named property in the given
! 945: * node to the given value and length, creating the property if it
! 946: * does not already exist.
! 947: *
! 948: * This function may insert or delete data from the blob, and will
! 949: * therefore change the offsets of some existing nodes.
! 950: *
! 951: * returns:
! 952: * 0, on success
! 953: * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
! 954: * contain the new property value
! 955: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 956: * -FDT_ERR_BADLAYOUT,
! 957: * -FDT_ERR_BADMAGIC,
! 958: * -FDT_ERR_BADVERSION,
! 959: * -FDT_ERR_BADSTATE,
! 960: * -FDT_ERR_BADSTRUCTURE,
! 961: * -FDT_ERR_BADLAYOUT,
! 962: * -FDT_ERR_TRUNCATED, standard meanings
! 963: */
! 964: int fdt_setprop(void *fdt, int nodeoffset, const char *name,
! 965: const void *val, int len);
! 966:
! 967: /**
! 968: * fdt_setprop_cell - set a property to a single cell value
! 969: * @fdt: pointer to the device tree blob
! 970: * @nodeoffset: offset of the node whose property to change
! 971: * @name: name of the property to change
! 972: * @val: 32-bit integer value for the property (native endian)
! 973: *
! 974: * fdt_setprop_cell() sets the value of the named property in the
! 975: * given node to the given cell value (converting to big-endian if
! 976: * necessary), or creates a new property with that value if it does
! 977: * not already exist.
! 978: *
! 979: * This function may insert or delete data from the blob, and will
! 980: * therefore change the offsets of some existing nodes.
! 981: *
! 982: * returns:
! 983: * 0, on success
! 984: * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
! 985: * contain the new property value
! 986: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 987: * -FDT_ERR_BADLAYOUT,
! 988: * -FDT_ERR_BADMAGIC,
! 989: * -FDT_ERR_BADVERSION,
! 990: * -FDT_ERR_BADSTATE,
! 991: * -FDT_ERR_BADSTRUCTURE,
! 992: * -FDT_ERR_BADLAYOUT,
! 993: * -FDT_ERR_TRUNCATED, standard meanings
! 994: */
! 995: static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name,
! 996: uint32_t val)
! 997: {
! 998: val = cpu_to_fdt32(val);
! 999: return fdt_setprop(fdt, nodeoffset, name, &val, sizeof(val));
! 1000: }
! 1001:
! 1002: /**
! 1003: * fdt_setprop_string - set a property to a string value
! 1004: * @fdt: pointer to the device tree blob
! 1005: * @nodeoffset: offset of the node whose property to change
! 1006: * @name: name of the property to change
! 1007: * @str: string value for the property
! 1008: *
! 1009: * fdt_setprop_string() sets the value of the named property in the
! 1010: * given node to the given string value (using the length of the
! 1011: * string to determine the new length of the property), or creates a
! 1012: * new property with that value if it does not already exist.
! 1013: *
! 1014: * This function may insert or delete data from the blob, and will
! 1015: * therefore change the offsets of some existing nodes.
! 1016: *
! 1017: * returns:
! 1018: * 0, on success
! 1019: * -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
! 1020: * contain the new property value
! 1021: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 1022: * -FDT_ERR_BADLAYOUT,
! 1023: * -FDT_ERR_BADMAGIC,
! 1024: * -FDT_ERR_BADVERSION,
! 1025: * -FDT_ERR_BADSTATE,
! 1026: * -FDT_ERR_BADSTRUCTURE,
! 1027: * -FDT_ERR_BADLAYOUT,
! 1028: * -FDT_ERR_TRUNCATED, standard meanings
! 1029: */
! 1030: #define fdt_setprop_string(fdt, nodeoffset, name, str) \
! 1031: fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
! 1032:
! 1033: /**
! 1034: * fdt_delprop - delete a property
! 1035: * @fdt: pointer to the device tree blob
! 1036: * @nodeoffset: offset of the node whose property to nop
! 1037: * @name: name of the property to nop
! 1038: *
! 1039: * fdt_del_property() will delete the given property.
! 1040: *
! 1041: * This function will delete data from the blob, and will therefore
! 1042: * change the offsets of some existing nodes.
! 1043: *
! 1044: * returns:
! 1045: * 0, on success
! 1046: * -FDT_ERR_NOTFOUND, node does not have the named property
! 1047: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 1048: * -FDT_ERR_BADLAYOUT,
! 1049: * -FDT_ERR_BADMAGIC,
! 1050: * -FDT_ERR_BADVERSION,
! 1051: * -FDT_ERR_BADSTATE,
! 1052: * -FDT_ERR_BADSTRUCTURE,
! 1053: * -FDT_ERR_TRUNCATED, standard meanings
! 1054: */
! 1055: int fdt_delprop(void *fdt, int nodeoffset, const char *name);
! 1056:
! 1057: /**
! 1058: * fdt_add_subnode_namelen - creates a new node based on substring
! 1059: * @fdt: pointer to the device tree blob
! 1060: * @parentoffset: structure block offset of a node
! 1061: * @name: name of the subnode to locate
! 1062: * @namelen: number of characters of name to consider
! 1063: *
! 1064: * Identical to fdt_add_subnode(), but use only the first namelen
! 1065: * characters of name as the name of the new node. This is useful for
! 1066: * creating subnodes based on a portion of a larger string, such as a
! 1067: * full path.
! 1068: */
! 1069: int fdt_add_subnode_namelen(void *fdt, int parentoffset,
! 1070: const char *name, int namelen);
! 1071:
! 1072: /**
! 1073: * fdt_add_subnode - creates a new node
! 1074: * @fdt: pointer to the device tree blob
! 1075: * @parentoffset: structure block offset of a node
! 1076: * @name: name of the subnode to locate
! 1077: *
! 1078: * fdt_add_subnode() creates a new node as a subnode of the node at
! 1079: * structure block offset parentoffset, with the given name (which
! 1080: * should include the unit address, if any).
! 1081: *
! 1082: * This function will insert data into the blob, and will therefore
! 1083: * change the offsets of some existing nodes.
! 1084:
! 1085: * returns:
! 1086: * structure block offset of the created nodeequested subnode (>=0), on success
! 1087: * -FDT_ERR_NOTFOUND, if the requested subnode does not exist
! 1088: * -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag
! 1089: * -FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of
! 1090: * the given name
! 1091: * -FDT_ERR_NOSPACE, if there is insufficient free space in the
! 1092: * blob to contain the new node
! 1093: * -FDT_ERR_NOSPACE
! 1094: * -FDT_ERR_BADLAYOUT
! 1095: * -FDT_ERR_BADMAGIC,
! 1096: * -FDT_ERR_BADVERSION,
! 1097: * -FDT_ERR_BADSTATE,
! 1098: * -FDT_ERR_BADSTRUCTURE,
! 1099: * -FDT_ERR_TRUNCATED, standard meanings.
! 1100: */
! 1101: int fdt_add_subnode(void *fdt, int parentoffset, const char *name);
! 1102:
! 1103: /**
! 1104: * fdt_del_node - delete a node (subtree)
! 1105: * @fdt: pointer to the device tree blob
! 1106: * @nodeoffset: offset of the node to nop
! 1107: *
! 1108: * fdt_del_node() will remove the given node, including all its
! 1109: * subnodes if any, from the blob.
! 1110: *
! 1111: * This function will delete data from the blob, and will therefore
! 1112: * change the offsets of some existing nodes.
! 1113: *
! 1114: * returns:
! 1115: * 0, on success
! 1116: * -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
! 1117: * -FDT_ERR_BADLAYOUT,
! 1118: * -FDT_ERR_BADMAGIC,
! 1119: * -FDT_ERR_BADVERSION,
! 1120: * -FDT_ERR_BADSTATE,
! 1121: * -FDT_ERR_BADSTRUCTURE,
! 1122: * -FDT_ERR_TRUNCATED, standard meanings
! 1123: */
! 1124: int fdt_del_node(void *fdt, int nodeoffset);
! 1125:
! 1126: /**********************************************************************/
! 1127: /* Debugging / informational functions */
! 1128: /**********************************************************************/
! 1129:
! 1130: const char *fdt_strerror(int errval);
! 1131:
! 1132: #endif /* _LIBFDT_H */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to libfdt.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / uboot_mkimage / include