1 /* 2 * Copyright (C) 2014, Red Hat Inc, Andrew Jones <drjones@redhat.com> 3 * 4 * This work is licensed under the terms of the GNU LGPL, version 2. 5 */ 6 #include "libcflat.h" 7 #include "libfdt/libfdt.h" 8 #include "devicetree.h" 9 10 static const void *fdt; 11 static u32 root_nr_address_cells, root_nr_size_cells; 12 13 const void *dt_fdt(void) 14 { 15 return fdt; 16 } 17 18 bool dt_available(void) 19 { 20 return fdt_check_header(fdt) == 0; 21 } 22 23 int dt_get_nr_cells(int fdtnode, u32 *nr_address_cells, u32 *nr_size_cells) 24 { 25 const struct fdt_property *prop; 26 u32 *nr_cells; 27 int len; 28 29 prop = fdt_get_property(fdt, fdtnode, "#address-cells", &len); 30 if (prop == NULL) 31 return len; 32 33 nr_cells = (u32 *)prop->data; 34 *nr_address_cells = fdt32_to_cpu(*nr_cells); 35 36 prop = fdt_get_property(fdt, fdtnode, "#size-cells", &len); 37 if (prop == NULL) 38 return len; 39 40 nr_cells = (u32 *)prop->data; 41 *nr_size_cells = fdt32_to_cpu(*nr_cells); 42 43 return 0; 44 } 45 46 void dt_reg_init(struct dt_reg *reg, u32 nr_address_cells, u32 nr_size_cells) 47 { 48 memset(reg, 0, sizeof(struct dt_reg)); 49 reg->nr_address_cells = nr_address_cells; 50 reg->nr_size_cells = nr_size_cells; 51 } 52 53 int dt_get_reg(int fdtnode, int regidx, struct dt_reg *reg) 54 { 55 const struct fdt_property *prop; 56 u32 *cells, i; 57 unsigned nr_tuple_cells; 58 int len; 59 60 prop = fdt_get_property(fdt, fdtnode, "reg", &len); 61 if (prop == NULL) 62 return len; 63 64 cells = (u32 *)prop->data; 65 nr_tuple_cells = reg->nr_address_cells + reg->nr_size_cells; 66 regidx *= nr_tuple_cells; 67 68 if (regidx + nr_tuple_cells > len/sizeof(u32)) 69 return -FDT_ERR_NOTFOUND; 70 71 for (i = 0; i < reg->nr_address_cells; ++i) 72 reg->address_cells[i] = fdt32_to_cpu(cells[regidx + i]); 73 74 regidx += reg->nr_address_cells; 75 for (i = 0; i < reg->nr_size_cells; ++i) 76 reg->size_cells[i] = fdt32_to_cpu(cells[regidx + i]); 77 78 return 0; 79 } 80 81 int dt_pbus_translate_node(int fdtnode, int regidx, 82 struct dt_pbus_reg *pbus_reg) 83 { 84 struct dt_reg raw_reg; 85 int ret; 86 87 dt_reg_init(&raw_reg, root_nr_address_cells, root_nr_size_cells); 88 89 ret = dt_get_reg(fdtnode, regidx, &raw_reg); 90 if (ret < 0) 91 return ret; 92 93 pbus_reg->addr = dt_pbus_read_cells(raw_reg.nr_address_cells, 94 raw_reg.address_cells); 95 pbus_reg->size = dt_pbus_read_cells(raw_reg.nr_size_cells, 96 raw_reg.size_cells); 97 98 return 0; 99 } 100 101 int dt_pbus_translate(const struct dt_device *dev, int regidx, 102 void *reg) 103 { 104 return dt_pbus_translate_node(dev->fdtnode, regidx, reg); 105 } 106 107 int dt_bus_match_any(const struct dt_device *dev __unused, int fdtnode) 108 { 109 /* matches any device with a valid node */ 110 return fdtnode < 0 ? fdtnode : 1; 111 } 112 113 static const struct dt_bus dt_default_bus = { 114 .match = dt_bus_match_any, 115 .translate = dt_pbus_translate, 116 }; 117 118 void dt_bus_init_defaults(struct dt_bus *bus) 119 { 120 memcpy(bus, &dt_default_bus, sizeof(struct dt_bus)); 121 } 122 123 void dt_device_init(struct dt_device *dev, const struct dt_bus *bus, 124 void *info) 125 { 126 memset(dev, 0, sizeof(struct dt_device)); 127 dev->bus = bus; 128 dev->info = info; 129 } 130 131 int dt_device_find_compatible(const struct dt_device *dev, 132 const char *compatible) 133 { 134 int node, ret; 135 136 node = fdt_node_offset_by_compatible(fdt, -1, compatible); 137 while (node >= 0) { 138 ret = dev->bus->match(dev, node); 139 if (ret < 0) 140 return ret; 141 else if (ret) 142 break; 143 node = fdt_node_offset_by_compatible(fdt, node, compatible); 144 } 145 return node; 146 } 147 148 int dt_pbus_get_base_compatible(const char *compatible, 149 struct dt_pbus_reg *base) 150 { 151 struct dt_device dev; 152 int node; 153 154 dt_device_init(&dev, &dt_default_bus, NULL); 155 156 node = dt_device_find_compatible(&dev, compatible); 157 if (node < 0) 158 return node; 159 160 dt_device_bind_node(&dev, node); 161 162 return dt_pbus_get_base(&dev, base); 163 } 164 165 int dt_get_memory_params(struct dt_pbus_reg *regs, int nr_regs) 166 { 167 const char *pn = "device_type", *pv = "memory"; 168 int node, ret, pl = strlen(pv) + 1, nr = 0; 169 struct dt_pbus_reg reg; 170 171 node = fdt_node_offset_by_prop_value(fdt, -1, pn, pv, pl); 172 173 while (node >= 0) { 174 175 while (nr < nr_regs) { 176 ret = dt_pbus_translate_node(node, nr, ®); 177 if (ret == -FDT_ERR_NOTFOUND) 178 break; 179 if (ret < 0) 180 return ret; 181 regs[nr].addr = reg.addr; 182 regs[nr].size = reg.size; 183 ++nr; 184 } 185 186 node = fdt_node_offset_by_prop_value(fdt, node, pn, pv, pl); 187 } 188 189 return node != -FDT_ERR_NOTFOUND ? node : nr; 190 } 191 192 int dt_for_each_cpu_node(void (*func)(int fdtnode, u32 regval, void *info), 193 void *info) 194 { 195 const struct fdt_property *prop; 196 int cpus, cpu, ret, len; 197 struct dt_reg raw_reg; 198 u32 nac, nsc; 199 200 cpus = fdt_path_offset(fdt, "/cpus"); 201 if (cpus < 0) 202 return cpus; 203 204 ret = dt_get_nr_cells(cpus, &nac, &nsc); 205 if (ret < 0) 206 return ret; 207 208 dt_reg_init(&raw_reg, nac, nsc); 209 210 dt_for_each_subnode(cpus, cpu) { 211 212 prop = fdt_get_property(fdt, cpu, "device_type", &len); 213 if (prop == NULL) 214 return len; 215 216 if (len != 4 || strcmp((char *)prop->data, "cpu")) 217 continue; 218 219 ret = dt_get_reg(cpu, 0, &raw_reg); 220 if (ret < 0) 221 return ret; 222 223 func(cpu, raw_reg.address_cells[0], info); 224 } 225 226 return 0; 227 } 228 229 int dt_get_bootargs(const char **bootargs) 230 { 231 const struct fdt_property *prop; 232 int node, len; 233 234 *bootargs = NULL; 235 236 node = fdt_path_offset(fdt, "/chosen"); 237 if (node < 0) 238 return node; 239 240 prop = fdt_get_property(fdt, node, "bootargs", &len); 241 if (prop) 242 *bootargs = prop->data; 243 else if (len < 0 && len != -FDT_ERR_NOTFOUND) 244 return len; 245 246 return 0; 247 } 248 249 int dt_init(const void *fdt_ptr) 250 { 251 struct dt_bus *defbus = (struct dt_bus *)&dt_default_bus; 252 int root, ret; 253 254 ret = fdt_check_header(fdt_ptr); 255 if (ret < 0) 256 return ret; 257 fdt = fdt_ptr; 258 259 root = fdt_path_offset(fdt, "/"); 260 if (root < 0) 261 return root; 262 263 ret = dt_get_nr_cells(root, &root_nr_address_cells, 264 &root_nr_size_cells); 265 if (ret < 0) 266 return ret; 267 268 defbus->nr_address_cells = root_nr_address_cells; 269 defbus->nr_size_cells = root_nr_size_cells; 270 271 return 0; 272 } 273