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 21static 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 39static 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 48static 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 76static 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 97static 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 106static int of_bus_ambapp_match(struct device_node *np) 107{ 108 return !strcmp(np->type, "ambapp"); 109} 110 111static 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 120static 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 126static 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 136static 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 175static 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 186static 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 221static 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 242static int of_resource_verbose; 243 244static 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 338static 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] = intr[i].pri; 359 } else { 360 const unsigned int *irq = 361 of_get_property(dp, "interrupts", &len); 362 363 if (irq) { 364 op->archdata.num_irqs = len / sizeof(unsigned int); 365 for (i = 0; i < op->archdata.num_irqs; i++) 366 op->archdata.irqs[i] = irq[i]; 367 } else { 368 op->archdata.num_irqs = 0; 369 } 370 } 371 if (sparc_cpu_model == sun4d) { 372 static int pil_to_sbus[] = { 373 0, 0, 1, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 0, 374 }; 375 struct device_node *io_unit, *sbi = dp->parent; 376 const struct linux_prom_registers *regs; 377 int board, slot; 378 379 while (sbi) { 380 if (!strcmp(sbi->name, "sbi")) 381 break; 382 383 sbi = sbi->parent; 384 } 385 if (!sbi) 386 goto build_resources; 387 388 regs = of_get_property(dp, "reg", NULL); 389 if (!regs) 390 goto build_resources; 391 392 slot = regs->which_io; 393 394 /* If SBI's parent is not io-unit or the io-unit lacks 395 * a "board#" property, something is very wrong. 396 */ 397 if (!sbi->parent || strcmp(sbi->parent->name, "io-unit")) { 398 printk("%s: Error, parent is not io-unit.\n", 399 sbi->full_name); 400 goto build_resources; 401 } 402 io_unit = sbi->parent; 403 board = of_getintprop_default(io_unit, "board#", -1); 404 if (board == -1) { 405 printk("%s: Error, lacks board# property.\n", 406 io_unit->full_name); 407 goto build_resources; 408 } 409 410 for (i = 0; i < op->archdata.num_irqs; i++) { 411 int this_irq = op->archdata.irqs[i]; 412 int sbusl = pil_to_sbus[this_irq]; 413 414 if (sbusl) 415 this_irq = (((board + 1) << 5) + 416 (sbusl << 2) + 417 slot); 418 419 op->archdata.irqs[i] = this_irq; 420 } 421 } 422 423build_resources: 424 build_device_resources(op, parent); 425 426 op->dev.parent = parent; 427 op->dev.bus = &platform_bus_type; 428 if (!parent) 429 dev_set_name(&op->dev, "root"); 430 else 431 dev_set_name(&op->dev, "%08x", dp->phandle); 432 433 if (of_device_register(op)) { 434 printk("%s: Could not register of device.\n", 435 dp->full_name); 436 kfree(op); 437 op = NULL; 438 } 439 440 return op; 441} 442 443static void __init scan_tree(struct device_node *dp, struct device *parent) 444{ 445 while (dp) { 446 struct platform_device *op = scan_one_device(dp, parent); 447 448 if (op) 449 scan_tree(dp->child, &op->dev); 450 451 dp = dp->sibling; 452 } 453} 454 455static int __init scan_of_devices(void) 456{ 457 struct device_node *root = of_find_node_by_path("/"); 458 struct platform_device *parent; 459 460 parent = scan_one_device(root, NULL); 461 if (!parent) 462 return 0; 463 464 scan_tree(root->child, &parent->dev); 465 return 0; 466} 467postcore_initcall(scan_of_devices); 468 469static int __init of_debug(char *str) 470{ 471 int val = 0; 472 473 get_option(&str, &val); 474 if (val & 1) 475 of_resource_verbose = 1; 476 return 1; 477} 478 479__setup("of_debug=", of_debug); 480