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 29static struct of_bus *of_match_bus(struct device_node *np); 30static 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 37static 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 45static void of_dump_addr(const char *s, const u32 *addr, int na) { } 46#endif 47 48 49/* Callbacks for bus specific translators */ 50struct 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 67static 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 76static 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 93static 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 105static 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 116static 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 122static 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 131static 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 151static 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 156static 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 175const 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} 215EXPORT_SYMBOL(of_get_pci_address); 216 217int 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} 229EXPORT_SYMBOL_GPL(of_pci_address_to_resource); 230 231static u8 of_irq_pci_swizzle(u8 slot, u8 pin) 232{ 233 return (((pin - 1) + slot) % 4) + 1; 234} 235 236int 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->arch_data : 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} 311EXPORT_SYMBOL_GPL(of_irq_map_pci); 312#endif /* CONFIG_PCI */ 313 314/* 315 * ISA bus specific translator 316 */ 317 318static int of_bus_isa_match(struct device_node *np) 319{ 320 return !strcmp(np->name, "isa"); 321} 322 323static 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 332static 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 352static 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 357static 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 374static 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 409static 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 420static 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) 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, "ranges", &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 */ 484u64 of_translate_address(struct device_node *dev, const u32 *in_addr) 485{ 486 struct device_node *parent = NULL; 487 struct of_bus *bus, *pbus; 488 u32 addr[OF_MAX_ADDR_CELLS]; 489 int na, ns, pna, pns; 490 u64 result = OF_BAD_ADDR; 491 492 DBG("OF: ** translation for device %s **\n", dev->full_name); 493 494 /* Increase refcount at current level */ 495 of_node_get(dev); 496 497 /* Get parent & match bus type */ 498 parent = of_get_parent(dev); 499 if (parent == NULL) 500 goto bail; 501 bus = of_match_bus(parent); 502 503 /* Cound address cells & copy address locally */ 504 bus->count_cells(dev, &na, &ns); 505 if (!OF_CHECK_COUNTS(na, ns)) { 506 printk(KERN_ERR "prom_parse: Bad cell count for %s\n", 507 dev->full_name); 508 goto bail; 509 } 510 memcpy(addr, in_addr, na * 4); 511 512 DBG("OF: bus is %s (na=%d, ns=%d) on %s\n", 513 bus->name, na, ns, parent->full_name); 514 of_dump_addr("OF: translating address:", addr, na); 515 516 /* Translate */ 517 for (;;) { 518 /* Switch to parent bus */ 519 of_node_put(dev); 520 dev = parent; 521 parent = of_get_parent(dev); 522 523 /* If root, we have finished */ 524 if (parent == NULL) { 525 DBG("OF: reached root node\n"); 526 result = of_read_number(addr, na); 527 break; 528 } 529 530 /* Get new parent bus and counts */ 531 pbus = of_match_bus(parent); 532 pbus->count_cells(dev, &pna, &pns); 533 if (!OF_CHECK_COUNTS(pna, pns)) { 534 printk(KERN_ERR "prom_parse: Bad cell count for %s\n", 535 dev->full_name); 536 break; 537 } 538 539 DBG("OF: parent bus is %s (na=%d, ns=%d) on %s\n", 540 pbus->name, pna, pns, parent->full_name); 541 542 /* Apply bus translation */ 543 if (of_translate_one(dev, bus, pbus, addr, na, ns, pna)) 544 break; 545 546 /* Complete the move up one level */ 547 na = pna; 548 ns = pns; 549 bus = pbus; 550 551 of_dump_addr("OF: one level translation:", addr, na); 552 } 553 bail: 554 of_node_put(parent); 555 of_node_put(dev); 556 557 return result; 558} 559EXPORT_SYMBOL(of_translate_address); 560 561const u32 *of_get_address(struct device_node *dev, int index, u64 *size, 562 unsigned int *flags) 563{ 564 const u32 *prop; 565 unsigned int psize; 566 struct device_node *parent; 567 struct of_bus *bus; 568 int onesize, i, na, ns; 569 570 /* Get parent & match bus type */ 571 parent = of_get_parent(dev); 572 if (parent == NULL) 573 return NULL; 574 bus = of_match_bus(parent); 575 bus->count_cells(dev, &na, &ns); 576 of_node_put(parent); 577 if (!OF_CHECK_COUNTS(na, ns)) 578 return NULL; 579 580 /* Get "reg" or "assigned-addresses" property */ 581 prop = of_get_property(dev, bus->addresses, &psize); 582 if (prop == NULL) 583 return NULL; 584 psize /= 4; 585 586 onesize = na + ns; 587 for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) 588 if (i == index) { 589 if (size) 590 *size = of_read_number(prop + na, ns); 591 if (flags) 592 *flags = bus->get_flags(prop); 593 return prop; 594 } 595 return NULL; 596} 597EXPORT_SYMBOL(of_get_address); 598 599static int __of_address_to_resource(struct device_node *dev, const u32 *addrp, 600 u64 size, unsigned int flags, 601 struct resource *r) 602{ 603 u64 taddr; 604 605 if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0) 606 return -EINVAL; 607 taddr = of_translate_address(dev, addrp); 608 if (taddr == OF_BAD_ADDR) 609 return -EINVAL; 610 memset(r, 0, sizeof(struct resource)); 611 if (flags & IORESOURCE_IO) { 612 unsigned long port; 613 port = pci_address_to_pio(taddr); 614 if (port == (unsigned long)-1) 615 return -EINVAL; 616 r->start = port; 617 r->end = port + size - 1; 618 } else { 619 r->start = taddr; 620 r->end = taddr + size - 1; 621 } 622 r->flags = flags; 623 r->name = dev->name; 624 return 0; 625} 626 627int of_address_to_resource(struct device_node *dev, int index, 628 struct resource *r) 629{ 630 const u32 *addrp; 631 u64 size; 632 unsigned int flags; 633 634 addrp = of_get_address(dev, index, &size, &flags); 635 if (addrp == NULL) 636 return -EINVAL; 637 return __of_address_to_resource(dev, addrp, size, flags, r); 638} 639EXPORT_SYMBOL_GPL(of_address_to_resource); 640 641void of_parse_dma_window(struct device_node *dn, const void *dma_window_prop, 642 unsigned long *busno, unsigned long *phys, unsigned long *size) 643{ 644 const u32 *dma_window; 645 u32 cells; 646 const unsigned char *prop; 647 648 dma_window = dma_window_prop; 649 650 /* busno is always one cell */ 651 *busno = *(dma_window++); 652 653 prop = of_get_property(dn, "ibm,#dma-address-cells", NULL); 654 if (!prop) 655 prop = of_get_property(dn, "#address-cells", NULL); 656 657 cells = prop ? *(u32 *)prop : of_n_addr_cells(dn); 658 *phys = of_read_number(dma_window, cells); 659 660 dma_window += cells; 661 662 prop = of_get_property(dn, "ibm,#dma-size-cells", NULL); 663 cells = prop ? *(u32 *)prop : of_n_size_cells(dn); 664 *size = of_read_number(dma_window, cells); 665} 666 667/* 668 * Interrupt remapper 669 */ 670 671static unsigned int of_irq_workarounds; 672static struct device_node *of_irq_dflt_pic; 673 674static struct device_node *of_irq_find_parent(struct device_node *child) 675{ 676 struct device_node *p; 677 const phandle *parp; 678 679 if (!of_node_get(child)) 680 return NULL; 681 682 do { 683 parp = of_get_property(child, "interrupt-parent", NULL); 684 if (parp == NULL) 685 p = of_get_parent(child); 686 else { 687 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE) 688 p = of_node_get(of_irq_dflt_pic); 689 else 690 p = of_find_node_by_phandle(*parp); 691 } 692 of_node_put(child); 693 child = p; 694 } while (p && of_get_property(p, "#interrupt-cells", NULL) == NULL); 695 696 return p; 697} 698 699void of_irq_map_init(unsigned int flags) 700{ 701 of_irq_workarounds = flags; 702 703 /* OldWorld, don't bother looking at other things */ 704 if (flags & OF_IMAP_OLDWORLD_MAC) 705 return; 706 707 /* If we don't have phandles, let's try to locate a default interrupt 708 * controller (happens when booting with BootX). We do a first match 709 * here, hopefully, that only ever happens on machines with one 710 * controller. 711 */ 712 if (flags & OF_IMAP_NO_PHANDLE) { 713 struct device_node *np; 714 715 for(np = NULL; (np = of_find_all_nodes(np)) != NULL;) { 716 if (of_get_property(np, "interrupt-controller", NULL) 717 == NULL) 718 continue; 719 /* Skip /chosen/interrupt-controller */ 720 if (strcmp(np->name, "chosen") == 0) 721 continue; 722 /* It seems like at least one person on this planet wants 723 * to use BootX on a machine with an AppleKiwi controller 724 * which happens to pretend to be an interrupt 725 * controller too. 726 */ 727 if (strcmp(np->name, "AppleKiwi") == 0) 728 continue; 729 /* I think we found one ! */ 730 of_irq_dflt_pic = np; 731 break; 732 } 733 } 734 735} 736 737int of_irq_map_raw(struct device_node *parent, const u32 *intspec, u32 ointsize, 738 const u32 *addr, struct of_irq *out_irq) 739{ 740 struct device_node *ipar, *tnode, *old = NULL, *newpar = NULL; 741 const u32 *tmp, *imap, *imask; 742 u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0; 743 int imaplen, match, i; 744 745 DBG("of_irq_map_raw: par=%s,intspec=[0x%08x 0x%08x...],ointsize=%d\n", 746 parent->full_name, intspec[0], intspec[1], ointsize); 747 748 ipar = of_node_get(parent); 749 750 /* First get the #interrupt-cells property of the current cursor 751 * that tells us how to interpret the passed-in intspec. If there 752 * is none, we are nice and just walk up the tree 753 */ 754 do { 755 tmp = of_get_property(ipar, "#interrupt-cells", NULL); 756 if (tmp != NULL) { 757 intsize = *tmp; 758 break; 759 } 760 tnode = ipar; 761 ipar = of_irq_find_parent(ipar); 762 of_node_put(tnode); 763 } while (ipar); 764 if (ipar == NULL) { 765 DBG(" -> no parent found !\n"); 766 goto fail; 767 } 768 769 DBG("of_irq_map_raw: ipar=%s, size=%d\n", ipar->full_name, intsize); 770 771 if (ointsize != intsize) 772 return -EINVAL; 773 774 /* Look for this #address-cells. We have to implement the old linux 775 * trick of looking for the parent here as some device-trees rely on it 776 */ 777 old = of_node_get(ipar); 778 do { 779 tmp = of_get_property(old, "#address-cells", NULL); 780 tnode = of_get_parent(old); 781 of_node_put(old); 782 old = tnode; 783 } while(old && tmp == NULL); 784 of_node_put(old); 785 old = NULL; 786 addrsize = (tmp == NULL) ? 2 : *tmp; 787 788 DBG(" -> addrsize=%d\n", addrsize); 789 790 /* Now start the actual "proper" walk of the interrupt tree */ 791 while (ipar != NULL) { 792 /* Now check if cursor is an interrupt-controller and if it is 793 * then we are done 794 */ 795 if (of_get_property(ipar, "interrupt-controller", NULL) != 796 NULL) { 797 DBG(" -> got it !\n"); 798 memcpy(out_irq->specifier, intspec, 799 intsize * sizeof(u32)); 800 out_irq->size = intsize; 801 out_irq->controller = ipar; 802 of_node_put(old); 803 return 0; 804 } 805 806 /* Now look for an interrupt-map */ 807 imap = of_get_property(ipar, "interrupt-map", &imaplen); 808 /* No interrupt map, check for an interrupt parent */ 809 if (imap == NULL) { 810 DBG(" -> no map, getting parent\n"); 811 newpar = of_irq_find_parent(ipar); 812 goto skiplevel; 813 } 814 imaplen /= sizeof(u32); 815 816 /* Look for a mask */ 817 imask = of_get_property(ipar, "interrupt-map-mask", NULL); 818 819 /* If we were passed no "reg" property and we attempt to parse 820 * an interrupt-map, then #address-cells must be 0. 821 * Fail if it's not. 822 */ 823 if (addr == NULL && addrsize != 0) { 824 DBG(" -> no reg passed in when needed !\n"); 825 goto fail; 826 } 827 828 /* Parse interrupt-map */ 829 match = 0; 830 while (imaplen > (addrsize + intsize + 1) && !match) { 831 /* Compare specifiers */ 832 match = 1; 833 for (i = 0; i < addrsize && match; ++i) { 834 u32 mask = imask ? imask[i] : 0xffffffffu; 835 match = ((addr[i] ^ imap[i]) & mask) == 0; 836 } 837 for (; i < (addrsize + intsize) && match; ++i) { 838 u32 mask = imask ? imask[i] : 0xffffffffu; 839 match = 840 ((intspec[i-addrsize] ^ imap[i]) & mask) == 0; 841 } 842 imap += addrsize + intsize; 843 imaplen -= addrsize + intsize; 844 845 DBG(" -> match=%d (imaplen=%d)\n", match, imaplen); 846 847 /* Get the interrupt parent */ 848 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE) 849 newpar = of_node_get(of_irq_dflt_pic); 850 else 851 newpar = of_find_node_by_phandle((phandle)*imap); 852 imap++; 853 --imaplen; 854 855 /* Check if not found */ 856 if (newpar == NULL) { 857 DBG(" -> imap parent not found !\n"); 858 goto fail; 859 } 860 861 /* Get #interrupt-cells and #address-cells of new 862 * parent 863 */ 864 tmp = of_get_property(newpar, "#interrupt-cells", NULL); 865 if (tmp == NULL) { 866 DBG(" -> parent lacks #interrupt-cells !\n"); 867 goto fail; 868 } 869 newintsize = *tmp; 870 tmp = of_get_property(newpar, "#address-cells", NULL); 871 newaddrsize = (tmp == NULL) ? 0 : *tmp; 872 873 DBG(" -> newintsize=%d, newaddrsize=%d\n", 874 newintsize, newaddrsize); 875 876 /* Check for malformed properties */ 877 if (imaplen < (newaddrsize + newintsize)) 878 goto fail; 879 880 imap += newaddrsize + newintsize; 881 imaplen -= newaddrsize + newintsize; 882 883 DBG(" -> imaplen=%d\n", imaplen); 884 } 885 if (!match) 886 goto fail; 887 888 of_node_put(old); 889 old = of_node_get(newpar); 890 addrsize = newaddrsize; 891 intsize = newintsize; 892 intspec = imap - intsize; 893 addr = intspec - addrsize; 894 895 skiplevel: 896 /* Iterate again with new parent */ 897 DBG(" -> new parent: %s\n", newpar ? newpar->full_name : "<>"); 898 of_node_put(ipar); 899 ipar = newpar; 900 newpar = NULL; 901 } 902 fail: 903 of_node_put(ipar); 904 of_node_put(old); 905 of_node_put(newpar); 906 907 return -EINVAL; 908} 909EXPORT_SYMBOL_GPL(of_irq_map_raw); 910 911#if defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32) 912static int of_irq_map_oldworld(struct device_node *device, int index, 913 struct of_irq *out_irq) 914{ 915 const u32 *ints = NULL; 916 int intlen; 917 918 /* 919 * Old machines just have a list of interrupt numbers 920 * and no interrupt-controller nodes. We also have dodgy 921 * cases where the APPL,interrupts property is completely 922 * missing behind pci-pci bridges and we have to get it 923 * from the parent (the bridge itself, as apple just wired 924 * everything together on these) 925 */ 926 while (device) { 927 ints = of_get_property(device, "AAPL,interrupts", &intlen); 928 if (ints != NULL) 929 break; 930 device = device->parent; 931 if (device && strcmp(device->type, "pci") != 0) 932 break; 933 } 934 if (ints == NULL) 935 return -EINVAL; 936 intlen /= sizeof(u32); 937 938 if (index >= intlen) 939 return -EINVAL; 940 941 out_irq->controller = NULL; 942 out_irq->specifier[0] = ints[index]; 943 out_irq->size = 1; 944 945 return 0; 946} 947#else /* defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32) */ 948static int of_irq_map_oldworld(struct device_node *device, int index, 949 struct of_irq *out_irq) 950{ 951 return -EINVAL; 952} 953#endif /* !(defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32)) */ 954 955int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq) 956{ 957 struct device_node *p; 958 const u32 *intspec, *tmp, *addr; 959 u32 intsize, intlen; 960 int res; 961 962 DBG("of_irq_map_one: dev=%s, index=%d\n", device->full_name, index); 963 964 /* OldWorld mac stuff is "special", handle out of line */ 965 if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC) 966 return of_irq_map_oldworld(device, index, out_irq); 967 968 /* Get the interrupts property */ 969 intspec = of_get_property(device, "interrupts", &intlen); 970 if (intspec == NULL) 971 return -EINVAL; 972 intlen /= sizeof(u32); 973 974 /* Get the reg property (if any) */ 975 addr = of_get_property(device, "reg", NULL); 976 977 /* Look for the interrupt parent. */ 978 p = of_irq_find_parent(device); 979 if (p == NULL) 980 return -EINVAL; 981 982 /* Get size of interrupt specifier */ 983 tmp = of_get_property(p, "#interrupt-cells", NULL); 984 if (tmp == NULL) { 985 of_node_put(p); 986 return -EINVAL; 987 } 988 intsize = *tmp; 989 990 DBG(" intsize=%d intlen=%d\n", intsize, intlen); 991 992 /* Check index */ 993 if ((index + 1) * intsize > intlen) 994 return -EINVAL; 995 996 /* Get new specifier and map it */ 997 res = of_irq_map_raw(p, intspec + index * intsize, intsize, 998 addr, out_irq); 999 of_node_put(p); 1000 return res; 1001} 1002EXPORT_SYMBOL_GPL(of_irq_map_one); 1003 1004/** 1005 * Search the device tree for the best MAC address to use. 'mac-address' is 1006 * checked first, because that is supposed to contain to "most recent" MAC 1007 * address. If that isn't set, then 'local-mac-address' is checked next, 1008 * because that is the default address. If that isn't set, then the obsolete 1009 * 'address' is checked, just in case we're using an old device tree. 1010 * 1011 * Note that the 'address' property is supposed to contain a virtual address of 1012 * the register set, but some DTS files have redefined that property to be the 1013 * MAC address. 1014 * 1015 * All-zero MAC addresses are rejected, because those could be properties that 1016 * exist in the device tree, but were not set by U-Boot. For example, the 1017 * DTS could define 'mac-address' and 'local-mac-address', with zero MAC 1018 * addresses. Some older U-Boots only initialized 'local-mac-address'. In 1019 * this case, the real MAC is in 'local-mac-address', and 'mac-address' exists 1020 * but is all zeros. 1021*/ 1022const void *of_get_mac_address(struct device_node *np) 1023{ 1024 struct property *pp; 1025 1026 pp = of_find_property(np, "mac-address", NULL); 1027 if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value)) 1028 return pp->value; 1029 1030 pp = of_find_property(np, "local-mac-address", NULL); 1031 if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value)) 1032 return pp->value; 1033 1034 pp = of_find_property(np, "address", NULL); 1035 if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value)) 1036 return pp->value; 1037 1038 return NULL; 1039} 1040EXPORT_SYMBOL(of_get_mac_address); 1041 1042int of_irq_to_resource(struct device_node *dev, int index, struct resource *r) 1043{ 1044 int irq = irq_of_parse_and_map(dev, index); 1045 1046 /* Only dereference the resource if both the 1047 * resource and the irq are valid. */ 1048 if (r && irq != NO_IRQ) { 1049 r->start = r->end = irq; 1050 r->flags = IORESOURCE_IRQ; 1051 } 1052 1053 return irq; 1054} 1055EXPORT_SYMBOL_GPL(of_irq_to_resource); 1056 1057void __iomem *of_iomap(struct device_node *np, int index) 1058{ 1059 struct resource res; 1060 1061 if (of_address_to_resource(np, index, &res)) 1062 return NULL; 1063 1064 return ioremap(res.start, 1 + res.end - res.start); 1065} 1066EXPORT_SYMBOL(of_iomap); 1067