1/* SPDX-License-Identifier: GPL-2.0+ */ 2/* 3 * Copyright (c) 2017 Google, Inc 4 * Written by Simon Glass <sjg@chromium.org> 5 */ 6 7#ifndef _DM_OF_H 8#define _DM_OF_H 9 10#include <asm/u-boot.h> 11#include <asm/global_data.h> 12 13/* integer value within a device tree property which references another node */ 14typedef u32 phandle; 15 16/** 17 * struct property: Device tree property 18 * 19 * @name: Property name 20 * @length: Length of property in bytes 21 * @value: Pointer to property value 22 * @next: Pointer to next property, or NULL if none 23 */ 24struct property { 25 char *name; 26 int length; 27 void *value; 28 struct property *next; 29}; 30 31/** 32 * struct device_node: Device tree node 33 * 34 * @name: Node name 35 * @type: Node type (value of device_type property) or "<NULL>" if none 36 * @phandle: Phandle value of this none, or 0 if none 37 * @full_name: Full path to node, e.g. "/bus@1/spi@1100" 38 * @properties: Pointer to head of list of properties, or NULL if none 39 * @parent: Pointer to parent node, or NULL if this is the root node 40 * @child: Pointer to head of child node list, or NULL if no children 41 * @sibling: Pointer to the next sibling node, or NULL if this is the last 42 */ 43struct device_node { 44 const char *name; 45 const char *type; 46 phandle phandle; 47 const char *full_name; 48 49 struct property *properties; 50 struct device_node *parent; 51 struct device_node *child; 52 struct device_node *sibling; 53}; 54 55#define OF_MAX_PHANDLE_ARGS 16 56 57/** 58 * struct of_phandle_args - structure to hold phandle and arguments 59 * 60 * This is used when decoding a phandle in a device tree property. Typically 61 * these look like this: 62 * 63 * wibble { 64 * phandle = <5>; 65 * }; 66 * 67 * ... 68 * some-prop = <&wibble 1 2 3> 69 * 70 * Here &node is the phandle of the node 'wibble', i.e. 5. There are three 71 * arguments: 1, 2, 3. 72 * 73 * So when decoding the phandle in some-prop, np will point to wibble, 74 * args_count will be 3 and the three arguments will be in args. 75 * 76 * @np: Node that the phandle refers to 77 * @args_count: Number of arguments 78 * @args: Argument values 79 */ 80struct of_phandle_args { 81 struct device_node *np; 82 int args_count; 83 uint32_t args[OF_MAX_PHANDLE_ARGS]; 84}; 85 86DECLARE_GLOBAL_DATA_PTR; 87 88/** 89 * of_live_active() - check if livetree is active 90 * 91 * @returns true if livetree is active, false it not 92 */ 93static inline bool of_live_active(void) 94{ 95 return gd_of_root() != NULL; 96} 97 98#define OF_BAD_ADDR ((u64)-1) 99 100static inline const char *of_node_full_name(const struct device_node *np) 101{ 102 return np ? np->full_name : "<no-node>"; 103} 104 105/* Default #address and #size cells */ 106#if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT) 107#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 2 108#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1 109#endif 110 111/* Default string compare functions */ 112#if !defined(of_compat_cmp) 113#define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2)) 114#define of_prop_cmp(s1, s2) strcmp((s1), (s2)) 115#define of_node_cmp(s1, s2) strcasecmp((s1), (s2)) 116#endif 117 118/* Helper to read a big number; size is in cells (not bytes) */ 119static inline u64 of_read_number(const __be32 *cell, int size) 120{ 121 u64 r = 0; 122 while (size--) 123 r = (r << 32) | be32_to_cpu(*(cell++)); 124 return r; 125} 126 127/* Like of_read_number, but we want an unsigned long result */ 128static inline unsigned long of_read_ulong(const __be32 *cell, int size) 129{ 130 /* toss away upper bits if unsigned long is smaller than u64 */ 131 return of_read_number(cell, size); 132} 133 134#endif 135