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>
9 #include <asm/pci-bridge.h>
12 #define DBG(fmt...) do { printk(fmt); } while(0)
14 #define DBG(fmt...) do { } while(0)
23 /* Max address size we deal with */
24 #define OF_MAX_ADDR_CELLS 4
25 #define OF_CHECK_COUNTS(na, ns) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS && \
28 static struct of_bus *of_match_bus(struct device_node *np);
29 static int __of_address_to_resource(struct device_node *dev,
30 const u32 *addrp, u64 size, unsigned int flags,
36 static void of_dump_addr(const char *s, const u32 *addr, int na)
40 printk(" %08x", *(addr++));
44 static void of_dump_addr(const char *s, const u32 *addr, int na) { }
48 /* Callbacks for bus specific translators */
51 const char *addresses;
52 int (*match)(struct device_node *parent);
53 void (*count_cells)(struct device_node *child,
54 int *addrc, int *sizec);
55 u64 (*map)(u32 *addr, const u32 *range,
56 int na, int ns, int pna);
57 int (*translate)(u32 *addr, u64 offset, int na);
58 unsigned int (*get_flags)(const u32 *addr);
63 * Default translator (generic bus)
66 static void of_bus_default_count_cells(struct device_node *dev,
67 int *addrc, int *sizec)
70 *addrc = prom_n_addr_cells(dev);
72 *sizec = prom_n_size_cells(dev);
75 static u64 of_bus_default_map(u32 *addr, const u32 *range,
76 int na, int ns, int pna)
80 cp = of_read_number(range, na);
81 s = of_read_number(range + na + pna, ns);
82 da = of_read_number(addr, na);
84 DBG("OF: default map, cp="PRu64", s="PRu64", da="PRu64"\n",
87 if (da < cp || da >= (cp + s))
92 static int of_bus_default_translate(u32 *addr, u64 offset, int na)
94 u64 a = of_read_number(addr, na);
95 memset(addr, 0, na * 4);
98 addr[na - 2] = a >> 32;
99 addr[na - 1] = a & 0xffffffffu;
104 static unsigned int of_bus_default_get_flags(const u32 *addr)
106 return IORESOURCE_MEM;
112 * PCI bus specific translator
115 static int of_bus_pci_match(struct device_node *np)
117 /* "vci" is for the /chaos bridge on 1st-gen PCI powermacs */
118 return !strcmp(np->type, "pci") || !strcmp(np->type, "vci");
121 static void of_bus_pci_count_cells(struct device_node *np,
122 int *addrc, int *sizec)
130 static u64 of_bus_pci_map(u32 *addr, const u32 *range, int na, int ns, int pna)
134 /* Check address type match */
135 if ((addr[0] ^ range[0]) & 0x03000000)
138 /* Read address values, skipping high cell */
139 cp = of_read_number(range + 1, na - 1);
140 s = of_read_number(range + na + pna, ns);
141 da = of_read_number(addr + 1, na - 1);
143 DBG("OF: PCI map, cp="PRu64", s="PRu64", da="PRu64"\n", cp, s, da);
145 if (da < cp || da >= (cp + s))
150 static int of_bus_pci_translate(u32 *addr, u64 offset, int na)
152 return of_bus_default_translate(addr + 1, offset, na - 1);
155 static unsigned int of_bus_pci_get_flags(const u32 *addr)
157 unsigned int flags = 0;
160 switch((w >> 24) & 0x03) {
162 flags |= IORESOURCE_IO;
163 case 0x02: /* 32 bits */
164 case 0x03: /* 64 bits */
165 flags |= IORESOURCE_MEM;
168 flags |= IORESOURCE_PREFETCH;
172 const u32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size,
177 struct device_node *parent;
179 int onesize, i, na, ns;
181 /* Get parent & match bus type */
182 parent = of_get_parent(dev);
185 bus = of_match_bus(parent);
186 if (strcmp(bus->name, "pci")) {
190 bus->count_cells(dev, &na, &ns);
192 if (!OF_CHECK_COUNTS(na, ns))
195 /* Get "reg" or "assigned-addresses" property */
196 prop = get_property(dev, bus->addresses, &psize);
202 for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++)
203 if ((prop[0] & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0)) {
205 *size = of_read_number(prop + na, ns);
207 *flags = bus->get_flags(prop);
212 EXPORT_SYMBOL(of_get_pci_address);
214 int of_pci_address_to_resource(struct device_node *dev, int bar,
221 addrp = of_get_pci_address(dev, bar, &size, &flags);
224 return __of_address_to_resource(dev, addrp, size, flags, r);
226 EXPORT_SYMBOL_GPL(of_pci_address_to_resource);
228 static u8 of_irq_pci_swizzle(u8 slot, u8 pin)
230 return (((pin - 1) + slot) % 4) + 1;
233 int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq)
235 struct device_node *dn, *ppnode;
236 struct pci_dev *ppdev;
242 /* Check if we have a device node, if yes, fallback to standard OF
245 dn = pci_device_to_OF_node(pdev);
247 return of_irq_map_one(dn, 0, out_irq);
249 /* Ok, we don't, time to have fun. Let's start by building up an
250 * interrupt spec. we assume #interrupt-cells is 1, which is standard
251 * for PCI. If you do different, then don't use that routine.
253 rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
260 /* Now we walk up the PCI tree */
263 /* Get the pci_dev of our parent */
264 ppdev = pdev->bus->self;
266 /* Ouch, it's a host bridge... */
269 ppnode = pci_bus_to_OF_node(pdev->bus);
271 struct pci_controller *host;
272 host = pci_bus_to_host(pdev->bus);
273 ppnode = host ? host->arch_data : NULL;
275 /* No node for host bridge ? give up */
279 /* We found a P2P bridge, check if it has a node */
280 ppnode = pci_device_to_OF_node(ppdev);
282 /* Ok, we have found a parent with a device-node, hand over to
283 * the OF parsing code.
284 * We build a unit address from the linux device to be used for
285 * resolution. Note that we use the linux bus number which may
286 * not match your firmware bus numbering.
287 * Fortunately, in most cases, interrupt-map-mask doesn't include
288 * the bus number as part of the matching.
289 * You should still be careful about that though if you intend
290 * to rely on this function (you ship a firmware that doesn't
291 * create device nodes for all PCI devices).
296 /* We can only get here if we hit a P2P bridge with no node,
297 * let's do standard swizzling and try again
299 lspec = of_irq_pci_swizzle(PCI_SLOT(pdev->devfn), lspec);
303 laddr[0] = (pdev->bus->number << 16)
304 | (pdev->devfn << 8);
305 laddr[1] = laddr[2] = 0;
306 return of_irq_map_raw(ppnode, &lspec, 1, laddr, out_irq);
308 EXPORT_SYMBOL_GPL(of_irq_map_pci);
309 #endif /* CONFIG_PCI */
312 * ISA bus specific translator
315 static int of_bus_isa_match(struct device_node *np)
317 return !strcmp(np->name, "isa");
320 static void of_bus_isa_count_cells(struct device_node *child,
321 int *addrc, int *sizec)
329 static u64 of_bus_isa_map(u32 *addr, const u32 *range, int na, int ns, int pna)
333 /* Check address type match */
334 if ((addr[0] ^ range[0]) & 0x00000001)
337 /* Read address values, skipping high cell */
338 cp = of_read_number(range + 1, na - 1);
339 s = of_read_number(range + na + pna, ns);
340 da = of_read_number(addr + 1, na - 1);
342 DBG("OF: ISA map, cp="PRu64", s="PRu64", da="PRu64"\n", cp, s, da);
344 if (da < cp || da >= (cp + s))
349 static int of_bus_isa_translate(u32 *addr, u64 offset, int na)
351 return of_bus_default_translate(addr + 1, offset, na - 1);
354 static unsigned int of_bus_isa_get_flags(const u32 *addr)
356 unsigned int flags = 0;
360 flags |= IORESOURCE_IO;
362 flags |= IORESOURCE_MEM;
368 * Array of bus specific translators
371 static struct of_bus of_busses[] = {
376 .addresses = "assigned-addresses",
377 .match = of_bus_pci_match,
378 .count_cells = of_bus_pci_count_cells,
379 .map = of_bus_pci_map,
380 .translate = of_bus_pci_translate,
381 .get_flags = of_bus_pci_get_flags,
383 #endif /* CONFIG_PCI */
388 .match = of_bus_isa_match,
389 .count_cells = of_bus_isa_count_cells,
390 .map = of_bus_isa_map,
391 .translate = of_bus_isa_translate,
392 .get_flags = of_bus_isa_get_flags,
399 .count_cells = of_bus_default_count_cells,
400 .map = of_bus_default_map,
401 .translate = of_bus_default_translate,
402 .get_flags = of_bus_default_get_flags,
406 static struct of_bus *of_match_bus(struct device_node *np)
410 for (i = 0; i < ARRAY_SIZE(of_busses); i ++)
411 if (!of_busses[i].match || of_busses[i].match(np))
412 return &of_busses[i];
417 static int of_translate_one(struct device_node *parent, struct of_bus *bus,
418 struct of_bus *pbus, u32 *addr,
419 int na, int ns, int pna)
424 u64 offset = OF_BAD_ADDR;
426 /* Normally, an absence of a "ranges" property means we are
427 * crossing a non-translatable boundary, and thus the addresses
428 * below the current not cannot be converted to CPU physical ones.
429 * Unfortunately, while this is very clear in the spec, it's not
430 * what Apple understood, and they do have things like /uni-n or
431 * /ht nodes with no "ranges" property and a lot of perfectly
432 * useable mapped devices below them. Thus we treat the absence of
433 * "ranges" as equivalent to an empty "ranges" property which means
434 * a 1:1 translation at that level. It's up to the caller not to try
435 * to translate addresses that aren't supposed to be translated in
436 * the first place. --BenH.
438 ranges = get_property(parent, "ranges", &rlen);
439 if (ranges == NULL || rlen == 0) {
440 offset = of_read_number(addr, na);
441 memset(addr, 0, pna * 4);
442 DBG("OF: no ranges, 1:1 translation\n");
446 DBG("OF: walking ranges...\n");
448 /* Now walk through the ranges */
450 rone = na + pna + ns;
451 for (; rlen >= rone; rlen -= rone, ranges += rone) {
452 offset = bus->map(addr, ranges, na, ns, pna);
453 if (offset != OF_BAD_ADDR)
456 if (offset == OF_BAD_ADDR) {
457 DBG("OF: not found !\n");
460 memcpy(addr, ranges + na, 4 * pna);
463 of_dump_addr("OF: parent translation for:", addr, pna);
464 DBG("OF: with offset: "PRu64"\n", offset);
466 /* Translate it into parent bus space */
467 return pbus->translate(addr, offset, pna);
472 * Translate an address from the device-tree into a CPU physical address,
473 * this walks up the tree and applies the various bus mappings on the
476 * Note: We consider that crossing any level with #size-cells == 0 to mean
477 * that translation is impossible (that is we are not dealing with a value
478 * that can be mapped to a cpu physical address). This is not really specified
479 * that way, but this is traditionally the way IBM at least do things
481 u64 of_translate_address(struct device_node *dev, const u32 *in_addr)
483 struct device_node *parent = NULL;
484 struct of_bus *bus, *pbus;
485 u32 addr[OF_MAX_ADDR_CELLS];
486 int na, ns, pna, pns;
487 u64 result = OF_BAD_ADDR;
489 DBG("OF: ** translation for device %s **\n", dev->full_name);
491 /* Increase refcount at current level */
494 /* Get parent & match bus type */
495 parent = of_get_parent(dev);
498 bus = of_match_bus(parent);
500 /* Cound address cells & copy address locally */
501 bus->count_cells(dev, &na, &ns);
502 if (!OF_CHECK_COUNTS(na, ns)) {
503 printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
507 memcpy(addr, in_addr, na * 4);
509 DBG("OF: bus is %s (na=%d, ns=%d) on %s\n",
510 bus->name, na, ns, parent->full_name);
511 of_dump_addr("OF: translating address:", addr, na);
515 /* Switch to parent bus */
518 parent = of_get_parent(dev);
520 /* If root, we have finished */
521 if (parent == NULL) {
522 DBG("OF: reached root node\n");
523 result = of_read_number(addr, na);
527 /* Get new parent bus and counts */
528 pbus = of_match_bus(parent);
529 pbus->count_cells(dev, &pna, &pns);
530 if (!OF_CHECK_COUNTS(pna, pns)) {
531 printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
536 DBG("OF: parent bus is %s (na=%d, ns=%d) on %s\n",
537 pbus->name, pna, pns, parent->full_name);
539 /* Apply bus translation */
540 if (of_translate_one(dev, bus, pbus, addr, na, ns, pna))
543 /* Complete the move up one level */
548 of_dump_addr("OF: one level translation:", addr, na);
556 EXPORT_SYMBOL(of_translate_address);
558 const u32 *of_get_address(struct device_node *dev, int index, u64 *size,
563 struct device_node *parent;
565 int onesize, i, na, ns;
567 /* Get parent & match bus type */
568 parent = of_get_parent(dev);
571 bus = of_match_bus(parent);
572 bus->count_cells(dev, &na, &ns);
574 if (!OF_CHECK_COUNTS(na, ns))
577 /* Get "reg" or "assigned-addresses" property */
578 prop = get_property(dev, bus->addresses, &psize);
584 for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++)
587 *size = of_read_number(prop + na, ns);
589 *flags = bus->get_flags(prop);
594 EXPORT_SYMBOL(of_get_address);
596 static int __of_address_to_resource(struct device_node *dev, const u32 *addrp,
597 u64 size, unsigned int flags,
602 if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0)
604 taddr = of_translate_address(dev, addrp);
605 if (taddr == OF_BAD_ADDR)
607 memset(r, 0, sizeof(struct resource));
608 if (flags & IORESOURCE_IO) {
610 port = pci_address_to_pio(taddr);
611 if (port == (unsigned long)-1)
614 r->end = port + size - 1;
617 r->end = taddr + size - 1;
624 int of_address_to_resource(struct device_node *dev, int index,
631 addrp = of_get_address(dev, index, &size, &flags);
634 return __of_address_to_resource(dev, addrp, size, flags, r);
636 EXPORT_SYMBOL_GPL(of_address_to_resource);
638 void of_parse_dma_window(struct device_node *dn, const void *dma_window_prop,
639 unsigned long *busno, unsigned long *phys, unsigned long *size)
641 const u32 *dma_window;
643 const unsigned char *prop;
645 dma_window = dma_window_prop;
647 /* busno is always one cell */
648 *busno = *(dma_window++);
650 prop = get_property(dn, "ibm,#dma-address-cells", NULL);
652 prop = get_property(dn, "#address-cells", NULL);
654 cells = prop ? *(u32 *)prop : prom_n_addr_cells(dn);
655 *phys = of_read_number(dma_window, cells);
659 prop = get_property(dn, "ibm,#dma-size-cells", NULL);
660 cells = prop ? *(u32 *)prop : prom_n_size_cells(dn);
661 *size = of_read_number(dma_window, cells);
668 static unsigned int of_irq_workarounds;
669 static struct device_node *of_irq_dflt_pic;
671 static struct device_node *of_irq_find_parent(struct device_node *child)
673 struct device_node *p;
676 if (!of_node_get(child))
680 parp = get_property(child, "interrupt-parent", NULL);
682 p = of_get_parent(child);
684 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE)
685 p = of_node_get(of_irq_dflt_pic);
687 p = of_find_node_by_phandle(*parp);
691 } while (p && get_property(p, "#interrupt-cells", NULL) == NULL);
696 /* This doesn't need to be called if you don't have any special workaround
699 void of_irq_map_init(unsigned int flags)
701 of_irq_workarounds = flags;
703 /* OldWorld, don't bother looking at other things */
704 if (flags & OF_IMAP_OLDWORLD_MAC)
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
712 if (flags & OF_IMAP_NO_PHANDLE) {
713 struct device_node *np;
715 for(np = NULL; (np = of_find_all_nodes(np)) != NULL;) {
716 if (get_property(np, "interrupt-controller", NULL)
719 /* Skip /chosen/interrupt-controller */
720 if (strcmp(np->name, "chosen") == 0)
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
727 if (strcmp(np->name, "AppleKiwi") == 0)
729 /* I think we found one ! */
730 of_irq_dflt_pic = np;
737 int of_irq_map_raw(struct device_node *parent, const u32 *intspec, u32 ointsize,
738 const u32 *addr, struct of_irq *out_irq)
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;
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);
748 ipar = of_node_get(parent);
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
755 tmp = get_property(ipar, "#interrupt-cells", NULL);
761 ipar = of_irq_find_parent(ipar);
765 DBG(" -> no parent found !\n");
769 DBG("of_irq_map_raw: ipar=%s, size=%d\n", ipar->full_name, intsize);
771 if (ointsize != intsize)
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
777 old = of_node_get(ipar);
779 tmp = get_property(old, "#address-cells", NULL);
780 tnode = of_get_parent(old);
783 } while(old && tmp == NULL);
786 addrsize = (tmp == NULL) ? 2 : *tmp;
788 DBG(" -> addrsize=%d\n", addrsize);
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
795 if (get_property(ipar, "interrupt-controller", NULL) != NULL) {
796 DBG(" -> got it !\n");
797 memcpy(out_irq->specifier, intspec,
798 intsize * sizeof(u32));
799 out_irq->size = intsize;
800 out_irq->controller = ipar;
805 /* Now look for an interrupt-map */
806 imap = get_property(ipar, "interrupt-map", &imaplen);
807 /* No interrupt map, check for an interrupt parent */
809 DBG(" -> no map, getting parent\n");
810 newpar = of_irq_find_parent(ipar);
813 imaplen /= sizeof(u32);
815 /* Look for a mask */
816 imask = get_property(ipar, "interrupt-map-mask", NULL);
818 /* If we were passed no "reg" property and we attempt to parse
819 * an interrupt-map, then #address-cells must be 0.
822 if (addr == NULL && addrsize != 0) {
823 DBG(" -> no reg passed in when needed !\n");
827 /* Parse interrupt-map */
829 while (imaplen > (addrsize + intsize + 1) && !match) {
830 /* Compare specifiers */
832 for (i = 0; i < addrsize && match; ++i) {
833 u32 mask = imask ? imask[i] : 0xffffffffu;
834 match = ((addr[i] ^ imap[i]) & mask) == 0;
836 for (; i < (addrsize + intsize) && match; ++i) {
837 u32 mask = imask ? imask[i] : 0xffffffffu;
839 ((intspec[i-addrsize] ^ imap[i]) & mask) == 0;
841 imap += addrsize + intsize;
842 imaplen -= addrsize + intsize;
844 DBG(" -> match=%d (imaplen=%d)\n", match, imaplen);
846 /* Get the interrupt parent */
847 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE)
848 newpar = of_node_get(of_irq_dflt_pic);
850 newpar = of_find_node_by_phandle((phandle)*imap);
854 /* Check if not found */
855 if (newpar == NULL) {
856 DBG(" -> imap parent not found !\n");
860 /* Get #interrupt-cells and #address-cells of new
863 tmp = get_property(newpar, "#interrupt-cells",
866 DBG(" -> parent lacks #interrupt-cells !\n");
870 tmp = get_property(newpar, "#address-cells",
872 newaddrsize = (tmp == NULL) ? 0 : *tmp;
874 DBG(" -> newintsize=%d, newaddrsize=%d\n",
875 newintsize, newaddrsize);
877 /* Check for malformed properties */
878 if (imaplen < (newaddrsize + newintsize))
881 imap += newaddrsize + newintsize;
882 imaplen -= newaddrsize + newintsize;
884 DBG(" -> imaplen=%d\n", imaplen);
890 old = of_node_get(newpar);
891 addrsize = newaddrsize;
892 intsize = newintsize;
893 intspec = imap - intsize;
894 addr = intspec - addrsize;
897 /* Iterate again with new parent */
898 DBG(" -> new parent: %s\n", newpar ? newpar->full_name : "<>");
910 EXPORT_SYMBOL_GPL(of_irq_map_raw);
912 #if defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32)
913 static int of_irq_map_oldworld(struct device_node *device, int index,
914 struct of_irq *out_irq)
920 * Old machines just have a list of interrupt numbers
921 * and no interrupt-controller nodes.
923 ints = get_property(device, "AAPL,interrupts", &intlen);
926 intlen /= sizeof(u32);
931 out_irq->controller = NULL;
932 out_irq->specifier[0] = ints[index];
937 #else /* defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32) */
938 static int of_irq_map_oldworld(struct device_node *device, int index,
939 struct of_irq *out_irq)
943 #endif /* !(defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32)) */
945 int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq)
947 struct device_node *p;
948 const u32 *intspec, *tmp, *addr;
952 DBG("of_irq_map_one: dev=%s, index=%d\n", device->full_name, index);
954 /* OldWorld mac stuff is "special", handle out of line */
955 if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
956 return of_irq_map_oldworld(device, index, out_irq);
958 /* Get the interrupts property */
959 intspec = get_property(device, "interrupts", &intlen);
962 intlen /= sizeof(u32);
964 /* Get the reg property (if any) */
965 addr = get_property(device, "reg", NULL);
967 /* Look for the interrupt parent. */
968 p = of_irq_find_parent(device);
972 /* Get size of interrupt specifier */
973 tmp = get_property(p, "#interrupt-cells", NULL);
980 DBG(" intsize=%d intlen=%d\n", intsize, intlen);
983 if ((index + 1) * intsize > intlen)
986 /* Get new specifier and map it */
987 res = of_irq_map_raw(p, intspec + index * intsize, intsize,
992 EXPORT_SYMBOL_GPL(of_irq_map_one);