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/* Errors in device tree content */
 120#define FDT_ERR_BADNCELLS	14
 121	/* FDT_ERR_BADNCELLS: Device tree has a #address-cells, #size-cells
 122	 * or similar property with a bad format or value */
 123
 124#define FDT_ERR_BADVALUE	15
 125	/* FDT_ERR_BADVALUE: Device tree has a property with an unexpected
 126	 * value. For example: a property expected to contain a string list
 127	 * is not NUL-terminated within the length of its value. */
 128
 129#define FDT_ERR_MAX		15
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 130
 131/**********************************************************************/
 132/* Low-level functions (you probably don't need these)                */
 133/**********************************************************************/
 134
 
 135const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int checklen);
 
 136static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)
 137{
 138	return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen);
 139}
 140
 141uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);
 142
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 143/**********************************************************************/
 144/* Traversal functions                                                */
 145/**********************************************************************/
 146
 147int fdt_next_node(const void *fdt, int offset, int *depth);
 148
 149/**
 150 * fdt_first_subnode() - get offset of first direct subnode
 151 *
 152 * @fdt:	FDT blob
 153 * @offset:	Offset of node to check
 154 * @return offset of first subnode, or -FDT_ERR_NOTFOUND if there is none
 155 */
 156int fdt_first_subnode(const void *fdt, int offset);
 157
 158/**
 159 * fdt_next_subnode() - get offset of next direct subnode
 160 *
 161 * After first calling fdt_first_subnode(), call this function repeatedly to
 162 * get direct subnodes of a parent node.
 163 *
 164 * @fdt:	FDT blob
 165 * @offset:	Offset of previous subnode
 166 * @return offset of next subnode, or -FDT_ERR_NOTFOUND if there are no more
 167 * subnodes
 168 */
 169int fdt_next_subnode(const void *fdt, int offset);
 170
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 171/**********************************************************************/
 172/* General functions                                                  */
 173/**********************************************************************/
 174
 175#define fdt_get_header(fdt, field) \
 176	(fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))
 177#define fdt_magic(fdt) 			(fdt_get_header(fdt, magic))
 178#define fdt_totalsize(fdt)		(fdt_get_header(fdt, totalsize))
 179#define fdt_off_dt_struct(fdt)		(fdt_get_header(fdt, off_dt_struct))
 180#define fdt_off_dt_strings(fdt)		(fdt_get_header(fdt, off_dt_strings))
 181#define fdt_off_mem_rsvmap(fdt)		(fdt_get_header(fdt, off_mem_rsvmap))
 182#define fdt_version(fdt)		(fdt_get_header(fdt, version))
 183#define fdt_last_comp_version(fdt) 	(fdt_get_header(fdt, last_comp_version))
 184#define fdt_boot_cpuid_phys(fdt) 	(fdt_get_header(fdt, boot_cpuid_phys))
 185#define fdt_size_dt_strings(fdt) 	(fdt_get_header(fdt, size_dt_strings))
 186#define fdt_size_dt_struct(fdt)		(fdt_get_header(fdt, size_dt_struct))
 187
 188#define __fdt_set_hdr(name) \
 189	static inline void fdt_set_##name(void *fdt, uint32_t val) \
 190	{ \
 191		struct fdt_header *fdth = (struct fdt_header*)fdt; \
 192		fdth->name = cpu_to_fdt32(val); \
 193	}
 194__fdt_set_hdr(magic);
 195__fdt_set_hdr(totalsize);
 196__fdt_set_hdr(off_dt_struct);
 197__fdt_set_hdr(off_dt_strings);
 198__fdt_set_hdr(off_mem_rsvmap);
 199__fdt_set_hdr(version);
 200__fdt_set_hdr(last_comp_version);
 201__fdt_set_hdr(boot_cpuid_phys);
 202__fdt_set_hdr(size_dt_strings);
 203__fdt_set_hdr(size_dt_struct);
 204#undef __fdt_set_hdr
 
 
 
 
 
 
 
 
 
 
 
 205
 206/**
 207 * fdt_check_header - sanity check a device tree or possible device tree
 
 208 * @fdt: pointer to data which might be a flattened device tree
 209 *
 210 * fdt_check_header() checks that the given buffer contains what
 211 * appears to be a flattened device tree with sane information in its
 212 * header.
 
 213 *
 214 * returns:
 215 *     0, if the buffer appears to contain a valid device tree
 216 *     -FDT_ERR_BADMAGIC,
 217 *     -FDT_ERR_BADVERSION,
 218 *     -FDT_ERR_BADSTATE, standard meanings, as above
 
 219 */
 220int fdt_check_header(const void *fdt);
 221
 222/**
 223 * fdt_move - move a device tree around in memory
 224 * @fdt: pointer to the device tree to move
 225 * @buf: pointer to memory where the device is to be moved
 226 * @bufsize: size of the memory space at buf
 227 *
 228 * fdt_move() relocates, if possible, the device tree blob located at
 229 * fdt to the buffer at buf of size bufsize.  The buffer may overlap
 230 * with the existing device tree blob at fdt.  Therefore,
 231 *     fdt_move(fdt, fdt, fdt_totalsize(fdt))
 232 * should always succeed.
 233 *
 234 * returns:
 235 *     0, on success
 236 *     -FDT_ERR_NOSPACE, bufsize is insufficient to contain the device tree
 237 *     -FDT_ERR_BADMAGIC,
 238 *     -FDT_ERR_BADVERSION,
 239 *     -FDT_ERR_BADSTATE, standard meanings
 240 */
 241int fdt_move(const void *fdt, void *buf, int bufsize);
 242
 243/**********************************************************************/
 244/* Read-only functions                                                */
 245/**********************************************************************/
 246
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 247/**
 248 * fdt_string - retrieve a string from the strings block of a device tree
 249 * @fdt: pointer to the device tree blob
 250 * @stroffset: offset of the string within the strings block (native endian)
 251 *
 252 * fdt_string() retrieves a pointer to a single string from the
 253 * strings block of the device tree blob at fdt.
 254 *
 255 * returns:
 256 *     a pointer to the string, on success
 257 *     NULL, if stroffset is out of bounds
 258 */
 259const char *fdt_string(const void *fdt, int stroffset);
 260
 261/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 262 * fdt_num_mem_rsv - retrieve the number of memory reserve map entries
 263 * @fdt: pointer to the device tree blob
 264 *
 265 * Returns the number of entries in the device tree blob's memory
 266 * reservation map.  This does not include the terminating 0,0 entry
 267 * or any other (0,0) entries reserved for expansion.
 268 *
 269 * returns:
 270 *     the number of entries
 271 */
 272int fdt_num_mem_rsv(const void *fdt);
 273
 274/**
 275 * fdt_get_mem_rsv - retrieve one memory reserve map entry
 276 * @fdt: pointer to the device tree blob
 277 * @address, @size: pointers to 64-bit variables
 278 *
 279 * On success, *address and *size will contain the address and size of
 280 * the n-th reserve map entry from the device tree blob, in
 281 * native-endian format.
 282 *
 283 * returns:
 284 *     0, on success
 285 *     -FDT_ERR_BADMAGIC,
 286 *     -FDT_ERR_BADVERSION,
 287 *     -FDT_ERR_BADSTATE, standard meanings
 288 */
 289int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size);
 290
 291/**
 292 * fdt_subnode_offset_namelen - find a subnode based on substring
 293 * @fdt: pointer to the device tree blob
 294 * @parentoffset: structure block offset of a node
 295 * @name: name of the subnode to locate
 296 * @namelen: number of characters of name to consider
 297 *
 298 * Identical to fdt_subnode_offset(), but only examine the first
 299 * namelen characters of name for matching the subnode name.  This is
 300 * useful for finding subnodes based on a portion of a larger string,
 301 * such as a full path.
 302 */
 
 303int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
 304			       const char *name, int namelen);
 
 305/**
 306 * fdt_subnode_offset - find a subnode of a given node
 307 * @fdt: pointer to the device tree blob
 308 * @parentoffset: structure block offset of a node
 309 * @name: name of the subnode to locate
 310 *
 311 * fdt_subnode_offset() finds a subnode of the node at structure block
 312 * offset parentoffset with the given name.  name may include a unit
 313 * address, in which case fdt_subnode_offset() will find the subnode
 314 * with that unit address, or the unit address may be omitted, in
 315 * which case fdt_subnode_offset() will find an arbitrary subnode
 316 * whose name excluding unit address matches the given name.
 317 *
 318 * returns:
 319 *	structure block offset of the requested subnode (>=0), on success
 320 *	-FDT_ERR_NOTFOUND, if the requested subnode does not exist
 321 *	-FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag
 322 *      -FDT_ERR_BADMAGIC,
 
 323 *	-FDT_ERR_BADVERSION,
 324 *	-FDT_ERR_BADSTATE,
 325 *	-FDT_ERR_BADSTRUCTURE,
 326 *	-FDT_ERR_TRUNCATED, standard meanings.
 327 */
 328int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name);
 329
 330/**
 331 * fdt_path_offset_namelen - find a tree node by its full path
 332 * @fdt: pointer to the device tree blob
 333 * @path: full path of the node to locate
 334 * @namelen: number of characters of path to consider
 335 *
 336 * Identical to fdt_path_offset(), but only consider the first namelen
 337 * characters of path as the path name.
 338 */
 
 339int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen);
 
 340
 341/**
 342 * fdt_path_offset - find a tree node by its full path
 343 * @fdt: pointer to the device tree blob
 344 * @path: full path of the node to locate
 345 *
 346 * fdt_path_offset() finds a node of a given path in the device tree.
 347 * Each path component may omit the unit address portion, but the
 348 * results of this are undefined if any such path component is
 349 * ambiguous (that is if there are multiple nodes at the relevant
 350 * level matching the given component, differentiated only by unit
 351 * address).
 352 *
 353 * returns:
 354 *	structure block offset of the node with the requested path (>=0), on success
 
 355 *	-FDT_ERR_BADPATH, given path does not begin with '/' or is invalid
 356 *	-FDT_ERR_NOTFOUND, if the requested node does not exist
 357 *      -FDT_ERR_BADMAGIC,
 358 *	-FDT_ERR_BADVERSION,
 359 *	-FDT_ERR_BADSTATE,
 360 *	-FDT_ERR_BADSTRUCTURE,
 361 *	-FDT_ERR_TRUNCATED, standard meanings.
 362 */
 363int fdt_path_offset(const void *fdt, const char *path);
 364
 365/**
 366 * fdt_get_name - retrieve the name of a given node
 367 * @fdt: pointer to the device tree blob
 368 * @nodeoffset: structure block offset of the starting node
 369 * @lenp: pointer to an integer variable (will be overwritten) or NULL
 370 *
 371 * fdt_get_name() retrieves the name (including unit address) of the
 372 * device tree node at structure block offset nodeoffset.  If lenp is
 373 * non-NULL, the length of this name is also returned, in the integer
 374 * pointed to by lenp.
 375 *
 376 * returns:
 377 *	pointer to the node's name, on success
 378 *		If lenp is non-NULL, *lenp contains the length of that name (>=0)
 
 379 *	NULL, on error
 380 *		if lenp is non-NULL *lenp contains an error code (<0):
 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, standard meanings
 385 */
 386const char *fdt_get_name(const void *fdt, int nodeoffset, int *lenp);
 387
 388/**
 389 * fdt_first_property_offset - find the offset of a node's first property
 390 * @fdt: pointer to the device tree blob
 391 * @nodeoffset: structure block offset of a node
 392 *
 393 * fdt_first_property_offset() finds the first property of the node at
 394 * the given structure block offset.
 395 *
 396 * returns:
 397 *	structure block offset of the property (>=0), on success
 398 *	-FDT_ERR_NOTFOUND, if the requested node has no properties
 399 *	-FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_BEGIN_NODE tag
 400 *      -FDT_ERR_BADMAGIC,
 401 *	-FDT_ERR_BADVERSION,
 402 *	-FDT_ERR_BADSTATE,
 403 *	-FDT_ERR_BADSTRUCTURE,
 404 *	-FDT_ERR_TRUNCATED, standard meanings.
 405 */
 406int fdt_first_property_offset(const void *fdt, int nodeoffset);
 407
 408/**
 409 * fdt_next_property_offset - step through a node's properties
 410 * @fdt: pointer to the device tree blob
 411 * @offset: structure block offset of a property
 412 *
 413 * fdt_next_property_offset() finds the property immediately after the
 414 * one at the given structure block offset.  This will be a property
 415 * of the same node as the given property.
 416 *
 417 * returns:
 418 *	structure block offset of the next property (>=0), on success
 419 *	-FDT_ERR_NOTFOUND, if the given property is the last in its node
 420 *	-FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_PROP tag
 421 *      -FDT_ERR_BADMAGIC,
 422 *	-FDT_ERR_BADVERSION,
 423 *	-FDT_ERR_BADSTATE,
 424 *	-FDT_ERR_BADSTRUCTURE,
 425 *	-FDT_ERR_TRUNCATED, standard meanings.
 426 */
 427int fdt_next_property_offset(const void *fdt, int offset);
 428
 429/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 430 * fdt_get_property_by_offset - retrieve the property at a given offset
 431 * @fdt: pointer to the device tree blob
 432 * @offset: offset of the property to retrieve
 433 * @lenp: pointer to an integer variable (will be overwritten) or NULL
 434 *
 435 * fdt_get_property_by_offset() retrieves a pointer to the
 436 * fdt_property structure within the device tree blob at the given
 437 * offset.  If lenp is non-NULL, the length of the property value is
 438 * also returned, in the integer pointed to by lenp.
 439 *
 
 
 
 440 * returns:
 441 *	pointer to the structure representing the property
 442 *		if lenp is non-NULL, *lenp contains the length of the property
 443 *		value (>=0)
 444 *	NULL, on error
 445 *		if lenp is non-NULL, *lenp contains an error code (<0):
 446 *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag
 447 *		-FDT_ERR_BADMAGIC,
 448 *		-FDT_ERR_BADVERSION,
 449 *		-FDT_ERR_BADSTATE,
 450 *		-FDT_ERR_BADSTRUCTURE,
 451 *		-FDT_ERR_TRUNCATED, standard meanings
 452 */
 453const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
 454						      int offset,
 455						      int *lenp);
 456
 457/**
 458 * fdt_get_property_namelen - find a property based on substring
 459 * @fdt: pointer to the device tree blob
 460 * @nodeoffset: offset of the node whose property to find
 461 * @name: name of the property to find
 462 * @namelen: number of characters of name to consider
 463 * @lenp: pointer to an integer variable (will be overwritten) or NULL
 464 *
 465 * Identical to fdt_get_property(), but only examine the first namelen
 466 * characters of name for matching the property name.
 467 */
 
 468const struct fdt_property *fdt_get_property_namelen(const void *fdt,
 469						    int nodeoffset,
 470						    const char *name,
 471						    int namelen, int *lenp);
 
 472
 473/**
 474 * fdt_get_property - find a given property in a given node
 475 * @fdt: pointer to the device tree blob
 476 * @nodeoffset: offset of the node whose property to find
 477 * @name: name of the property to find
 478 * @lenp: pointer to an integer variable (will be overwritten) or NULL
 479 *
 480 * fdt_get_property() retrieves a pointer to the fdt_property
 481 * structure within the device tree blob corresponding to the property
 482 * named 'name' of the node at offset nodeoffset.  If lenp is
 483 * non-NULL, the length of the property value is also returned, in the
 484 * integer pointed to by lenp.
 485 *
 486 * returns:
 487 *	pointer to the structure representing the property
 488 *		if lenp is non-NULL, *lenp contains the length of the property
 489 *		value (>=0)
 490 *	NULL, on error
 491 *		if lenp is non-NULL, *lenp contains an error code (<0):
 492 *		-FDT_ERR_NOTFOUND, node does not have named property
 493 *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
 
 494 *		-FDT_ERR_BADMAGIC,
 495 *		-FDT_ERR_BADVERSION,
 496 *		-FDT_ERR_BADSTATE,
 497 *		-FDT_ERR_BADSTRUCTURE,
 498 *		-FDT_ERR_TRUNCATED, standard meanings
 499 */
 500const struct fdt_property *fdt_get_property(const void *fdt, int nodeoffset,
 501					    const char *name, int *lenp);
 502static inline struct fdt_property *fdt_get_property_w(void *fdt, int nodeoffset,
 503						      const char *name,
 504						      int *lenp)
 505{
 506	return (struct fdt_property *)(uintptr_t)
 507		fdt_get_property(fdt, nodeoffset, name, lenp);
 508}
 509
 510/**
 511 * fdt_getprop_by_offset - retrieve the value of a property at a given offset
 512 * @fdt: pointer to the device tree blob
 513 * @ffset: offset of the property to read
 514 * @namep: pointer to a string variable (will be overwritten) or NULL
 515 * @lenp: pointer to an integer variable (will be overwritten) or NULL
 516 *
 517 * fdt_getprop_by_offset() retrieves a pointer to the value of the
 518 * property at structure block offset 'offset' (this will be a pointer
 519 * to within the device blob itself, not a copy of the value).  If
 520 * lenp is non-NULL, the length of the property value is also
 521 * returned, in the integer pointed to by lenp.  If namep is non-NULL,
 522 * the property's namne will also be returned in the char * pointed to
 523 * by namep (this will be a pointer to within the device tree's string
 524 * block, not a new copy of the name).
 525 *
 526 * returns:
 527 *	pointer to the property's value
 528 *		if lenp is non-NULL, *lenp contains the length of the property
 529 *		value (>=0)
 530 *		if namep is non-NULL *namep contiains a pointer to the property
 531 *		name.
 532 *	NULL, on error
 533 *		if lenp is non-NULL, *lenp contains an error code (<0):
 534 *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag
 535 *		-FDT_ERR_BADMAGIC,
 536 *		-FDT_ERR_BADVERSION,
 537 *		-FDT_ERR_BADSTATE,
 538 *		-FDT_ERR_BADSTRUCTURE,
 539 *		-FDT_ERR_TRUNCATED, standard meanings
 540 */
 
 541const void *fdt_getprop_by_offset(const void *fdt, int offset,
 542				  const char **namep, int *lenp);
 
 543
 544/**
 545 * fdt_getprop_namelen - get property value based on substring
 546 * @fdt: pointer to the device tree blob
 547 * @nodeoffset: offset of the node whose property to find
 548 * @name: name of the property to find
 549 * @namelen: number of characters of name to consider
 550 * @lenp: pointer to an integer variable (will be overwritten) or NULL
 551 *
 552 * Identical to fdt_getprop(), but only examine the first namelen
 553 * characters of name for matching the property name.
 554 */
 
 555const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
 556				const char *name, int namelen, int *lenp);
 
 
 
 
 
 
 
 
 557
 558/**
 559 * fdt_getprop - retrieve the value of a given property
 560 * @fdt: pointer to the device tree blob
 561 * @nodeoffset: offset of the node whose property to find
 562 * @name: name of the property to find
 563 * @lenp: pointer to an integer variable (will be overwritten) or NULL
 564 *
 565 * fdt_getprop() retrieves a pointer to the value of the property
 566 * named 'name' of the node at offset nodeoffset (this will be a
 567 * pointer to within the device blob itself, not a copy of the value).
 568 * If lenp is non-NULL, the length of the property value is also
 569 * returned, in the integer pointed to by lenp.
 570 *
 571 * returns:
 572 *	pointer to the property's value
 573 *		if lenp is non-NULL, *lenp contains the length of the property
 574 *		value (>=0)
 575 *	NULL, on error
 576 *		if lenp is non-NULL, *lenp contains an error code (<0):
 577 *		-FDT_ERR_NOTFOUND, node does not have named property
 578 *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
 
 579 *		-FDT_ERR_BADMAGIC,
 580 *		-FDT_ERR_BADVERSION,
 581 *		-FDT_ERR_BADSTATE,
 582 *		-FDT_ERR_BADSTRUCTURE,
 583 *		-FDT_ERR_TRUNCATED, standard meanings
 584 */
 585const void *fdt_getprop(const void *fdt, int nodeoffset,
 586			const char *name, int *lenp);
 587static inline void *fdt_getprop_w(void *fdt, int nodeoffset,
 588				  const char *name, int *lenp)
 589{
 590	return (void *)(uintptr_t)fdt_getprop(fdt, nodeoffset, name, lenp);
 591}
 592
 593/**
 594 * fdt_get_phandle - retrieve the phandle of a given node
 595 * @fdt: pointer to the device tree blob
 596 * @nodeoffset: structure block offset of the node
 597 *
 598 * fdt_get_phandle() retrieves the phandle of the device tree node at
 599 * structure block offset nodeoffset.
 600 *
 601 * returns:
 602 *	the phandle of the node at nodeoffset, on success (!= 0, != -1)
 603 *	0, if the node has no phandle, or another error occurs
 604 */
 605uint32_t fdt_get_phandle(const void *fdt, int nodeoffset);
 606
 607/**
 608 * fdt_get_alias_namelen - get alias based on substring
 609 * @fdt: pointer to the device tree blob
 610 * @name: name of the alias th look up
 611 * @namelen: number of characters of name to consider
 612 *
 613 * Identical to fdt_get_alias(), but only examine the first namelen
 614 * characters of name for matching the alias name.
 615 */
 
 616const char *fdt_get_alias_namelen(const void *fdt,
 617				  const char *name, int namelen);
 
 618
 619/**
 620 * fdt_get_alias - retreive the path referenced by a given alias
 621 * @fdt: pointer to the device tree blob
 622 * @name: name of the alias th look up
 623 *
 624 * fdt_get_alias() retrieves the value of a given alias.  That is, the
 625 * value of the property named 'name' in the node /aliases.
 626 *
 627 * returns:
 628 *	a pointer to the expansion of the alias named 'name', if it exists
 629 *	NULL, if the given alias or the /aliases node does not exist
 630 */
 631const char *fdt_get_alias(const void *fdt, const char *name);
 632
 633/**
 634 * fdt_get_path - determine the full path of a node
 635 * @fdt: pointer to the device tree blob
 636 * @nodeoffset: offset of the node whose path to find
 637 * @buf: character buffer to contain the returned path (will be overwritten)
 638 * @buflen: size of the character buffer at buf
 639 *
 640 * fdt_get_path() computes the full path of the node at offset
 641 * nodeoffset, and records that path in the buffer at buf.
 642 *
 643 * NOTE: This function is expensive, as it must scan the device tree
 644 * structure from the start to nodeoffset.
 645 *
 646 * returns:
 647 *	0, on success
 648 *		buf contains the absolute path of the node at
 649 *		nodeoffset, as a NUL-terminated string.
 650 * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
 651 *	-FDT_ERR_NOSPACE, the path of the given node is longer than (bufsize-1)
 652 *		characters and will not fit in the given buffer.
 653 *	-FDT_ERR_BADMAGIC,
 654 *	-FDT_ERR_BADVERSION,
 655 *	-FDT_ERR_BADSTATE,
 656 *	-FDT_ERR_BADSTRUCTURE, standard meanings
 657 */
 658int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen);
 659
 660/**
 661 * fdt_supernode_atdepth_offset - find a specific ancestor of a node
 662 * @fdt: pointer to the device tree blob
 663 * @nodeoffset: offset of the node whose parent to find
 664 * @supernodedepth: depth of the ancestor to find
 665 * @nodedepth: pointer to an integer variable (will be overwritten) or NULL
 666 *
 667 * fdt_supernode_atdepth_offset() finds an ancestor of the given node
 668 * at a specific depth from the root (where the root itself has depth
 669 * 0, its immediate subnodes depth 1 and so forth).  So
 670 *	fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, NULL);
 671 * will always return 0, the offset of the root node.  If the node at
 672 * nodeoffset has depth D, then:
 673 *	fdt_supernode_atdepth_offset(fdt, nodeoffset, D, NULL);
 674 * will return nodeoffset itself.
 675 *
 676 * NOTE: This function is expensive, as it must scan the device tree
 677 * structure from the start to nodeoffset.
 678 *
 679 * returns:
 680
 681 *	structure block offset of the node at node offset's ancestor
 682 *		of depth supernodedepth (>=0), on success
 683 * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
 684*	-FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of nodeoffset
 
 685 *	-FDT_ERR_BADMAGIC,
 686 *	-FDT_ERR_BADVERSION,
 687 *	-FDT_ERR_BADSTATE,
 688 *	-FDT_ERR_BADSTRUCTURE, standard meanings
 689 */
 690int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
 691				 int supernodedepth, int *nodedepth);
 692
 693/**
 694 * fdt_node_depth - find the depth of a given node
 695 * @fdt: pointer to the device tree blob
 696 * @nodeoffset: offset of the node whose parent to find
 697 *
 698 * fdt_node_depth() finds the depth of a given node.  The root node
 699 * has depth 0, its immediate subnodes depth 1 and so forth.
 700 *
 701 * NOTE: This function is expensive, as it must scan the device tree
 702 * structure from the start to nodeoffset.
 703 *
 704 * returns:
 705 *	depth of the node at nodeoffset (>=0), on success
 706 * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
 707 *	-FDT_ERR_BADMAGIC,
 708 *	-FDT_ERR_BADVERSION,
 709 *	-FDT_ERR_BADSTATE,
 710 *	-FDT_ERR_BADSTRUCTURE, standard meanings
 711 */
 712int fdt_node_depth(const void *fdt, int nodeoffset);
 713
 714/**
 715 * fdt_parent_offset - find the parent of a given node
 716 * @fdt: pointer to the device tree blob
 717 * @nodeoffset: offset of the node whose parent to find
 718 *
 719 * fdt_parent_offset() locates the parent node of a given node (that
 720 * is, it finds the offset of the node which contains the node at
 721 * nodeoffset as a subnode).
 722 *
 723 * NOTE: This function is expensive, as it must scan the device tree
 724 * structure from the start to nodeoffset, *twice*.
 725 *
 726 * returns:
 727 *	structure block offset of the parent of the node at nodeoffset
 728 *		(>=0), on success
 729 * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
 730 *	-FDT_ERR_BADMAGIC,
 731 *	-FDT_ERR_BADVERSION,
 732 *	-FDT_ERR_BADSTATE,
 733 *	-FDT_ERR_BADSTRUCTURE, standard meanings
 734 */
 735int fdt_parent_offset(const void *fdt, int nodeoffset);
 736
 737/**
 738 * fdt_node_offset_by_prop_value - find nodes with a given property value
 739 * @fdt: pointer to the device tree blob
 740 * @startoffset: only find nodes after this offset
 741 * @propname: property name to check
 742 * @propval: property value to search for
 743 * @proplen: length of the value in propval
 744 *
 745 * fdt_node_offset_by_prop_value() returns the offset of the first
 746 * node after startoffset, which has a property named propname whose
 747 * value is of length proplen and has value equal to propval; or if
 748 * startoffset is -1, the very first such node in the tree.
 749 *
 750 * To iterate through all nodes matching the criterion, the following
 751 * idiom can be used:
 752 *	offset = fdt_node_offset_by_prop_value(fdt, -1, propname,
 753 *					       propval, proplen);
 754 *	while (offset != -FDT_ERR_NOTFOUND) {
 755 *		// other code here
 756 *		offset = fdt_node_offset_by_prop_value(fdt, offset, propname,
 757 *						       propval, proplen);
 758 *	}
 759 *
 760 * Note the -1 in the first call to the function, if 0 is used here
 761 * instead, the function will never locate the root node, even if it
 762 * matches the criterion.
 763 *
 764 * returns:
 765 *	structure block offset of the located node (>= 0, >startoffset),
 766 *		 on success
 767 *	-FDT_ERR_NOTFOUND, no node matching the criterion exists in the
 768 *		tree after startoffset
 769 * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
 770 *	-FDT_ERR_BADMAGIC,
 771 *	-FDT_ERR_BADVERSION,
 772 *	-FDT_ERR_BADSTATE,
 773 *	-FDT_ERR_BADSTRUCTURE, standard meanings
 774 */
 775int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
 776				  const char *propname,
 777				  const void *propval, int proplen);
 778
 779/**
 780 * fdt_node_offset_by_phandle - find the node with a given phandle
 781 * @fdt: pointer to the device tree blob
 782 * @phandle: phandle value
 783 *
 784 * fdt_node_offset_by_phandle() returns the offset of the node
 785 * which has the given phandle value.  If there is more than one node
 786 * in the tree with the given phandle (an invalid tree), results are
 787 * undefined.
 788 *
 789 * returns:
 790 *	structure block offset of the located node (>= 0), on success
 791 *	-FDT_ERR_NOTFOUND, no node with that phandle exists
 792 *	-FDT_ERR_BADPHANDLE, given phandle value was invalid (0 or -1)
 793 *	-FDT_ERR_BADMAGIC,
 794 *	-FDT_ERR_BADVERSION,
 795 *	-FDT_ERR_BADSTATE,
 796 *	-FDT_ERR_BADSTRUCTURE, standard meanings
 797 */
 798int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle);
 799
 800/**
 801 * fdt_node_check_compatible: check a node's compatible property
 802 * @fdt: pointer to the device tree blob
 803 * @nodeoffset: offset of a tree node
 804 * @compatible: string to match against
 805 *
 806 *
 807 * fdt_node_check_compatible() returns 0 if the given node contains a
 808 * 'compatible' property with the given string as one of its elements,
 809 * it returns non-zero otherwise, or on error.
 810 *
 811 * returns:
 812 *	0, if the node has a 'compatible' property listing the given string
 813 *	1, if the node has a 'compatible' property, but it does not list
 814 *		the given string
 815 *	-FDT_ERR_NOTFOUND, if the given node has no 'compatible' property
 816 * 	-FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag
 817 *	-FDT_ERR_BADMAGIC,
 818 *	-FDT_ERR_BADVERSION,
 819 *	-FDT_ERR_BADSTATE,
 820 *	-FDT_ERR_BADSTRUCTURE, standard meanings
 821 */
 822int fdt_node_check_compatible(const void *fdt, int nodeoffset,
 823			      const char *compatible);
 824
 825/**
 826 * fdt_node_offset_by_compatible - find nodes with a given 'compatible' value
 827 * @fdt: pointer to the device tree blob
 828 * @startoffset: only find nodes after this offset
 829 * @compatible: 'compatible' string to match against
 830 *
 831 * fdt_node_offset_by_compatible() returns the offset of the first
 832 * node after startoffset, which has a 'compatible' property which
 833 * lists the given compatible string; or if startoffset is -1, the
 834 * very first such node in the tree.
 835 *
 836 * To iterate through all nodes matching the criterion, the following
 837 * idiom can be used:
 838 *	offset = fdt_node_offset_by_compatible(fdt, -1, compatible);
 839 *	while (offset != -FDT_ERR_NOTFOUND) {
 840 *		// other code here
 841 *		offset = fdt_node_offset_by_compatible(fdt, offset, compatible);
 842 *	}
 843 *
 844 * Note the -1 in the first call to the function, if 0 is used here
 845 * instead, the function will never locate the root node, even if it
 846 * matches the criterion.
 847 *
 848 * returns:
 849 *	structure block offset of the located node (>= 0, >startoffset),
 850 *		 on success
 851 *	-FDT_ERR_NOTFOUND, no node matching the criterion exists in the
 852 *		tree after startoffset
 853 * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
 854 *	-FDT_ERR_BADMAGIC,
 855 *	-FDT_ERR_BADVERSION,
 856 *	-FDT_ERR_BADSTATE,
 857 *	-FDT_ERR_BADSTRUCTURE, standard meanings
 858 */
 859int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
 860				  const char *compatible);
 861
 862/**
 863 * fdt_stringlist_contains - check a string list property for a string
 864 * @strlist: Property containing a list of strings to check
 865 * @listlen: Length of property
 866 * @str: String to search for
 867 *
 868 * This is a utility function provided for convenience. The list contains
 869 * one or more strings, each terminated by \0, as is found in a device tree
 870 * "compatible" property.
 871 *
 872 * @return: 1 if the string is found in the list, 0 not found, or invalid list
 873 */
 874int fdt_stringlist_contains(const char *strlist, int listlen, const char *str);
 875
 876/**
 877 * fdt_stringlist_count - count the number of strings in a string list
 878 * @fdt: pointer to the device tree blob
 879 * @nodeoffset: offset of a tree node
 880 * @property: name of the property containing the string list
 881 * @return:
 882 *   the number of strings in the given property
 883 *   -FDT_ERR_BADVALUE if the property value is not NUL-terminated
 884 *   -FDT_ERR_NOTFOUND if the property does not exist
 885 */
 886int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property);
 887
 888/**
 889 * fdt_stringlist_search - find a string in a string list and return its index
 890 * @fdt: pointer to the device tree blob
 891 * @nodeoffset: offset of a tree node
 892 * @property: name of the property containing the string list
 893 * @string: string to look up in the string list
 894 *
 895 * Note that it is possible for this function to succeed on property values
 896 * that are not NUL-terminated. That's because the function will stop after
 897 * finding the first occurrence of @string. This can for example happen with
 898 * small-valued cell properties, such as #address-cells, when searching for
 899 * the empty string.
 900 *
 901 * @return:
 902 *   the index of the string in the list of strings
 903 *   -FDT_ERR_BADVALUE if the property value is not NUL-terminated
 904 *   -FDT_ERR_NOTFOUND if the property does not exist or does not contain
 905 *                     the given string
 906 */
 907int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
 908			  const char *string);
 909
 910/**
 911 * fdt_stringlist_get() - obtain the string at a given index in a string list
 912 * @fdt: pointer to the device tree blob
 913 * @nodeoffset: offset of a tree node
 914 * @property: name of the property containing the string list
 915 * @index: index of the string to return
 916 * @lenp: return location for the string length or an error code on failure
 917 *
 918 * Note that this will successfully extract strings from properties with
 919 * non-NUL-terminated values. For example on small-valued cell properties
 920 * this function will return the empty string.
 921 *
 922 * If non-NULL, the length of the string (on success) or a negative error-code
 923 * (on failure) will be stored in the integer pointer to by lenp.
 924 *
 925 * @return:
 926 *   A pointer to the string at the given index in the string list or NULL on
 927 *   failure. On success the length of the string will be stored in the memory
 928 *   location pointed to by the lenp parameter, if non-NULL. On failure one of
 929 *   the following negative error codes will be returned in the lenp parameter
 930 *   (if non-NULL):
 931 *     -FDT_ERR_BADVALUE if the property value is not NUL-terminated
 932 *     -FDT_ERR_NOTFOUND if the property does not exist
 933 */
 934const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
 935			       const char *property, int index,
 936			       int *lenp);
 937
 938/**********************************************************************/
 939/* Read-only functions (addressing related)                           */
 940/**********************************************************************/
 941
 942/**
 943 * FDT_MAX_NCELLS - maximum value for #address-cells and #size-cells
 944 *
 945 * This is the maximum value for #address-cells, #size-cells and
 946 * similar properties that will be processed by libfdt.  IEE1275
 947 * requires that OF implementations handle values up to 4.
 948 * Implementations may support larger values, but in practice higher
 949 * values aren't used.
 950 */
 951#define FDT_MAX_NCELLS		4
 952
 953/**
 954 * fdt_address_cells - retrieve address size for a bus represented in the tree
 955 * @fdt: pointer to the device tree blob
 956 * @nodeoffset: offset of the node to find the address size for
 957 *
 958 * When the node has a valid #address-cells property, returns its value.
 959 *
 960 * returns:
 961 *	0 <= n < FDT_MAX_NCELLS, on success
 962 *      2, if the node has no #address-cells property
 963 *      -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid #address-cells property
 
 964 *	-FDT_ERR_BADMAGIC,
 965 *	-FDT_ERR_BADVERSION,
 966 *	-FDT_ERR_BADSTATE,
 967 *	-FDT_ERR_BADSTRUCTURE,
 968 *	-FDT_ERR_TRUNCATED, standard meanings
 969 */
 970int fdt_address_cells(const void *fdt, int nodeoffset);
 971
 972/**
 973 * fdt_size_cells - retrieve address range size for a bus represented in the
 974 *                  tree
 975 * @fdt: pointer to the device tree blob
 976 * @nodeoffset: offset of the node to find the address range size for
 977 *
 978 * When the node has a valid #size-cells property, returns its value.
 979 *
 980 * returns:
 981 *	0 <= n < FDT_MAX_NCELLS, on success
 982 *      2, if the node has no #address-cells property
 983 *      -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid #size-cells property
 
 984 *	-FDT_ERR_BADMAGIC,
 985 *	-FDT_ERR_BADVERSION,
 986 *	-FDT_ERR_BADSTATE,
 987 *	-FDT_ERR_BADSTRUCTURE,
 988 *	-FDT_ERR_TRUNCATED, standard meanings
 989 */
 990int fdt_size_cells(const void *fdt, int nodeoffset);
 991
 992
 993/**********************************************************************/
 994/* Write-in-place functions                                           */
 995/**********************************************************************/
 996
 997/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 998 * fdt_setprop_inplace - change a property's value, but not its size
 999 * @fdt: pointer to the device tree blob
