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 */ 93#ifdef CONFIG_OF_LIVE 94static inline bool of_live_active(void) 95{ 96 return gd->of_root != NULL; 97} 98#else 99static inline bool of_live_active(void) 100{ 101 return false; 102} 103#endif 104 105#define OF_BAD_ADDR ((u64)-1) 106 107static inline const char *of_node_full_name(const struct device_node *np) 108{ 109 return np ? np->full_name : "<no-node>"; 110} 111 112/* Default #address and #size cells */ 113#if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT) 114#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 2 115#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1 116#endif 117 118/* Default string compare functions */ 119#if !defined(of_compat_cmp) 120#define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2)) 121#define of_prop_cmp(s1, s2) strcmp((s1), (s2)) 122#define of_node_cmp(s1, s2) strcasecmp((s1), (s2)) 123#endif 124 125/* Helper to read a big number; size is in cells (not bytes) */ 126static inline u64 of_read_number(const __be32 *cell, int size) 127{ 128 u64 r = 0; 129 while (size--) 130 r = (r << 32) | be32_to_cpu(*(cell++)); 131 return r; 132} 133 134/* Like of_read_number, but we want an unsigned long result */ 135static inline unsigned long of_read_ulong(const __be32 *cell, int size) 136{ 137 /* toss away upper bits if unsigned long is smaller than u64 */ 138 return of_read_number(cell, size); 139} 140 141#endif 142