1 /* 2 * Header with function prototypes to help device tree manipulation using 3 * libfdt. It also provides functions to read entries from device tree proc 4 * interface. 5 * 6 * Copyright 2008 IBM Corporation. 7 * Authors: Jerone Young <jyoung5@us.ibm.com> 8 * Hollis Blanchard <hollisb@us.ibm.com> 9 * 10 * This work is licensed under the GNU GPL license version 2 or later. 11 * 12 */ 13 14 #ifndef DEVICE_TREE_H 15 #define DEVICE_TREE_H 16 17 void *create_device_tree(int *sizep); 18 void *load_device_tree(const char *filename_path, int *sizep); 19 #ifdef CONFIG_LINUX 20 /** 21 * load_device_tree_from_sysfs: reads the device tree information in the 22 * /proc/device-tree directory and return the corresponding binary blob 23 * buffer pointer. Asserts in case of error. 24 */ 25 void *load_device_tree_from_sysfs(void); 26 #endif 27 28 /** 29 * qemu_fdt_node_path: return the paths of nodes matching a given 30 * name and compat string 31 * @fdt: pointer to the dt blob 32 * @name: node name 33 * @compat: compatibility string 34 * @errp: handle to an error object 35 * 36 * returns a newly allocated NULL-terminated array of node paths. 37 * Use g_strfreev() to free it. If one or more nodes were found, the 38 * array contains the path of each node and the last element equals to 39 * NULL. If there is no error but no matching node was found, the 40 * returned array contains a single element equal to NULL. If an error 41 * was encountered when parsing the blob, the function returns NULL 42 * 43 * @name may be NULL to wildcard names and only match compatibility 44 * strings. 45 */ 46 char **qemu_fdt_node_path(void *fdt, const char *name, const char *compat, 47 Error **errp); 48 49 /** 50 * qemu_fdt_node_unit_path: return the paths of nodes matching a given 51 * node-name, ie. node-name and node-name@unit-address 52 * @fdt: pointer to the dt blob 53 * @name: node name 54 * @errp: handle to an error object 55 * 56 * returns a newly allocated NULL-terminated array of node paths. 57 * Use g_strfreev() to free it. If one or more nodes were found, the 58 * array contains the path of each node and the last element equals to 59 * NULL. If there is no error but no matching node was found, the 60 * returned array contains a single element equal to NULL. If an error 61 * was encountered when parsing the blob, the function returns NULL 62 */ 63 char **qemu_fdt_node_unit_path(void *fdt, const char *name, Error **errp); 64 65 int qemu_fdt_setprop(void *fdt, const char *node_path, 66 const char *property, const void *val, int size); 67 int qemu_fdt_setprop_cell(void *fdt, const char *node_path, 68 const char *property, uint32_t val); 69 int qemu_fdt_setprop_u64(void *fdt, const char *node_path, 70 const char *property, uint64_t val); 71 int qemu_fdt_setprop_string(void *fdt, const char *node_path, 72 const char *property, const char *string); 73 int qemu_fdt_setprop_phandle(void *fdt, const char *node_path, 74 const char *property, 75 const char *target_node_path); 76 /** 77 * qemu_fdt_getprop: retrieve the value of a given property 78 * @fdt: pointer to the device tree blob 79 * @node_path: node path 80 * @property: name of the property to find 81 * @lenp: fdt error if any or length of the property on success 82 * @errp: handle to an error object 83 * 84 * returns a pointer to the property on success and NULL on failure 85 */ 86 const void *qemu_fdt_getprop(void *fdt, const char *node_path, 87 const char *property, int *lenp, 88 Error **errp); 89 /** 90 * qemu_fdt_getprop_cell: retrieve the value of a given 4 byte property 91 * @fdt: pointer to the device tree blob 92 * @node_path: node path 93 * @property: name of the property to find 94 * @lenp: fdt error if any or -EINVAL if the property size is different from 95 * 4 bytes, or 4 (expected length of the property) upon success. 96 * @errp: handle to an error object 97 * 98 * returns the property value on success 99 */ 100 uint32_t qemu_fdt_getprop_cell(void *fdt, const char *node_path, 101 const char *property, int *lenp, 102 Error **errp); 103 uint32_t qemu_fdt_get_phandle(void *fdt, const char *path); 104 uint32_t qemu_fdt_alloc_phandle(void *fdt); 105 int qemu_fdt_nop_node(void *fdt, const char *node_path); 106 int qemu_fdt_add_subnode(void *fdt, const char *name); 107 108 #define qemu_fdt_setprop_cells(fdt, node_path, property, ...) \ 109 do { \ 110 uint32_t qdt_tmp[] = { __VA_ARGS__ }; \ 111 int i; \ 112 \ 113 for (i = 0; i < ARRAY_SIZE(qdt_tmp); i++) { \ 114 qdt_tmp[i] = cpu_to_be32(qdt_tmp[i]); \ 115 } \ 116 qemu_fdt_setprop(fdt, node_path, property, qdt_tmp, \ 117 sizeof(qdt_tmp)); \ 118 } while (0) 119 120 void qemu_fdt_dumpdtb(void *fdt, int size); 121 122 /** 123 * qemu_fdt_setprop_sized_cells_from_array: 124 * @fdt: device tree blob 125 * @node_path: node to set property on 126 * @property: property to set 127 * @numvalues: number of values 128 * @values: array of number-of-cells, value pairs 129 * 130 * Set the specified property on the specified node in the device tree 131 * to be an array of cells. The values of the cells are specified via 132 * the values list, which alternates between "number of cells used by 133 * this value" and "value". 134 * number-of-cells must be either 1 or 2 (other values will result in 135 * an error being returned). If a value is too large to fit in the 136 * number of cells specified for it, an error is returned. 137 * 138 * This function is useful because device tree nodes often have cell arrays 139 * which are either lists of addresses or lists of address,size tuples, but 140 * the number of cells used for each element vary depending on the 141 * #address-cells and #size-cells properties of their parent node. 142 * If you know all your cell elements are one cell wide you can use the 143 * simpler qemu_fdt_setprop_cells(). If you're not setting up the 144 * array programmatically, qemu_fdt_setprop_sized_cells may be more 145 * convenient. 146 * 147 * Return value: 0 on success, <0 on error. 148 */ 149 int qemu_fdt_setprop_sized_cells_from_array(void *fdt, 150 const char *node_path, 151 const char *property, 152 int numvalues, 153 uint64_t *values); 154 155 /** 156 * qemu_fdt_setprop_sized_cells: 157 * @fdt: device tree blob 158 * @node_path: node to set property on 159 * @property: property to set 160 * @...: list of number-of-cells, value pairs 161 * 162 * Set the specified property on the specified node in the device tree 163 * to be an array of cells. The values of the cells are specified via 164 * the variable arguments, which alternates between "number of cells 165 * used by this value" and "value". 166 * 167 * This is a convenience wrapper for the function 168 * qemu_fdt_setprop_sized_cells_from_array(). 169 * 170 * Return value: 0 on success, <0 on error. 171 */ 172 #define qemu_fdt_setprop_sized_cells(fdt, node_path, property, ...) \ 173 ({ \ 174 uint64_t qdt_tmp[] = { __VA_ARGS__ }; \ 175 qemu_fdt_setprop_sized_cells_from_array(fdt, node_path, \ 176 property, \ 177 ARRAY_SIZE(qdt_tmp) / 2, \ 178 qdt_tmp); \ 179 }) 180 181 #define FDT_PCI_RANGE_RELOCATABLE 0x80000000 182 #define FDT_PCI_RANGE_PREFETCHABLE 0x40000000 183 #define FDT_PCI_RANGE_ALIASED 0x20000000 184 #define FDT_PCI_RANGE_TYPE_MASK 0x03000000 185 #define FDT_PCI_RANGE_MMIO_64BIT 0x03000000 186 #define FDT_PCI_RANGE_MMIO 0x02000000 187 #define FDT_PCI_RANGE_IOPORT 0x01000000 188 #define FDT_PCI_RANGE_CONFIG 0x00000000 189 190 #endif /* DEVICE_TREE_H */ 191