1000 * @nodeoffset: offset of the node whose property to change
1001 * @name: name of the property to change
1002 * @val: pointer to data to replace the property value with
1003 * @len: length of the property value
1004 *
1005 * fdt_setprop_inplace() replaces the value of a given property with
1006 * the data in val, of length len.  This function cannot change the
1007 * size of a property, and so will only work if len is equal to the
1008 * current length of the property.
1009 *
1010 * This function will alter only the bytes in the blob which contain
1011 * the given property value, and will not alter or move any other part
1012 * of the tree.
1013 *
1014 * returns:
1015 *	0, on success
1016 *	-FDT_ERR_NOSPACE, if len is not equal to the property's current length
1017 *	-FDT_ERR_NOTFOUND, node does not have the named property
1018 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1019 *	-FDT_ERR_BADMAGIC,
1020 *	-FDT_ERR_BADVERSION,
1021 *	-FDT_ERR_BADSTATE,
1022 *	-FDT_ERR_BADSTRUCTURE,
1023 *	-FDT_ERR_TRUNCATED, standard meanings
1024 */
 
1025int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
1026			const void *val, int len);
 
1027
1028/**
1029 * fdt_setprop_inplace_u32 - change the value of a 32-bit integer property
1030 * @fdt: pointer to the device tree blob
1031 * @nodeoffset: offset of the node whose property to change
1032 * @name: name of the property to change
1033 * @val: 32-bit integer value to replace the property with
1034 *
1035 * fdt_setprop_inplace_u32() replaces the value of a given property
1036 * with the 32-bit integer value in val, converting val to big-endian
1037 * if necessary.  This function cannot change the size of a property,
1038 * and so will only work if the property already exists and has length
1039 * 4.
1040 *
1041 * This function will alter only the bytes in the blob which contain
1042 * the given property value, and will not alter or move any other part
1043 * of the tree.
1044 *
1045 * returns:
1046 *	0, on success
1047 *	-FDT_ERR_NOSPACE, if the property's length is not equal to 4
1048 *	-FDT_ERR_NOTFOUND, node does not have the named property
1049 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1050 *	-FDT_ERR_BADMAGIC,
1051 *	-FDT_ERR_BADVERSION,
1052 *	-FDT_ERR_BADSTATE,
1053 *	-FDT_ERR_BADSTRUCTURE,
1054 *	-FDT_ERR_TRUNCATED, standard meanings
1055 */
1056static inline int fdt_setprop_inplace_u32(void *fdt, int nodeoffset,
1057					  const char *name, uint32_t val)
1058{
1059	fdt32_t tmp = cpu_to_fdt32(val);
1060	return fdt_setprop_inplace(fdt, nodeoffset, name, &tmp, sizeof(tmp));
1061}
1062
1063/**
1064 * fdt_setprop_inplace_u64 - change the value of a 64-bit integer property
1065 * @fdt: pointer to the device tree blob
1066 * @nodeoffset: offset of the node whose property to change
1067 * @name: name of the property to change
1068 * @val: 64-bit integer value to replace the property with
1069 *
1070 * fdt_setprop_inplace_u64() replaces the value of a given property
1071 * with the 64-bit integer value in val, converting val to big-endian
1072 * if necessary.  This function cannot change the size of a property,
1073 * and so will only work if the property already exists and has length
1074 * 8.
1075 *
1076 * This function will alter only the bytes in the blob which contain
1077 * the given property value, and will not alter or move any other part
1078 * of the tree.
1079 *
1080 * returns:
1081 *	0, on success
1082 *	-FDT_ERR_NOSPACE, if the property's length is not equal to 8
1083 *	-FDT_ERR_NOTFOUND, node does not have the named property
1084 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1085 *	-FDT_ERR_BADMAGIC,
1086 *	-FDT_ERR_BADVERSION,
1087 *	-FDT_ERR_BADSTATE,
1088 *	-FDT_ERR_BADSTRUCTURE,
1089 *	-FDT_ERR_TRUNCATED, standard meanings
1090 */
1091static inline int fdt_setprop_inplace_u64(void *fdt, int nodeoffset,
1092					  const char *name, uint64_t val)
1093{
1094	fdt64_t tmp = cpu_to_fdt64(val);
1095	return fdt_setprop_inplace(fdt, nodeoffset, name, &tmp, sizeof(tmp));
1096}
1097
1098/**
1099 * fdt_setprop_inplace_cell - change the value of a single-cell property
1100 *
1101 * This is an alternative name for fdt_setprop_inplace_u32()
1102 */
1103static inline int fdt_setprop_inplace_cell(void *fdt, int nodeoffset,
1104					   const char *name, uint32_t val)
1105{
1106	return fdt_setprop_inplace_u32(fdt, nodeoffset, name, val);
1107}
1108
1109/**
1110 * fdt_nop_property - replace a property with nop tags
1111 * @fdt: pointer to the device tree blob
1112 * @nodeoffset: offset of the node whose property to nop
1113 * @name: name of the property to nop
1114 *
1115 * fdt_nop_property() will replace a given property's representation
1116 * in the blob with FDT_NOP tags, effectively removing it from the
1117 * tree.
1118 *
1119 * This function will alter only the bytes in the blob which contain
1120 * the property, and will not alter or move any other part of the
1121 * tree.
1122 *
1123 * returns:
1124 *	0, on success
1125 *	-FDT_ERR_NOTFOUND, node does not have the named property
1126 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1127 *	-FDT_ERR_BADMAGIC,
1128 *	-FDT_ERR_BADVERSION,
1129 *	-FDT_ERR_BADSTATE,
1130 *	-FDT_ERR_BADSTRUCTURE,
1131 *	-FDT_ERR_TRUNCATED, standard meanings
1132 */
1133int fdt_nop_property(void *fdt, int nodeoffset, const char *name);
1134
1135/**
1136 * fdt_nop_node - replace a node (subtree) with nop tags
1137 * @fdt: pointer to the device tree blob
1138 * @nodeoffset: offset of the node to nop
1139 *
1140 * fdt_nop_node() will replace a given node's representation in the
1141 * blob, including all its subnodes, if any, with FDT_NOP tags,
1142 * effectively removing it from the tree.
1143 *
1144 * This function will alter only the bytes in the blob which contain
1145 * the node and its properties and subnodes, and will not alter or
1146 * move any other part of the tree.
1147 *
1148 * returns:
1149 *	0, on success
1150 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1151 *	-FDT_ERR_BADMAGIC,
1152 *	-FDT_ERR_BADVERSION,
1153 *	-FDT_ERR_BADSTATE,
1154 *	-FDT_ERR_BADSTRUCTURE,
1155 *	-FDT_ERR_TRUNCATED, standard meanings
1156 */
1157int fdt_nop_node(void *fdt, int nodeoffset);
1158
1159/**********************************************************************/
1160/* Sequential write functions                                         */
1161/**********************************************************************/
1162
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1163int fdt_create(void *buf, int bufsize);
 
