1 #include <linux/string.h> 2 #include <linux/kernel.h> 3 #include <linux/of.h> 4 #include <linux/init.h> 5 #include <linux/mod_devicetable.h> 6 #include <linux/slab.h> 7 #include <linux/errno.h> 8 #include <linux/irq.h> 9 #include <linux/of_device.h> 10 #include <linux/of_platform.h> 11 #include <asm/leon.h> 12 #include <asm/leon_amba.h> 13 14 #include "of_device_common.h" 15 #include "irq.h" 16 17 /* 18 * PCI bus specific translator 19 */ 20 21 static int of_bus_pci_match(struct device_node *np) 22 { 23 if (!strcmp(np->type, "pci") || !strcmp(np->type, "pciex")) { 24 /* Do not do PCI specific frobbing if the 25 * PCI bridge lacks a ranges property. We 26 * want to pass it through up to the next 27 * parent as-is, not with the PCI translate 28 * method which chops off the top address cell. 29 */ 30 if (!of_find_property(np, "ranges", NULL)) 31 return 0; 32 33 return 1; 34 } 35 36 return 0; 37 } 38 39 static void of_bus_pci_count_cells(struct device_node *np, 40 int *addrc, int *sizec) 41 { 42 if (addrc) 43 *addrc = 3; 44 if (sizec) 45 *sizec = 2; 46 } 47 48 static int of_bus_pci_map(u32 *addr, const u32 *range, 49 int na, int ns, int pna) 50 { 51 u32 result[OF_MAX_ADDR_CELLS]; 52 int i; 53 54 /* Check address type match */ 55 if ((addr[0] ^ range[0]) & 0x03000000) 56 return -EINVAL; 57 58 if (of_out_of_range(addr + 1, range + 1, range + na + pna, 59 na - 1, ns)) 60 return -EINVAL; 61 62 /* Start with the parent range base. */ 63 memcpy(result, range + na, pna * 4); 64 65 /* Add in the child address offset, skipping high cell. */ 66 for (i = 0; i < na - 1; i++) 67 result[pna - 1 - i] += 68 (addr[na - 1 - i] - 69 range[na - 1 - i]); 70 71 memcpy(addr, result, pna * 4); 72 73 return 0; 74 } 75 76 static unsigned long of_bus_pci_get_flags(const u32 *addr, unsigned long flags) 77 { 78 u32 w = addr[0]; 79 80 /* For PCI, we override whatever child busses may have used. */ 81 flags = 0; 82 switch((w >> 24) & 0x03) { 83 case 0x01: 84 flags |= IORESOURCE_IO; 85 break; 86 87 case 0x02: /* 32 bits */ 88 case 0x03: /* 64 bits */ 89 flags |= IORESOURCE_MEM; 90 break; 91 } 92 if (w & 0x40000000) 93 flags |= IORESOURCE_PREFETCH; 94 return flags; 95 } 96 97 static unsigned long of_bus_sbus_get_flags(const u32 *addr, unsigned long flags) 98 { 99 return IORESOURCE_MEM; 100 } 101 102 /* 103 * AMBAPP bus specific translator 104 */ 105 106 static int of_bus_ambapp_match(struct device_node *np) 107 { 108 return !strcmp(np->type, "ambapp"); 109 } 110 111 static void of_bus_ambapp_count_cells(struct device_node *child, 112 int *addrc, int *sizec) 113 { 114 if (addrc) 115 *addrc = 1; 116 if (sizec) 117 *sizec = 1; 118 } 119 120 static int of_bus_ambapp_map(u32 *addr, const u32 *range, 121 int na, int ns, int pna) 122 { 123 return of_bus_default_map(addr, range, na, ns, pna); 124 } 125 126 static unsigned long of_bus_ambapp_get_flags(const u32 *addr, 127 unsigned long flags) 128 { 129 return IORESOURCE_MEM; 130 } 131 132 /* 133 * Array of bus specific translators 134 */ 135 136 static struct of_bus of_busses[] = { 137 /* PCI */ 138 { 139 .name = "pci", 140 .addr_prop_name = "assigned-addresses", 141 .match = of_bus_pci_match, 142 .count_cells = of_bus_pci_count_cells, 143 .map = of_bus_pci_map, 144 .get_flags = of_bus_pci_get_flags, 145 }, 146 /* SBUS */ 147 { 148 .name = "sbus", 149 .addr_prop_name = "reg", 150 .match = of_bus_sbus_match, 151 .count_cells = of_bus_sbus_count_cells, 152 .map = of_bus_default_map, 153 .get_flags = of_bus_sbus_get_flags, 154 }, 155 /* AMBA */ 156 { 157 .name = "ambapp", 158 .addr_prop_name = "reg", 159 .match = of_bus_ambapp_match, 160 .count_cells = of_bus_ambapp_count_cells, 161 .map = of_bus_ambapp_map, 162 .get_flags = of_bus_ambapp_get_flags, 163 }, 164 /* Default */ 165 { 166 .name = "default", 167 .addr_prop_name = "reg", 168 .match = NULL, 169 .count_cells = of_bus_default_count_cells, 170 .map = of_bus_default_map, 171 .get_flags = of_bus_default_get_flags, 172 }, 173 }; 174 175 static struct of_bus *of_match_bus(struct device_node *np) 176 { 177 int i; 178 179 for (i = 0; i < ARRAY_SIZE(of_busses); i ++) 180 if (!of_busses[i].match || of_busses[i].match(np)) 181 return &of_busses[i]; 182 BUG(); 183 return NULL; 184 } 185 186 static int __init build_one_resource(struct device_node *parent, 187 struct of_bus *bus, 188 struct of_bus *pbus, 189 u32 *addr, 190 int na, int ns, int pna) 191 { 192 const u32 *ranges; 193 unsigned int rlen; 194 int rone; 195 196 ranges = of_get_property(parent, "ranges", &rlen); 197 if (ranges == NULL || rlen == 0) { 198 u32 result[OF_MAX_ADDR_CELLS]; 199 int i; 200 201 memset(result, 0, pna * 4); 202 for (i = 0; i < na; i++) 203 result[pna - 1 - i] = 204 addr[na - 1 - i]; 205 206 memcpy(addr, result, pna * 4); 207 return 0; 208 } 209 210 /* Now walk through the ranges */ 211 rlen /= 4; 212 rone = na + pna + ns; 213 for (; rlen >= rone; rlen -= rone, ranges += rone) { 214 if (!bus->map(addr, ranges, na, ns, pna)) 215 return 0; 216 } 217 218 return 1; 219 } 220 221 static int __init use_1to1_mapping(struct device_node *pp) 222 { 223 /* If we have a ranges property in the parent, use it. */ 224 if (of_find_property(pp, "ranges", NULL) != NULL) 225 return 0; 226 227 /* Some SBUS devices use intermediate nodes to express 228 * hierarchy within the device itself. These aren't 229 * real bus nodes, and don't have a 'ranges' property. 230 * But, we should still pass the translation work up 231 * to the SBUS itself. 232 */ 233 if (!strcmp(pp->name, "dma") || 234 !strcmp(pp->name, "espdma") || 235 !strcmp(pp->name, "ledma") || 236 !strcmp(pp->name, "lebuffer")) 237 return 0; 238 239 return 1; 240 } 241 242 static int of_resource_verbose; 243 244 static void __init build_device_resources(struct platform_device *op, 245 struct device *parent) 246 { 247 struct platform_device *p_op; 248 struct of_bus *bus; 249 int na, ns; 250 int index, num_reg; 251 const void *preg; 252 253 if (!parent) 254 return; 255 256 p_op = to_platform_device(parent); 257 bus = of_match_bus(p_op->dev.of_node); 258 bus->count_cells(op->dev.of_node, &na, &ns); 259 260 preg = of_get_property(op->dev.of_node, bus->addr_prop_name, &num_reg); 261 if (!preg || num_reg == 0) 262 return; 263 264 /* Convert to num-cells. */ 265 num_reg /= 4; 266 267 /* Conver to num-entries. */ 268 num_reg /= na + ns; 269 270 op->resource = op->archdata.resource; 271 op->num_resources = num_reg; 272 for (index = 0; index < num_reg; index++) { 273 struct resource *r = &op->resource[index]; 274 u32 addr[OF_MAX_ADDR_CELLS]; 275 const u32 *reg = (preg + (index * ((na + ns) * 4))); 276 struct device_node *dp = op->dev.of_node; 277 struct device_node *pp = p_op->dev.of_node; 278 struct of_bus *pbus, *dbus; 279 u64 size, result = OF_BAD_ADDR; 280 unsigned long flags; 281 int dna, dns; 282 int pna, pns; 283 284 size = of_read_addr(reg + na, ns); 285 286 memcpy(addr, reg, na * 4); 287 288 flags = bus->get_flags(reg, 0); 289 290 if (use_1to1_mapping(pp)) { 291 result = of_read_addr(addr, na); 292 goto build_res; 293 } 294 295 dna = na; 296 dns = ns; 297 dbus = bus; 298 299 while (1) { 300 dp = pp; 301 pp = dp->parent; 302 if (!pp) { 303 result = of_read_addr(addr, dna); 304 break; 305 } 306 307 pbus = of_match_bus(pp); 308 pbus->count_cells(dp, &pna, &pns); 309 310 if (build_one_resource(dp, dbus, pbus, addr, 311 dna, dns, pna)) 312 break; 313 314 flags = pbus->get_flags(addr, flags); 315 316 dna = pna; 317 dns = pns; 318 dbus = pbus; 319 } 320 321 build_res: 322 memset(r, 0, sizeof(*r)); 323 324 if (of_resource_verbose) 325 printk("%s reg[%d] -> %llx\n", 326 op->dev.of_node->full_name, index, 327 result); 328 329 if (result != OF_BAD_ADDR) { 330 r->start = result & 0xffffffff; 331 r->end = result + size - 1; 332 r->flags = flags | ((result >> 32ULL) & 0xffUL); 333 } 334 r->name = op->dev.of_node->name; 335 } 336 } 337 338 static struct platform_device * __init scan_one_device(struct device_node *dp, 339 struct device *parent) 340 { 341 struct platform_device *op = kzalloc(sizeof(*op), GFP_KERNEL); 342 const struct linux_prom_irqs *intr; 343 struct dev_archdata *sd; 344 int len, i; 345 346 if (!op) 347 return NULL; 348 349 sd = &op->dev.archdata; 350 sd->op = op; 351 352 op->dev.of_node = dp; 353 354 intr = of_get_property(dp, "intr", &len); 355 if (intr) { 356 op->archdata.num_irqs = len / sizeof(struct linux_prom_irqs); 357 for (i = 0; i < op->archdata.num_irqs; i++) 358 op->archdata.irqs[i] = 359 sparc_config.build_device_irq(op, intr[i].pri); 360 } else { 361 const unsigned int *irq = 362 of_get_property(dp, "interrupts", &len); 363 364 if (irq) { 365 op->archdata.num_irqs = len / sizeof(unsigned int); 366 for (i = 0; i < op->archdata.num_irqs; i++) 367 op->archdata.irqs[i] = 368 sparc_config.build_device_irq(op, irq[i]); 369 } else { 370 op->archdata.num_irqs = 0; 371 } 372 } 373 374 build_device_resources(op, parent); 375 376 op->dev.parent = parent; 377 op->dev.bus = &platform_bus_type; 378 if (!parent) 379 dev_set_name(&op->dev, "root"); 380 else 381 dev_set_name(&op->dev, "%08x", dp->phandle); 382 383 if (of_device_register(op)) { 384 printk("%s: Could not register of device.\n", 385 dp->full_name); 386 kfree(op); 387 op = NULL; 388 } 389 390 return op; 391 } 392 393 static void __init scan_tree(struct device_node *dp, struct device *parent) 394 { 395 while (dp) { 396 struct platform_device *op = scan_one_device(dp, parent); 397 398 if (op) 399 scan_tree(dp->child, &op->dev); 400 401 dp = dp->sibling; 402 } 403 } 404 405 static int __init scan_of_devices(void) 406 { 407 struct device_node *root = of_find_node_by_path("/"); 408 struct platform_device *parent; 409 410 parent = scan_one_device(root, NULL); 411 if (!parent) 412 return 0; 413 414 scan_tree(root->child, &parent->dev); 415 return 0; 416 } 417 postcore_initcall(scan_of_devices); 418 419 static int __init of_debug(char *str) 420 { 421 int val = 0; 422 423 get_option(&str, &val); 424 if (val & 1) 425 of_resource_verbose = 1; 426 return 1; 427 } 428 429 __setup("of_debug=", of_debug); 430