1 #include <linux/string.h> 2 #include <linux/kernel.h> 3 #include <linux/of.h> 4 #include <linux/init.h> 5 #include <linux/module.h> 6 #include <linux/mod_devicetable.h> 7 #include <linux/slab.h> 8 #include <linux/errno.h> 9 #include <linux/irq.h> 10 #include <linux/of_device.h> 11 #include <linux/of_platform.h> 12 #include <asm/leon.h> 13 #include <asm/leon_amba.h> 14 15 #include "of_device_common.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 of_device *op, 245 struct device *parent) 246 { 247 struct of_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_of_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 for (index = 0; index < num_reg; index++) { 271 struct resource *r = &op->resource[index]; 272 u32 addr[OF_MAX_ADDR_CELLS]; 273 const u32 *reg = (preg + (index * ((na + ns) * 4))); 274 struct device_node *dp = op->dev.of_node; 275 struct device_node *pp = p_op->dev.of_node; 276 struct of_bus *pbus, *dbus; 277 u64 size, result = OF_BAD_ADDR; 278 unsigned long flags; 279 int dna, dns; 280 int pna, pns; 281 282 size = of_read_addr(reg + na, ns); 283 284 memcpy(addr, reg, na * 4); 285 286 flags = bus->get_flags(reg, 0); 287 288 if (use_1to1_mapping(pp)) { 289 result = of_read_addr(addr, na); 290 goto build_res; 291 } 292 293 dna = na; 294 dns = ns; 295 dbus = bus; 296 297 while (1) { 298 dp = pp; 299 pp = dp->parent; 300 if (!pp) { 301 result = of_read_addr(addr, dna); 302 break; 303 } 304 305 pbus = of_match_bus(pp); 306 pbus->count_cells(dp, &pna, &pns); 307 308 if (build_one_resource(dp, dbus, pbus, addr, 309 dna, dns, pna)) 310 break; 311 312 flags = pbus->get_flags(addr, flags); 313 314 dna = pna; 315 dns = pns; 316 dbus = pbus; 317 } 318 319 build_res: 320 memset(r, 0, sizeof(*r)); 321 322 if (of_resource_verbose) 323 printk("%s reg[%d] -> %llx\n", 324 op->dev.of_node->full_name, index, 325 result); 326 327 if (result != OF_BAD_ADDR) { 328 r->start = result & 0xffffffff; 329 r->end = result + size - 1; 330 r->flags = flags | ((result >> 32ULL) & 0xffUL); 331 } 332 r->name = op->dev.of_node->name; 333 } 334 } 335 336 static struct of_device * __init scan_one_device(struct device_node *dp, 337 struct device *parent) 338 { 339 struct of_device *op = kzalloc(sizeof(*op), GFP_KERNEL); 340 const struct linux_prom_irqs *intr; 341 struct dev_archdata *sd; 342 int len, i; 343 344 if (!op) 345 return NULL; 346 347 sd = &op->dev.archdata; 348 sd->op = op; 349 350 op->dev.of_node = dp; 351 352 op->clock_freq = of_getintprop_default(dp, "clock-frequency", 353 (25*1000*1000)); 354 op->portid = of_getintprop_default(dp, "upa-portid", -1); 355 if (op->portid == -1) 356 op->portid = of_getintprop_default(dp, "portid", -1); 357 358 intr = of_get_property(dp, "intr", &len); 359 if (intr) { 360 op->num_irqs = len / sizeof(struct linux_prom_irqs); 361 for (i = 0; i < op->num_irqs; i++) 362 op->irqs[i] = intr[i].pri; 363 } else { 364 const unsigned int *irq = 365 of_get_property(dp, "interrupts", &len); 366 367 if (irq) { 368 op->num_irqs = len / sizeof(unsigned int); 369 for (i = 0; i < op->num_irqs; i++) 370 op->irqs[i] = irq[i]; 371 } else { 372 op->num_irqs = 0; 373 } 374 } 375 if (sparc_cpu_model == sun4d) { 376 static int pil_to_sbus[] = { 377 0, 0, 1, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 0, 378 }; 379 struct device_node *io_unit, *sbi = dp->parent; 380 const struct linux_prom_registers *regs; 381 int board, slot; 382 383 while (sbi) { 384 if (!strcmp(sbi->name, "sbi")) 385 break; 386 387 sbi = sbi->parent; 388 } 389 if (!sbi) 390 goto build_resources; 391 392 regs = of_get_property(dp, "reg", NULL); 393 if (!regs) 394 goto build_resources; 395 396 slot = regs->which_io; 397 398 /* If SBI's parent is not io-unit or the io-unit lacks 399 * a "board#" property, something is very wrong. 400 */ 401 if (!sbi->parent || strcmp(sbi->parent->name, "io-unit")) { 402 printk("%s: Error, parent is not io-unit.\n", 403 sbi->full_name); 404 goto build_resources; 405 } 406 io_unit = sbi->parent; 407 board = of_getintprop_default(io_unit, "board#", -1); 408 if (board == -1) { 409 printk("%s: Error, lacks board# property.\n", 410 io_unit->full_name); 411 goto build_resources; 412 } 413 414 for (i = 0; i < op->num_irqs; i++) { 415 int this_irq = op->irqs[i]; 416 int sbusl = pil_to_sbus[this_irq]; 417 418 if (sbusl) 419 this_irq = (((board + 1) << 5) + 420 (sbusl << 2) + 421 slot); 422 423 op->irqs[i] = this_irq; 424 } 425 } 426 427 build_resources: 428 build_device_resources(op, parent); 429 430 op->dev.parent = parent; 431 op->dev.bus = &of_platform_bus_type; 432 if (!parent) 433 dev_set_name(&op->dev, "root"); 434 else 435 dev_set_name(&op->dev, "%08x", dp->phandle); 436 437 if (of_device_register(op)) { 438 printk("%s: Could not register of device.\n", 439 dp->full_name); 440 kfree(op); 441 op = NULL; 442 } 443 444 return op; 445 } 446 447 static void __init scan_tree(struct device_node *dp, struct device *parent) 448 { 449 while (dp) { 450 struct of_device *op = scan_one_device(dp, parent); 451 452 if (op) 453 scan_tree(dp->child, &op->dev); 454 455 dp = dp->sibling; 456 } 457 } 458 459 static void __init scan_of_devices(void) 460 { 461 struct device_node *root = of_find_node_by_path("/"); 462 struct of_device *parent; 463 464 parent = scan_one_device(root, NULL); 465 if (!parent) 466 return; 467 468 scan_tree(root->child, &parent->dev); 469 } 470 471 static int __init of_bus_driver_init(void) 472 { 473 int err; 474 475 err = of_bus_type_init(&of_platform_bus_type, "of"); 476 if (!err) 477 scan_of_devices(); 478 479 return err; 480 } 481 482 postcore_initcall(of_bus_driver_init); 483 484 static int __init of_debug(char *str) 485 { 486 int val = 0; 487 488 get_option(&str, &val); 489 if (val & 1) 490 of_resource_verbose = 1; 491 return 1; 492 } 493 494 __setup("of_debug=", of_debug); 495