1164int fdt_resize(void *fdt, void *buf, int bufsize);
1165int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size);
1166int fdt_finish_reservemap(void *fdt);
1167int fdt_begin_node(void *fdt, const char *name);
1168int fdt_property(void *fdt, const char *name, const void *val, int len);
1169static inline int fdt_property_u32(void *fdt, const char *name, uint32_t val)
1170{
1171	fdt32_t tmp = cpu_to_fdt32(val);
1172	return fdt_property(fdt, name, &tmp, sizeof(tmp));
1173}
1174static inline int fdt_property_u64(void *fdt, const char *name, uint64_t val)
1175{
1176	fdt64_t tmp = cpu_to_fdt64(val);
1177	return fdt_property(fdt, name, &tmp, sizeof(tmp));
1178}
 
 
1179static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val)
1180{
1181	return fdt_property_u32(fdt, name, val);
1182}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1183#define fdt_property_string(fdt, name, str) \
1184	fdt_property(fdt, name, str, strlen(str)+1)
1185int fdt_end_node(void *fdt);
1186int fdt_finish(void *fdt);
1187
1188/**********************************************************************/
1189/* Read-write functions                                               */
1190/**********************************************************************/
1191
1192int fdt_create_empty_tree(void *buf, int bufsize);
1193int fdt_open_into(const void *fdt, void *buf, int bufsize);
1194int fdt_pack(void *fdt);
1195
1196/**
1197 * fdt_add_mem_rsv - add one memory reserve map entry
1198 * @fdt: pointer to the device tree blob
1199 * @address, @size: 64-bit values (native endian)
1200 *
1201 * Adds a reserve map entry to the given blob reserving a region at
1202 * address address of length size.
1203 *
1204 * This function will insert data into the reserve map and will
1205 * therefore change the indexes of some entries in the table.
1206 *
1207 * returns:
1208 *	0, on success
1209 *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
1210 *		contain the new reservation entry
1211 *	-FDT_ERR_BADMAGIC,
1212 *	-FDT_ERR_BADVERSION,
1213 *	-FDT_ERR_BADSTATE,
1214 *	-FDT_ERR_BADSTRUCTURE,
1215 *	-FDT_ERR_BADLAYOUT,
1216 *	-FDT_ERR_TRUNCATED, standard meanings
1217 */
1218int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size);
1219
1220/**
1221 * fdt_del_mem_rsv - remove a memory reserve map entry
1222 * @fdt: pointer to the device tree blob
1223 * @n: entry to remove
1224 *
1225 * fdt_del_mem_rsv() removes the n-th memory reserve map entry from
1226 * the blob.
1227 *
1228 * This function will delete data from the reservation table and will
1229 * therefore change the indexes of some entries in the table.
1230 *
1231 * returns:
1232 *	0, on success
1233 *	-FDT_ERR_NOTFOUND, there is no entry of the given index (i.e. there
1234 *		are less than n+1 reserve map entries)
1235 *	-FDT_ERR_BADMAGIC,
1236 *	-FDT_ERR_BADVERSION,
1237 *	-FDT_ERR_BADSTATE,
1238 *	-FDT_ERR_BADSTRUCTURE,
1239 *	-FDT_ERR_BADLAYOUT,
1240 *	-FDT_ERR_TRUNCATED, standard meanings
1241 */
1242int fdt_del_mem_rsv(void *fdt, int n);
1243
1244/**
1245 * fdt_set_name - change the name of a given node
1246 * @fdt: pointer to the device tree blob
1247 * @nodeoffset: structure block offset of a node
1248 * @name: name to give the node
1249 *
1250 * fdt_set_name() replaces the name (including unit address, if any)
1251 * of the given node with the given string.  NOTE: this function can't
1252 * efficiently check if the new name is unique amongst the given
1253 * node's siblings; results are undefined if this function is invoked
1254 * with a name equal to one of the given node's siblings.
1255 *
1256 * This function may insert or delete data from the blob, and will
1257 * therefore change the offsets of some existing nodes.
1258 *
1259 * returns:
1260 *	0, on success
1261 *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob
1262 *		to contain the new name
1263 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1264 *	-FDT_ERR_BADMAGIC,
1265 *	-FDT_ERR_BADVERSION,
1266 *	-FDT_ERR_BADSTATE, standard meanings
1267 */
1268int fdt_set_name(void *fdt, int nodeoffset, const char *name);
1269
1270/**
1271 * fdt_setprop - create or change a property
1272 * @fdt: pointer to the device tree blob
1273 * @nodeoffset: offset of the node whose property to change
1274 * @name: name of the property to change
1275 * @val: pointer to data to set the property value to
1276 * @len: length of the property value
1277 *
1278 * fdt_setprop() sets the value of the named property in the given
1279 * node to the given value and length, creating the property if it
1280 * does not already exist.
1281 *
1282 * This function may insert or delete data from the blob, and will
1283 * therefore change the offsets of some existing nodes.
1284 *
1285 * returns:
1286 *	0, on success
1287 *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
1288 *		contain the new property value
1289 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1290 *	-FDT_ERR_BADLAYOUT,
1291 *	-FDT_ERR_BADMAGIC,
1292 *	-FDT_ERR_BADVERSION,
1293 *	-FDT_ERR_BADSTATE,
1294 *	-FDT_ERR_BADSTRUCTURE,
1295 *	-FDT_ERR_BADLAYOUT,
1296 *	-FDT_ERR_TRUNCATED, standard meanings
1297 */
1298int fdt_setprop(void *fdt, int nodeoffset, const char *name,
1299		const void *val, int len);
1300
1301/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1302 * fdt_setprop_u32 - set a property to a 32-bit integer
1303 * @fdt: pointer to the device tree blob
1304 * @nodeoffset: offset of the node whose property to change
1305 * @name: name of the property to change
1306 * @val: 32-bit integer value for the property (native endian)
1307 *
1308 * fdt_setprop_u32() sets the value of the named property in the given
1309 * node to the given 32-bit integer value (converting to big-endian if
1310 * necessary), or creates a new property with that value if it does
1311 * not already exist.
1312 *
1313 * This function may insert or delete data from the blob, and will
1314 * therefore change the offsets of some existing nodes.
1315 *
1316 * returns:
1317 *	0, on success
1318 *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
1319 *		contain the new property value
1320 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1321 *	-FDT_ERR_BADLAYOUT,
1322 *	-FDT_ERR_BADMAGIC,
1323 *	-FDT_ERR_BADVERSION,
1324 *	-FDT_ERR_BADSTATE,
1325 *	-FDT_ERR_BADSTRUCTURE,
1326 *	-FDT_ERR_BADLAYOUT,
1327 *	-FDT_ERR_TRUNCATED, standard meanings
1328 */
1329static inline int fdt_setprop_u32(void *fdt, int nodeoffset, const char *name,
1330				  uint32_t val)
1331{
1332	fdt32_t tmp = cpu_to_fdt32(val);
1333	return fdt_setprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
1334}
1335
1336/**
1337 * fdt_setprop_u64 - set a property to a 64-bit integer
1338 * @fdt: pointer to the device tree blob
1339 * @nodeoffset: offset of the node whose property to change
1340 * @name: name of the property to change
1341 * @val: 64-bit integer value for the property (native endian)
1342 *
1343 * fdt_setprop_u64() sets the value of the named property in the given
1344 * node to the given 64-bit integer value (converting to big-endian if
1345 * necessary), or creates a new property with that value if it does
1346 * not already exist.
1347 *
1348 * This function may insert or delete data from the blob, and will
1349 * therefore change the offsets of some existing nodes.
1350 *
1351 * returns:
1352 *	0, on success
1353 *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
1354 *		contain the new property value
1355 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1356 *	-FDT_ERR_BADLAYOUT,
1357 *	-FDT_ERR_BADMAGIC,
1358 *	-FDT_ERR_BADVERSION,
1359 *	-FDT_ERR_BADSTATE,
1360 *	-FDT_ERR_BADSTRUCTURE,
1361 *	-FDT_ERR_BADLAYOUT,
1362 *	-FDT_ERR_TRUNCATED, standard meanings
1363 */
1364static inline int fdt_setprop_u64(void *fdt, int nodeoffset, const char *name,
1365				  uint64_t val)
1366{
1367	fdt64_t tmp = cpu_to_fdt64(val);
1368	return fdt_setprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
1369}
1370
1371/**
1372 * fdt_setprop_cell - set a property to a single cell value
1373 *
1374 * This is an alternative name for fdt_setprop_u32()
1375 */
1376static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name,
1377				   uint32_t val)
1378{
1379	return fdt_setprop_u32(fdt, nodeoffset, name, val);
1380}
1381
1382/**
1383 * fdt_setprop_string - set a property to a string value
1384 * @fdt: pointer to the device tree blob
1385 * @nodeoffset: offset of the node whose property to change
1386 * @name: name of the property to change
1387 * @str: string value for the property
1388 *
1389 * fdt_setprop_string() sets the value of the named property in the
1390 * given node to the given string value (using the length of the
1391 * string to determine the new length of the property), or creates a
1392 * new property with that value if it does not already exist.
1393 *
1394 * This function may insert or delete data from the blob, and will
1395 * therefore change the offsets of some existing nodes.
1396 *
1397 * returns:
1398 *	0, on success
1399 *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
1400 *		contain the new property value
1401 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1402 *	-FDT_ERR_BADLAYOUT,
1403 *	-FDT_ERR_BADMAGIC,
1404 *	-FDT_ERR_BADVERSION,
1405 *	-FDT_ERR_BADSTATE,
1406 *	-FDT_ERR_BADSTRUCTURE,
1407 *	-FDT_ERR_BADLAYOUT,
1408 *	-FDT_ERR_TRUNCATED, standard meanings
1409 */
1410#define fdt_setprop_string(fdt, nodeoffset, name, str) \
1411	fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
1412
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1413/**
1414 * fdt_appendprop - append to or create a property
1415 * @fdt: pointer to the device tree blob
1416 * @nodeoffset: offset of the node whose property to change
1417 * @name: name of the property to append to
1418 * @val: pointer to data to append to the property value
1419 * @len: length of the data to append to the property value
1420 *
1421 * fdt_appendprop() appends the value to the named property in the
1422 * given node, creating the property if it does not already exist.
1423 *
1424 * This function may insert data into the blob, and will therefore
1425 * change the offsets of some existing nodes.
1426 *
1427 * returns:
1428 *	0, on success
1429 *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
1430 *		contain the new property value
1431 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1432 *	-FDT_ERR_BADLAYOUT,
1433 *	-FDT_ERR_BADMAGIC,
1434 *	-FDT_ERR_BADVERSION,
1435 *	-FDT_ERR_BADSTATE,
1436 *	-FDT_ERR_BADSTRUCTURE,
1437 *	-FDT_ERR_BADLAYOUT,
1438 *	-FDT_ERR_TRUNCATED, standard meanings
1439 */
1440int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
1441		   const void *val, int len);
1442
1443/**
1444 * fdt_appendprop_u32 - append a 32-bit integer value to a property
1445 * @fdt: pointer to the device tree blob
1446 * @nodeoffset: offset of the node whose property to change
1447 * @name: name of the property to change
1448 * @val: 32-bit integer value to append to the property (native endian)
1449 *
1450 * fdt_appendprop_u32() appends the given 32-bit integer value
1451 * (converting to big-endian if necessary) to the value of the named
1452 * property in the given node, or creates a new property with that
1453 * value if it does not already exist.
1454 *
1455 * This function may insert data into the blob, and will therefore
1456 * change the offsets of some existing nodes.
1457 *
1458 * returns:
1459 *	0, on success
1460 *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
1461 *		contain the new property value
1462 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1463 *	-FDT_ERR_BADLAYOUT,
1464 *	-FDT_ERR_BADMAGIC,
1465 *	-FDT_ERR_BADVERSION,
1466 *	-FDT_ERR_BADSTATE,
1467 *	-FDT_ERR_BADSTRUCTURE,
1468 *	-FDT_ERR_BADLAYOUT,
1469 *	-FDT_ERR_TRUNCATED, standard meanings
1470 */
1471static inline int fdt_appendprop_u32(void *fdt, int nodeoffset,
1472				     const char *name, uint32_t val)
1473{
1474	fdt32_t tmp = cpu_to_fdt32(val);
1475	return fdt_appendprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
1476}
1477
1478/**
1479 * fdt_appendprop_u64 - append a 64-bit integer value to a property
1480 * @fdt: pointer to the device tree blob
1481 * @nodeoffset: offset of the node whose property to change
1482 * @name: name of the property to change
1483 * @val: 64-bit integer value to append to the property (native endian)
1484 *
1485 * fdt_appendprop_u64() appends the given 64-bit integer value
1486 * (converting to big-endian if necessary) to the value of the named
1487 * property in the given node, or creates a new property with that
1488 * value if it does not already exist.
1489 *
1490 * This function may insert data into the blob, and will therefore
1491 * change the offsets of some existing nodes.
1492 *
1493 * returns:
1494 *	0, on success
1495 *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
1496 *		contain the new property value
1497 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1498 *	-FDT_ERR_BADLAYOUT,
1499 *	-FDT_ERR_BADMAGIC,
1500 *	-FDT_ERR_BADVERSION,
1501 *	-FDT_ERR_BADSTATE,
1502 *	-FDT_ERR_BADSTRUCTURE,
1503 *	-FDT_ERR_BADLAYOUT,
1504 *	-FDT_ERR_TRUNCATED, standard meanings
1505 */
1506static inline int fdt_appendprop_u64(void *fdt, int nodeoffset,
1507				     const char *name, uint64_t val)
1508{
1509	fdt64_t tmp = cpu_to_fdt64(val);
1510	return fdt_appendprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
1511}
1512
1513/**
1514 * fdt_appendprop_cell - append a single cell value to a property
1515 *
1516 * This is an alternative name for fdt_appendprop_u32()
1517 */
1518static inline int fdt_appendprop_cell(void *fdt, int nodeoffset,
1519				      const char *name, uint32_t val)
1520{
1521	return fdt_appendprop_u32(fdt, nodeoffset, name, val);
1522}
1523
1524/**
1525 * fdt_appendprop_string - append a string to a property
1526 * @fdt: pointer to the device tree blob
1527 * @nodeoffset: offset of the node whose property to change
1528 * @name: name of the property to change
1529 * @str: string value to append to the property
1530 *
1531 * fdt_appendprop_string() appends the given string to the value of
1532 * the named property in the given node, or creates a new property
1533 * with that value if it does not already exist.
1534 *
1535 * This function may insert data into the blob, and will therefore
1536 * change the offsets of some existing nodes.
1537 *
1538 * returns:
1539 *	0, on success
1540 *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
1541 *		contain the new property value
1542 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1543 *	-FDT_ERR_BADLAYOUT,
1544 *	-FDT_ERR_BADMAGIC,
1545 *	-FDT_ERR_BADVERSION,
1546 *	-FDT_ERR_BADSTATE,
1547 *	-FDT_ERR_BADSTRUCTURE,
1548 *	-FDT_ERR_BADLAYOUT,
1549 *	-FDT_ERR_TRUNCATED, standard meanings
1550 */
1551#define fdt_appendprop_string(fdt, nodeoffset, name, str) \
1552	fdt_appendprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
1553
1554/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1555 * fdt_delprop - delete a property
1556 * @fdt: pointer to the device tree blob
1557 * @nodeoffset: offset of the node whose property to nop
1558 * @name: name of the property to nop
1559 *
1560 * fdt_del_property() will delete the given property.
1561 *
1562 * This function will delete data from the blob, and will therefore
1563 * change the offsets of some existing nodes.
1564 *
1565 * returns:
1566 *	0, on success
1567 *	-FDT_ERR_NOTFOUND, node does not have the named property
1568 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1569 *	-FDT_ERR_BADLAYOUT,
1570 *	-FDT_ERR_BADMAGIC,
1571 *	-FDT_ERR_BADVERSION,
1572 *	-FDT_ERR_BADSTATE,
1573 *	-FDT_ERR_BADSTRUCTURE,
1574 *	-FDT_ERR_TRUNCATED, standard meanings
1575 */
1576int fdt_delprop(void *fdt, int nodeoffset, const char *name);
1577
1578/**
1579 * fdt_add_subnode_namelen - creates a new node based on substring
1580 * @fdt: pointer to the device tree blob
1581 * @parentoffset: structure block offset of a node
1582 * @name: name of the subnode to locate
1583 * @namelen: number of characters of name to consider
1584 *
1585 * Identical to fdt_add_subnode(), but use only the first namelen
1586 * characters of name as the name of the new node.  This is useful for
1587 * creating subnodes based on a portion of a larger string, such as a
1588 * full path.
1589 */
 
