1 #undef DEBUG 2 3 #include <linux/kernel.h> 4 #include <linux/string.h> 5 #include <linux/pci_regs.h> 6 #include <linux/module.h> 7 #include <linux/ioport.h> 8 #include <linux/etherdevice.h> 9 #include <asm/prom.h> 10 #include <asm/pci-bridge.h> 11 12 #ifdef DEBUG 13 #define DBG(fmt...) do { printk(fmt); } while(0) 14 #else 15 #define DBG(fmt...) do { } while(0) 16 #endif 17 18 #ifdef CONFIG_PPC64 19 #define PRu64 "%lx" 20 #else 21 #define PRu64 "%llx" 22 #endif 23 24 /* Max address size we deal with */ 25 #define OF_MAX_ADDR_CELLS 4 26 #define OF_CHECK_COUNTS(na, ns) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS && \ 27 (ns) > 0) 28 29 static struct of_bus *of_match_bus(struct device_node *np); 30 static int __of_address_to_resource(struct device_node *dev, 31 const u32 *addrp, u64 size, unsigned int flags, 32 struct resource *r); 33 34 35 /* Debug utility */ 36 #ifdef DEBUG 37 static void of_dump_addr(const char *s, const u32 *addr, int na) 38 { 39 printk("%s", s); 40 while(na--) 41 printk(" %08x", *(addr++)); 42 printk("\n"); 43 } 44 #else 45 static void of_dump_addr(const char *s, const u32 *addr, int na) { } 46 #endif 47 48 49 /* Callbacks for bus specific translators */ 50 struct of_bus { 51 const char *name; 52 const char *addresses; 53 int (*match)(struct device_node *parent); 54 void (*count_cells)(struct device_node *child, 55 int *addrc, int *sizec); 56 u64 (*map)(u32 *addr, const u32 *range, 57 int na, int ns, int pna); 58 int (*translate)(u32 *addr, u64 offset, int na); 59 unsigned int (*get_flags)(const u32 *addr); 60 }; 61 62 63 /* 64 * Default translator (generic bus) 65 */ 66 67 static void of_bus_default_count_cells(struct device_node *dev, 68 int *addrc, int *sizec) 69 { 70 if (addrc) 71 *addrc = of_n_addr_cells(dev); 72 if (sizec) 73 *sizec = of_n_size_cells(dev); 74 } 75 76 static u64 of_bus_default_map(u32 *addr, const u32 *range, 77 int na, int ns, int pna) 78 { 79 u64 cp, s, da; 80 81 cp = of_read_number(range, na); 82 s = of_read_number(range + na + pna, ns); 83 da = of_read_number(addr, na); 84 85 DBG("OF: default map, cp="PRu64", s="PRu64", da="PRu64"\n", 86 cp, s, da); 87 88 if (da < cp || da >= (cp + s)) 89 return OF_BAD_ADDR; 90 return da - cp; 91 } 92 93 static int of_bus_default_translate(u32 *addr, u64 offset, int na) 94 { 95 u64 a = of_read_number(addr, na); 96 memset(addr, 0, na * 4); 97 a += offset; 98 if (na > 1) 99 addr[na - 2] = a >> 32; 100 addr[na - 1] = a & 0xffffffffu; 101 102 return 0; 103 } 104 105 static unsigned int of_bus_default_get_flags(const u32 *addr) 106 { 107 return IORESOURCE_MEM; 108 } 109 110 111 #ifdef CONFIG_PCI 112 /* 113 * PCI bus specific translator 114 */ 115 116 static int of_bus_pci_match(struct device_node *np) 117 { 118 /* "vci" is for the /chaos bridge on 1st-gen PCI powermacs */ 119 return !strcmp(np->type, "pci") || !strcmp(np->type, "vci"); 120 } 121 122 static void of_bus_pci_count_cells(struct device_node *np, 123 int *addrc, int *sizec) 124 { 125 if (addrc) 126 *addrc = 3; 127 if (sizec) 128 *sizec = 2; 129 } 130 131 static u64 of_bus_pci_map(u32 *addr, const u32 *range, int na, int ns, int pna) 132 { 133 u64 cp, s, da; 134 135 /* Check address type match */ 136 if ((addr[0] ^ range[0]) & 0x03000000) 137 return OF_BAD_ADDR; 138 139 /* Read address values, skipping high cell */ 140 cp = of_read_number(range + 1, na - 1); 141 s = of_read_number(range + na + pna, ns); 142 da = of_read_number(addr + 1, na - 1); 143 144 DBG("OF: PCI map, cp="PRu64", s="PRu64", da="PRu64"\n", cp, s, da); 145 146 if (da < cp || da >= (cp + s)) 147 return OF_BAD_ADDR; 148 return da - cp; 149 } 150 151 static int of_bus_pci_translate(u32 *addr, u64 offset, int na) 152 { 153 return of_bus_default_translate(addr + 1, offset, na - 1); 154 } 155 156 static unsigned int of_bus_pci_get_flags(const u32 *addr) 157 { 158 unsigned int flags = 0; 159 u32 w = addr[0]; 160 161 switch((w >> 24) & 0x03) { 162 case 0x01: 163 flags |= IORESOURCE_IO; 164 break; 165 case 0x02: /* 32 bits */ 166 case 0x03: /* 64 bits */ 167 flags |= IORESOURCE_MEM; 168 break; 169 } 170 if (w & 0x40000000) 171 flags |= IORESOURCE_PREFETCH; 172 return flags; 173 } 174 175 const u32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size, 176 unsigned int *flags) 177 { 178 const u32 *prop; 179 unsigned int psize; 180 struct device_node *parent; 181 struct of_bus *bus; 182 int onesize, i, na, ns; 183 184 /* Get parent & match bus type */ 185 parent = of_get_parent(dev); 186 if (parent == NULL) 187 return NULL; 188 bus = of_match_bus(parent); 189 if (strcmp(bus->name, "pci")) { 190 of_node_put(parent); 191 return NULL; 192 } 193 bus->count_cells(dev, &na, &ns); 194 of_node_put(parent); 195 if (!OF_CHECK_COUNTS(na, ns)) 196 return NULL; 197 198 /* Get "reg" or "assigned-addresses" property */ 199 prop = of_get_property(dev, bus->addresses, &psize); 200 if (prop == NULL) 201 return NULL; 202 psize /= 4; 203 204 onesize = na + ns; 205 for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) 206 if ((prop[0] & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0)) { 207 if (size) 208 *size = of_read_number(prop + na, ns); 209 if (flags) 210 *flags = bus->get_flags(prop); 211 return prop; 212 } 213 return NULL; 214 } 215 EXPORT_SYMBOL(of_get_pci_address); 216 217 int of_pci_address_to_resource(struct device_node *dev, int bar, 218 struct resource *r) 219 { 220 const u32 *addrp; 221 u64 size; 222 unsigned int flags; 223 224 addrp = of_get_pci_address(dev, bar, &size, &flags); 225 if (addrp == NULL) 226 return -EINVAL; 227 return __of_address_to_resource(dev, addrp, size, flags, r); 228 } 229 EXPORT_SYMBOL_GPL(of_pci_address_to_resource); 230 231 static u8 of_irq_pci_swizzle(u8 slot, u8 pin) 232 { 233 return (((pin - 1) + slot) % 4) + 1; 234 } 235 236 int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq) 237 { 238 struct device_node *dn, *ppnode; 239 struct pci_dev *ppdev; 240 u32 lspec; 241 u32 laddr[3]; 242 u8 pin; 243 int rc; 244 245 /* Check if we have a device node, if yes, fallback to standard OF 246 * parsing 247 */ 248 dn = pci_device_to_OF_node(pdev); 249 if (dn) 250 return of_irq_map_one(dn, 0, out_irq); 251 252 /* Ok, we don't, time to have fun. Let's start by building up an 253 * interrupt spec. we assume #interrupt-cells is 1, which is standard 254 * for PCI. If you do different, then don't use that routine. 255 */ 256 rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin); 257 if (rc != 0) 258 return rc; 259 /* No pin, exit */ 260 if (pin == 0) 261 return -ENODEV; 262 263 /* Now we walk up the PCI tree */ 264 lspec = pin; 265 for (;;) { 266 /* Get the pci_dev of our parent */ 267 ppdev = pdev->bus->self; 268 269 /* Ouch, it's a host bridge... */ 270 if (ppdev == NULL) { 271 #ifdef CONFIG_PPC64 272 ppnode = pci_bus_to_OF_node(pdev->bus); 273 #else 274 struct pci_controller *host; 275 host = pci_bus_to_host(pdev->bus); 276 ppnode = host ? host->dn : NULL; 277 #endif 278 /* No node for host bridge ? give up */ 279 if (ppnode == NULL) 280 return -EINVAL; 281 } else 282 /* We found a P2P bridge, check if it has a node */ 283 ppnode = pci_device_to_OF_node(ppdev); 284 285 /* Ok, we have found a parent with a device-node, hand over to 286 * the OF parsing code. 287 * We build a unit address from the linux device to be used for 288 * resolution. Note that we use the linux bus number which may 289 * not match your firmware bus numbering. 290 * Fortunately, in most cases, interrupt-map-mask doesn't include 291 * the bus number as part of the matching. 292 * You should still be careful about that though if you intend 293 * to rely on this function (you ship a firmware that doesn't 294 * create device nodes for all PCI devices). 295 */ 296 if (ppnode) 297 break; 298 299 /* We can only get here if we hit a P2P bridge with no node, 300 * let's do standard swizzling and try again 301 */ 302 lspec = of_irq_pci_swizzle(PCI_SLOT(pdev->devfn), lspec); 303 pdev = ppdev; 304 } 305 306 laddr[0] = (pdev->bus->number << 16) 307 | (pdev->devfn << 8); 308 laddr[1] = laddr[2] = 0; 309 return of_irq_map_raw(ppnode, &lspec, 1, laddr, out_irq); 310 } 311 EXPORT_SYMBOL_GPL(of_irq_map_pci); 312 #endif /* CONFIG_PCI */ 313 314 /* 315 * ISA bus specific translator 316 */ 317 318 static int of_bus_isa_match(struct device_node *np) 319 { 320 return !strcmp(np->name, "isa"); 321 } 322 323 static void of_bus_isa_count_cells(struct device_node *child, 324 int *addrc, int *sizec) 325 { 326 if (addrc) 327 *addrc = 2; 328 if (sizec) 329 *sizec = 1; 330 } 331 332 static u64 of_bus_isa_map(u32 *addr, const u32 *range, int na, int ns, int pna) 333 { 334 u64 cp, s, da; 335 336 /* Check address type match */ 337 if ((addr[0] ^ range[0]) & 0x00000001) 338 return OF_BAD_ADDR; 339 340 /* Read address values, skipping high cell */ 341 cp = of_read_number(range + 1, na - 1); 342 s = of_read_number(range + na + pna, ns); 343 da = of_read_number(addr + 1, na - 1); 344 345 DBG("OF: ISA map, cp="PRu64", s="PRu64", da="PRu64"\n", cp, s, da); 346 347 if (da < cp || da >= (cp + s)) 348 return OF_BAD_ADDR; 349 return da - cp; 350 } 351 352 static int of_bus_isa_translate(u32 *addr, u64 offset, int na) 353 { 354 return of_bus_default_translate(addr + 1, offset, na - 1); 355 } 356 357 static unsigned int of_bus_isa_get_flags(const u32 *addr) 358 { 359 unsigned int flags = 0; 360 u32 w = addr[0]; 361 362 if (w & 1) 363 flags |= IORESOURCE_IO; 364 else 365 flags |= IORESOURCE_MEM; 366 return flags; 367 } 368 369 370 /* 371 * Array of bus specific translators 372 */ 373 374 static struct of_bus of_busses[] = { 375 #ifdef CONFIG_PCI 376 /* PCI */ 377 { 378 .name = "pci", 379 .addresses = "assigned-addresses", 380 .match = of_bus_pci_match, 381 .count_cells = of_bus_pci_count_cells, 382 .map = of_bus_pci_map, 383 .translate = of_bus_pci_translate, 384 .get_flags = of_bus_pci_get_flags, 385 }, 386 #endif /* CONFIG_PCI */ 387 /* ISA */ 388 { 389 .name = "isa", 390 .addresses = "reg", 391 .match = of_bus_isa_match, 392 .count_cells = of_bus_isa_count_cells, 393 .map = of_bus_isa_map, 394 .translate = of_bus_isa_translate, 395 .get_flags = of_bus_isa_get_flags, 396 }, 397 /* Default */ 398 { 399 .name = "default", 400 .addresses = "reg", 401 .match = NULL, 402 .count_cells = of_bus_default_count_cells, 403 .map = of_bus_default_map, 404 .translate = of_bus_default_translate, 405 .get_flags = of_bus_default_get_flags, 406 }, 407 }; 408 409 static struct of_bus *of_match_bus(struct device_node *np) 410 { 411 int i; 412 413 for (i = 0; i < ARRAY_SIZE(of_busses); i ++) 414 if (!of_busses[i].match || of_busses[i].match(np)) 415 return &of_busses[i]; 416 BUG(); 417 return NULL; 418 } 419 420 static int of_translate_one(struct device_node *parent, struct of_bus *bus, 421 struct of_bus *pbus, u32 *addr, 422 int na, int ns, int pna, const char *rprop) 423 { 424 const u32 *ranges; 425 unsigned int rlen; 426 int rone; 427 u64 offset = OF_BAD_ADDR; 428 429 /* Normally, an absence of a "ranges" property means we are 430 * crossing a non-translatable boundary, and thus the addresses 431 * below the current not cannot be converted to CPU physical ones. 432 * Unfortunately, while this is very clear in the spec, it's not 433 * what Apple understood, and they do have things like /uni-n or 434 * /ht nodes with no "ranges" property and a lot of perfectly 435 * useable mapped devices below them. Thus we treat the absence of 436 * "ranges" as equivalent to an empty "ranges" property which means 437 * a 1:1 translation at that level. It's up to the caller not to try 438 * to translate addresses that aren't supposed to be translated in 439 * the first place. --BenH. 440 */ 441 ranges = of_get_property(parent, rprop, &rlen); 442 if (ranges == NULL || rlen == 0) { 443 offset = of_read_number(addr, na); 444 memset(addr, 0, pna * 4); 445 DBG("OF: no ranges, 1:1 translation\n"); 446 goto finish; 447 } 448 449 DBG("OF: walking ranges...\n"); 450 451 /* Now walk through the ranges */ 452 rlen /= 4; 453 rone = na + pna + ns; 454 for (; rlen >= rone; rlen -= rone, ranges += rone) { 455 offset = bus->map(addr, ranges, na, ns, pna); 456 if (offset != OF_BAD_ADDR) 457 break; 458 } 459 if (offset == OF_BAD_ADDR) { 460 DBG("OF: not found !\n"); 461 return 1; 462 } 463 memcpy(addr, ranges + na, 4 * pna); 464 465 finish: 466 of_dump_addr("OF: parent translation for:", addr, pna); 467 DBG("OF: with offset: "PRu64"\n", offset); 468 469 /* Translate it into parent bus space */ 470 return pbus->translate(addr, offset, pna); 471 } 472 473 474 /* 475 * Translate an address from the device-tree into a CPU physical address, 476 * this walks up the tree and applies the various bus mappings on the 477 * way. 478 * 479 * Note: We consider that crossing any level with #size-cells == 0 to mean 480 * that translation is impossible (that is we are not dealing with a value 481 * that can be mapped to a cpu physical address). This is not really specified 482 * that way, but this is traditionally the way IBM at least do things 483 */ 484 u64 __of_translate_address(struct device_node *dev, const u32 *in_addr, 485 const char *rprop) 486 { 487 struct device_node *parent = NULL; 488 struct of_bus *bus, *pbus; 489 u32 addr[OF_MAX_ADDR_CELLS]; 490 int na, ns, pna, pns; 491 u64 result = OF_BAD_ADDR; 492 493 DBG("OF: ** translation for device %s **\n", dev->full_name); 494 495 /* Increase refcount at current level */ 496 of_node_get(dev); 497 498 /* Get parent & match bus type */ 499 parent = of_get_parent(dev); 500 if (parent == NULL) 501 goto bail; 502 bus = of_match_bus(parent); 503 504 /* Cound address cells & copy address locally */ 505 bus->count_cells(dev, &na, &ns); 506 if (!OF_CHECK_COUNTS(na, ns)) { 507 printk(KERN_ERR "prom_parse: Bad cell count for %s\n", 508 dev->full_name); 509 goto bail; 510 } 511 memcpy(addr, in_addr, na * 4); 512 513 DBG("OF: bus is %s (na=%d, ns=%d) on %s\n", 514 bus->name, na, ns, parent->full_name); 515 of_dump_addr("OF: translating address:", addr, na); 516 517 /* Translate */ 518 for (;;) { 519 /* Switch to parent bus */ 520 of_node_put(dev); 521 dev = parent; 522 parent = of_get_parent(dev); 523 524 /* If root, we have finished */ 525 if (parent == NULL) { 526 DBG("OF: reached root node\n"); 527 result = of_read_number(addr, na); 528 break; 529 } 530 531 /* Get new parent bus and counts */ 532 pbus = of_match_bus(parent); 533 pbus->count_cells(dev, &pna, &pns); 534 if (!OF_CHECK_COUNTS(pna, pns)) { 535 printk(KERN_ERR "prom_parse: Bad cell count for %s\n", 536 dev->full_name); 537 break; 538 } 539 540 DBG("OF: parent bus is %s (na=%d, ns=%d) on %s\n", 541 pbus->name, pna, pns, parent->full_name); 542 543 /* Apply bus translation */ 544 if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop)) 545 break; 546 547 /* Complete the move up one level */ 548 na = pna; 549 ns = pns; 550 bus = pbus; 551 552 of_dump_addr("OF: one level translation:", addr, na); 553 } 554 bail: 555 of_node_put(parent); 556 of_node_put(dev); 557 558 return result; 559 } 560 561 u64 of_translate_address(struct device_node *dev, const u32 *in_addr) 562 { 563 return __of_translate_address(dev, in_addr, "ranges"); 564 } 565 EXPORT_SYMBOL(of_translate_address); 566 567 u64 of_translate_dma_address(struct device_node *dev, const u32 *in_addr) 568 { 569 return __of_translate_address(dev, in_addr, "dma-ranges"); 570 } 571 EXPORT_SYMBOL(of_translate_dma_address); 572 573 const u32 *of_get_address(struct device_node *dev, int index, u64 *size, 574 unsigned int *flags) 575 { 576 const u32 *prop; 577 unsigned int psize; 578 struct device_node *parent; 579 struct of_bus *bus; 580 int onesize, i, na, ns; 581 582 /* Get parent & match bus type */ 583 parent = of_get_parent(dev); 584 if (parent == NULL) 585 return NULL; 586 bus = of_match_bus(parent); 587 bus->count_cells(dev, &na, &ns); 588 of_node_put(parent); 589 if (!OF_CHECK_COUNTS(na, ns)) 590 return NULL; 591 592 /* Get "reg" or "assigned-addresses" property */ 593 prop = of_get_property(dev, bus->addresses, &psize); 594 if (prop == NULL) 595 return NULL; 596 psize /= 4; 597 598 onesize = na + ns; 599 for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) 600 if (i == index) { 601 if (size) 602 *size = of_read_number(prop + na, ns); 603 if (flags) 604 *flags = bus->get_flags(prop); 605 return prop; 606 } 607 return NULL; 608 } 609 EXPORT_SYMBOL(of_get_address); 610 611 static int __of_address_to_resource(struct device_node *dev, const u32 *addrp, 612 u64 size, unsigned int flags, 613 struct resource *r) 614 { 615 u64 taddr; 616 617 if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0) 618 return -EINVAL; 619 taddr = of_translate_address(dev, addrp); 620 if (taddr == OF_BAD_ADDR) 621 return -EINVAL; 622 memset(r, 0, sizeof(struct resource)); 623 if (flags & IORESOURCE_IO) { 624 unsigned long port; 625 port = pci_address_to_pio(taddr); 626 if (port == (unsigned long)-1) 627 return -EINVAL; 628 r->start = port; 629 r->end = port + size - 1; 630 } else { 631 r->start = taddr; 632 r->end = taddr + size - 1; 633 } 634 r->flags = flags; 635 r->name = dev->name; 636 return 0; 637 } 638 639 int of_address_to_resource(struct device_node *dev, int index, 640 struct resource *r) 641 { 642 const u32 *addrp; 643 u64 size; 644 unsigned int flags; 645 646 addrp = of_get_address(dev, index, &size, &flags); 647 if (addrp == NULL) 648 return -EINVAL; 649 return __of_address_to_resource(dev, addrp, size, flags, r); 650 } 651 EXPORT_SYMBOL_GPL(of_address_to_resource); 652 653 void of_parse_dma_window(struct device_node *dn, const void *dma_window_prop, 654 unsigned long *busno, unsigned long *phys, unsigned long *size) 655 { 656 const u32 *dma_window; 657 u32 cells; 658 const unsigned char *prop; 659 660 dma_window = dma_window_prop; 661 662 /* busno is always one cell */ 663 *busno = *(dma_window++); 664 665 prop = of_get_property(dn, "ibm,#dma-address-cells", NULL); 666 if (!prop) 667 prop = of_get_property(dn, "#address-cells", NULL); 668 669 cells = prop ? *(u32 *)prop : of_n_addr_cells(dn); 670 *phys = of_read_number(dma_window, cells); 671 672 dma_window += cells; 673 674 prop = of_get_property(dn, "ibm,#dma-size-cells", NULL); 675 cells = prop ? *(u32 *)prop : of_n_size_cells(dn); 676 *size = of_read_number(dma_window, cells); 677 } 678 679 /* 680 * Interrupt remapper 681 */ 682 683 static unsigned int of_irq_workarounds; 684 static struct device_node *of_irq_dflt_pic; 685 686 static struct device_node *of_irq_find_parent(struct device_node *child) 687 { 688 struct device_node *p; 689 const phandle *parp; 690 691 if (!of_node_get(child)) 692 return NULL; 693 694 do { 695 parp = of_get_property(child, "interrupt-parent", NULL); 696 if (parp == NULL) 697 p = of_get_parent(child); 698 else { 699 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE) 700 p = of_node_get(of_irq_dflt_pic); 701 else 702 p = of_find_node_by_phandle(*parp); 703 } 704 of_node_put(child); 705 child = p; 706 } while (p && of_get_property(p, "#interrupt-cells", NULL) == NULL); 707 708 return p; 709 } 710 711 /* This doesn't need to be called if you don't have any special workaround 712 * flags to pass 713 */ 714 void of_irq_map_init(unsigned int flags) 715 { 716 of_irq_workarounds = flags; 717 718 /* OldWorld, don't bother looking at other things */ 719 if (flags & OF_IMAP_OLDWORLD_MAC) 720 return; 721 722 /* If we don't have phandles, let's try to locate a default interrupt 723 * controller (happens when booting with BootX). We do a first match 724 * here, hopefully, that only ever happens on machines with one 725 * controller. 726 */ 727 if (flags & OF_IMAP_NO_PHANDLE) { 728 struct device_node *np; 729 730 for(np = NULL; (np = of_find_all_nodes(np)) != NULL;) { 731 if (of_get_property(np, "interrupt-controller", NULL) 732 == NULL) 733 continue; 734 /* Skip /chosen/interrupt-controller */ 735 if (strcmp(np->name, "chosen") == 0) 736 continue; 737 /* It seems like at least one person on this planet wants 738 * to use BootX on a machine with an AppleKiwi controller 739 * which happens to pretend to be an interrupt 740 * controller too. 741 */ 742 if (strcmp(np->name, "AppleKiwi") == 0) 743 continue; 744 /* I think we found one ! */ 745 of_irq_dflt_pic = np; 746 break; 747 } 748 } 749 750 } 751 752 int of_irq_map_raw(struct device_node *parent, const u32 *intspec, u32 ointsize, 753 const u32 *addr, struct of_irq *out_irq) 754 { 755 struct device_node *ipar, *tnode, *old = NULL, *newpar = NULL; 756 const u32 *tmp, *imap, *imask; 757 u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0; 758 int imaplen, match, i; 759 760 DBG("of_irq_map_raw: par=%s,intspec=[0x%08x 0x%08x...],ointsize=%d\n", 761 parent->full_name, intspec[0], intspec[1], ointsize); 762 763 ipar = of_node_get(parent); 764 765 /* First get the #interrupt-cells property of the current cursor 766 * that tells us how to interpret the passed-in intspec. If there 767 * is none, we are nice and just walk up the tree 768 */ 769 do { 770 tmp = of_get_property(ipar, "#interrupt-cells", NULL); 771 if (tmp != NULL) { 772 intsize = *tmp; 773 break; 774 } 775 tnode = ipar; 776 ipar = of_irq_find_parent(ipar); 777 of_node_put(tnode); 778 } while (ipar); 779 if (ipar == NULL) { 780 DBG(" -> no parent found !\n"); 781 goto fail; 782 } 783 784 DBG("of_irq_map_raw: ipar=%s, size=%d\n", ipar->full_name, intsize); 785 786 if (ointsize != intsize) 787 return -EINVAL; 788 789 /* Look for this #address-cells. We have to implement the old linux 790 * trick of looking for the parent here as some device-trees rely on it 791 */ 792 old = of_node_get(ipar); 793 do { 794 tmp = of_get_property(old, "#address-cells", NULL); 795 tnode = of_get_parent(old); 796 of_node_put(old); 797 old = tnode; 798 } while(old && tmp == NULL); 799 of_node_put(old); 800 old = NULL; 801 addrsize = (tmp == NULL) ? 2 : *tmp; 802 803 DBG(" -> addrsize=%d\n", addrsize); 804 805 /* Now start the actual "proper" walk of the interrupt tree */ 806 while (ipar != NULL) { 807 /* Now check if cursor is an interrupt-controller and if it is 808 * then we are done 809 */ 810 if (of_get_property(ipar, "interrupt-controller", NULL) != 811 NULL) { 812 DBG(" -> got it !\n"); 813 memcpy(out_irq->specifier, intspec, 814 intsize * sizeof(u32)); 815 out_irq->size = intsize; 816 out_irq->controller = ipar; 817 of_node_put(old); 818 return 0; 819 } 820 821 /* Now look for an interrupt-map */ 822 imap = of_get_property(ipar, "interrupt-map", &imaplen); 823 /* No interrupt map, check for an interrupt parent */ 824 if (imap == NULL) { 825 DBG(" -> no map, getting parent\n"); 826 newpar = of_irq_find_parent(ipar); 827 goto skiplevel; 828 } 829 imaplen /= sizeof(u32); 830 831 /* Look for a mask */ 832 imask = of_get_property(ipar, "interrupt-map-mask", NULL); 833 834 /* If we were passed no "reg" property and we attempt to parse 835 * an interrupt-map, then #address-cells must be 0. 836 * Fail if it's not. 837 */ 838 if (addr == NULL && addrsize != 0) { 839 DBG(" -> no reg passed in when needed !\n"); 840 goto fail; 841 } 842 843 /* Parse interrupt-map */ 844 match = 0; 845 while (imaplen > (addrsize + intsize + 1) && !match) { 846 /* Compare specifiers */ 847 match = 1; 848 for (i = 0; i < addrsize && match; ++i) { 849 u32 mask = imask ? imask[i] : 0xffffffffu; 850 match = ((addr[i] ^ imap[i]) & mask) == 0; 851 } 852 for (; i < (addrsize + intsize) && match; ++i) { 853 u32 mask = imask ? imask[i] : 0xffffffffu; 854 match = 855 ((intspec[i-addrsize] ^ imap[i]) & mask) == 0; 856 } 857 imap += addrsize + intsize; 858 imaplen -= addrsize + intsize; 859 860 DBG(" -> match=%d (imaplen=%d)\n", match, imaplen); 861 862 /* Get the interrupt parent */ 863 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE) 864 newpar = of_node_get(of_irq_dflt_pic); 865 else 866 newpar = of_find_node_by_phandle((phandle)*imap); 867 imap++; 868 --imaplen; 869 870 /* Check if not found */ 871 if (newpar == NULL) { 872 DBG(" -> imap parent not found !\n"); 873 goto fail; 874 } 875 876 /* Get #interrupt-cells and #address-cells of new 877 * parent 878 */ 879 tmp = of_get_property(newpar, "#interrupt-cells", NULL); 880 if (tmp == NULL) { 881 DBG(" -> parent lacks #interrupt-cells !\n"); 882 goto fail; 883 } 884 newintsize = *tmp; 885 tmp = of_get_property(newpar, "#address-cells", NULL); 886 newaddrsize = (tmp == NULL) ? 0 : *tmp; 887 888 DBG(" -> newintsize=%d, newaddrsize=%d\n", 889 newintsize, newaddrsize); 890 891 /* Check for malformed properties */ 892 if (imaplen < (newaddrsize + newintsize)) 893 goto fail; 894 895 imap += newaddrsize + newintsize; 896 imaplen -= newaddrsize + newintsize; 897 898 DBG(" -> imaplen=%d\n", imaplen); 899 } 900 if (!match) 901 goto fail; 902 903 of_node_put(old); 904 old = of_node_get(newpar); 905 addrsize = newaddrsize; 906 intsize = newintsize; 907 intspec = imap - intsize; 908 addr = intspec - addrsize; 909 910 skiplevel: 911 /* Iterate again with new parent */ 912 DBG(" -> new parent: %s\n", newpar ? newpar->full_name : "<>"); 913 of_node_put(ipar); 914 ipar = newpar; 915 newpar = NULL; 916 } 917 fail: 918 of_node_put(ipar); 919 of_node_put(old); 920 of_node_put(newpar); 921 922 return -EINVAL; 923 } 924 EXPORT_SYMBOL_GPL(of_irq_map_raw); 925 926 #if defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32) 927 static int of_irq_map_oldworld(struct device_node *device, int index, 928 struct of_irq *out_irq) 929 { 930 const u32 *ints = NULL; 931 int intlen; 932 933 /* 934 * Old machines just have a list of interrupt numbers 935 * and no interrupt-controller nodes. We also have dodgy 936 * cases where the APPL,interrupts property is completely 937 * missing behind pci-pci bridges and we have to get it 938 * from the parent (the bridge itself, as apple just wired 939 * everything together on these) 940 */ 941 while (device) { 942 ints = of_get_property(device, "AAPL,interrupts", &intlen); 943 if (ints != NULL) 944 break; 945 device = device->parent; 946 if (device && strcmp(device->type, "pci") != 0) 947 break; 948 } 949 if (ints == NULL) 950 return -EINVAL; 951 intlen /= sizeof(u32); 952 953 if (index >= intlen) 954 return -EINVAL; 955 956 out_irq->controller = NULL; 957 out_irq->specifier[0] = ints[index]; 958 out_irq->size = 1; 959 960 return 0; 961 } 962 #else /* defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32) */ 963 static int of_irq_map_oldworld(struct device_node *device, int index, 964 struct of_irq *out_irq) 965 { 966 return -EINVAL; 967 } 968 #endif /* !(defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32)) */ 969 970 int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq) 971 { 972 struct device_node *p; 973 const u32 *intspec, *tmp, *addr; 974 u32 intsize, intlen; 975 int res; 976 977 DBG("of_irq_map_one: dev=%s, index=%d\n", device->full_name, index); 978 979 /* OldWorld mac stuff is "special", handle out of line */ 980 if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC) 981 return of_irq_map_oldworld(device, index, out_irq); 982 983 /* Get the interrupts property */ 984 intspec = of_get_property(device, "interrupts", &intlen); 985 if (intspec == NULL) 986 return -EINVAL; 987 intlen /= sizeof(u32); 988 989 /* Get the reg property (if any) */ 990 addr = of_get_property(device, "reg", NULL); 991 992 /* Look for the interrupt parent. */ 993 p = of_irq_find_parent(device); 994 if (p == NULL) 995 return -EINVAL; 996 997 /* Get size of interrupt specifier */ 998 tmp = of_get_property(p, "#interrupt-cells", NULL); 999 if (tmp == NULL) { 1000 of_node_put(p); 1001 return -EINVAL; 1002 } 1003 intsize = *tmp; 1004 1005 DBG(" intsize=%d intlen=%d\n", intsize, intlen); 1006 1007 /* Check index */ 1008 if ((index + 1) * intsize > intlen) 1009 return -EINVAL; 1010 1011 /* Get new specifier and map it */ 1012 res = of_irq_map_raw(p, intspec + index * intsize, intsize, 1013 addr, out_irq); 1014 of_node_put(p); 1015 return res; 1016 } 1017 EXPORT_SYMBOL_GPL(of_irq_map_one); 1018 1019 /** 1020 * Search the device tree for the best MAC address to use. 'mac-address' is 1021 * checked first, because that is supposed to contain to "most recent" MAC 1022 * address. If that isn't set, then 'local-mac-address' is checked next, 1023 * because that is the default address. If that isn't set, then the obsolete 1024 * 'address' is checked, just in case we're using an old device tree. 1025 * 1026 * Note that the 'address' property is supposed to contain a virtual address of 1027 * the register set, but some DTS files have redefined that property to be the 1028 * MAC address. 1029 * 1030 * All-zero MAC addresses are rejected, because those could be properties that 1031 * exist in the device tree, but were not set by U-Boot. For example, the 1032 * DTS could define 'mac-address' and 'local-mac-address', with zero MAC 1033 * addresses. Some older U-Boots only initialized 'local-mac-address'. In 1034 * this case, the real MAC is in 'local-mac-address', and 'mac-address' exists 1035 * but is all zeros. 1036 */ 1037 const void *of_get_mac_address(struct device_node *np) 1038 { 1039 struct property *pp; 1040 1041 pp = of_find_property(np, "mac-address", NULL); 1042 if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value)) 1043 return pp->value; 1044 1045 pp = of_find_property(np, "local-mac-address", NULL); 1046 if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value)) 1047 return pp->value; 1048 1049 pp = of_find_property(np, "address", NULL); 1050 if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value)) 1051 return pp->value; 1052 1053 return NULL; 1054 } 1055 EXPORT_SYMBOL(of_get_mac_address); 1056 1057 int of_irq_to_resource(struct device_node *dev, int index, struct resource *r) 1058 { 1059 int irq = irq_of_parse_and_map(dev, index); 1060 1061 /* Only dereference the resource if both the 1062 * resource and the irq are valid. */ 1063 if (r && irq != NO_IRQ) { 1064 r->start = r->end = irq; 1065 r->flags = IORESOURCE_IRQ; 1066 } 1067 1068 return irq; 1069 } 1070 EXPORT_SYMBOL_GPL(of_irq_to_resource); 1071 1072 void __iomem *of_iomap(struct device_node *np, int index) 1073 { 1074 struct resource res; 1075 1076 if (of_address_to_resource(np, index, &res)) 1077 return NULL; 1078 1079 return ioremap(res.start, 1 + res.end - res.start); 1080 } 1081 EXPORT_SYMBOL(of_iomap); 1082