Lines Matching +full:dts +full:- +full:node
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
8 * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
57 class node;
72 * Owning pointer to a node.
74 typedef std::shared_ptr<node> node_ptr;
104 * property-coded arrays will appear simply as binary (or possibly
105 * string, if they happen to be nul-terminated and printable), and must
127 /** This contains a short-form address that should be replaced
128 * by a fully-qualified version. This will only appear when
132 * the full path of the target node. */
136 * string_data will contain the node label for the target and,
138 * will contain a 32-bit integer that should match the phandle
139 * property of the target node.
179 * Returns true if this value is a string list (a nul-separated
194 * Returns this property value as a 32-bit integer. Returns 0 if this
196 * are assumed to be in big-endian format, but the return value is in
213 * - If the value is nul-terminated and only contains printable
215 * - If it is a multiple of 4 bytes long, then it is printed as cells.
216 * - Otherwise, it is printed as a byte buffer.
247 * This is used when generating DTS.
252 * 32-bit big-endian cells. This is used when generating DTS.
257 * bytes. This is used when generating DTS.
290 * Parses one or more 32-bit values enclosed in angle brackets.
298 * Parses a reference. This is a node label preceded by an ampersand
299 * symbol, which should expand to the full path to that node.
302 * a node name, however dtc assumes that it is a label, and so we
391 * Writes in DTS format to the specified file, at the given indent
404 * Class encapsulating a device tree node. Nodes may contain properties and
407 class node class
411 * The labels for this node, if any. Node labels are used as the
416 * The name of the node.
420 * The name of the node is a path reference.
424 * The unit address of the node, which is optionally written after the
429 * A flag indicating that this node has been marked /omit-if-no-ref/ and
431 * by a node that is not similarly denoted.
435 * A flag indicating that this node has been referenced, either directly
436 * or indirectly, by a node that is not marked /omit-if-no-ref/.
468 * Adaptor to use children in range-based for loops.
472 child_range(node &nd) : n(nd) {} in child_range()
476 node &n;
479 * Adaptor to use properties in range-based for loops.
483 property_range(node &nd) : n(nd) {} in property_range()
487 node &n;
490 * The properties contained within this node.
494 * The children of this node.
498 * Children that should be deleted from this node when merging.
502 * Properties that should be deleted from this node when merging.
506 * A flag indicating whether this node is valid. This is set to false
511 * Parses a name inside a node, writing the string passed as the last
518 * Constructs a new node from two input buffers, pointing to the struct
521 node(input_buffer &structs, input_buffer &strings);
523 * Parses a new node from the specified input buffer. This is called
525 * node. The name, and optionally label and unit address, should have
528 node(text_input_buffer &input,
535 * Creates a special node with the specified name and properties.
537 node(const std::string &n, const std::vector<property_ptr> &p);
545 return p1->get_key() < p2->get_key();
556 * Sorts the node's properties and children into alphabetical order and
561 * Returns an iterator for the first child of this node.
568 * Returns an iterator after the last child of this node.
575 * Returns a range suitable for use in a range-based for loop describing
576 * the children of this node.
597 * Returns a range suitable for use in a range-based for loop describing
598 * the properties of this node.
605 * Returns an iterator after the last property of this node.
612 * Returns an iterator for the first property of this node.
619 * Factory method for constructing a new node. Attempts to parse a
620 * node in DTS format from the input, and returns it on success. On
632 * Factory method for constructing a new node. Attempts to parse a
633 * node in DTB format from the input, and returns it on success. On
640 * Construct a new special node from a name and set of properties.
646 * node does not contain a property of that name.
650 * Adds a new property to this node.
657 * Adds a new child to this node.
664 * Deletes any children from this node.
671 * Merges a node into this one. Any properties present in both are
676 * Write this node to the specified output. Although nodes do not
679 * properties within this node and its children.
683 * Writes the current node as DTS to the specified file. The second
689 * Recursively visit this node and then its children based on the
692 * not recurse into the current node's children, or VISIT_RECURSE to recurse
695 visit_behavior visit(std::function<visit_behavior(node&, node*)>, node *parent);
699 * Class encapsulating the entire parsed FDT. This is the top-level class,
700 * which parses the entire DTS representation and write out the finished
707 * Type used for node paths. A node path is sequence of names and unit
742 * set to true if a node marked /omit-if-no-ref/ is encountered.
746 * Type used for memory reservations. A reservation is two 64-bit
748 * kernel should not use. The high 32 bits are ignored on 32-bit
757 * Root node. All other nodes are children of this node.
762 * duplicate names are stored as (node*)-1.
770 * A map from labels to node paths. When resolving cross references,
787 * Labels collected from top-level /delete-node/ directives.
796 * The path to the node.
841 * nul-terminated strings, which are not owned by this class and so
877 * Assign a phandle property to a single node. The next parameter
885 * the node that it is passed.
889 * Calls the recursive version of this method on every root node.
894 * node must have their values replaced by either the node path or
902 * Garbage collects nodes that have been marked /omit-if-no-ref/ and do not
911 * Parses a dts file in the given buffer and adds the roots to the parsed
913 * already been read. Some dts files place the header in an include,
914 * rather than in the top-level file.
927 * Should we write the __symbols__ node (to allow overlays to be linked
932 * Returns the node referenced by the property. If this is a tree that
948 * Writes the tree in DTS (source) format.
961 * Construct a fragment wrapper around node. This will assume that node's
963 * be wrapped in an __overlay__ node. The fragment wrapper will be assigned
966 node_ptr create_fragment_wrapper(node_ptr &node, int &fragnum);
968 * Generate a root node from the node passed in. This is sensitive to
970 * can circumvent any errors that might normally arise from a non-/ root.
974 node_ptr generate_root(node_ptr &node, int &fragnum);
976 * Reassign any fragment numbers from this new node, based on the given
979 void reassign_fragment_numbers(node_ptr &node, int &delta);
993 * Mark this tree as needing garbage collection, because an /omit-if-no-ref/
994 * node has been encountered.
1008 * Returns a pointer to the root node of this tree. No ownership
1029 root->sort(); in sort()
1034 * nul-terminated string representing the path. The device tree keeps