1590int fdt_add_subnode_namelen(void *fdt, int parentoffset,
1591			    const char *name, int namelen);
 
1592
1593/**
1594 * fdt_add_subnode - creates a new node
1595 * @fdt: pointer to the device tree blob
1596 * @parentoffset: structure block offset of a node
1597 * @name: name of the subnode to locate
1598 *
1599 * fdt_add_subnode() creates a new node as a subnode of the node at
1600 * structure block offset parentoffset, with the given name (which
1601 * should include the unit address, if any).
1602 *
1603 * This function will insert data into the blob, and will therefore
1604 * change the offsets of some existing nodes.
1605
1606 * returns:
1607 *	structure block offset of the created nodeequested subnode (>=0), on success
 
1608 *	-FDT_ERR_NOTFOUND, if the requested subnode does not exist
1609 *	-FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag
 
1610 *	-FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of
1611 *		the given name
1612 *	-FDT_ERR_NOSPACE, if there is insufficient free space in the
1613 *		blob to contain the new node
1614 *	-FDT_ERR_NOSPACE
1615 *	-FDT_ERR_BADLAYOUT
1616 *      -FDT_ERR_BADMAGIC,
1617 *	-FDT_ERR_BADVERSION,
1618 *	-FDT_ERR_BADSTATE,
1619 *	-FDT_ERR_BADSTRUCTURE,
1620 *	-FDT_ERR_TRUNCATED, standard meanings.
1621 */
1622int fdt_add_subnode(void *fdt, int parentoffset, const char *name);
1623
1624/**
1625 * fdt_del_node - delete a node (subtree)
1626 * @fdt: pointer to the device tree blob
1627 * @nodeoffset: offset of the node to nop
1628 *
1629 * fdt_del_node() will remove the given node, including all its
1630 * subnodes if any, from the blob.
1631 *
1632 * This function will delete data from the blob, and will therefore
1633 * change the offsets of some existing nodes.
1634 *
1635 * returns:
1636 *	0, on success
1637 *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
1638 *	-FDT_ERR_BADLAYOUT,
1639 *	-FDT_ERR_BADMAGIC,
1640 *	-FDT_ERR_BADVERSION,
1641 *	-FDT_ERR_BADSTATE,
1642 *	-FDT_ERR_BADSTRUCTURE,
1643 *	-FDT_ERR_TRUNCATED, standard meanings
1644 */
1645int fdt_del_node(void *fdt, int nodeoffset);
1646
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1647/**********************************************************************/
1648/* Debugging / informational functions                                */
1649/**********************************************************************/
1650
1651const char *fdt_strerror(int errval);
1652
1653#endif /* _LIBFDT_H */