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>
10 #include <asm/pci-bridge.h>
13 #define DBG(fmt...) do { printk(fmt); } while(0)
15 #define DBG(fmt...) do { } while(0)
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 && \
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
,
37 static void of_dump_addr(const char *s
, const u32
*addr
, int na
)
41 printk(" %08x", *(addr
++));
45 static void of_dump_addr(const char *s
, const u32
*addr
, int na
) { }
49 /* Callbacks for bus specific translators */
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
);
64 * Default translator (generic bus)
67 static void of_bus_default_count_cells(struct device_node
*dev
,
68 int *addrc
, int *sizec
)
71 *addrc
= of_n_addr_cells(dev
);
73 *sizec
= of_n_size_cells(dev
);
76 static u64
of_bus_default_map(u32
*addr
, const u32
*range
,
77 int na
, int ns
, int pna
)
81 cp
= of_read_number(range
, na
);
82 s
= of_read_number(range
+ na
+ pna
, ns
);
83 da
= of_read_number(addr
, na
);
85 DBG("OF: default map, cp="PRu64
", s="PRu64
", da="PRu64
"\n",
88 if (da
< cp
|| da
>= (cp
+ s
))
93 static int of_bus_default_translate(u32
*addr
, u64 offset
, int na
)
95 u64 a
= of_read_number(addr
, na
);
96 memset(addr
, 0, na
* 4);
99 addr
[na
- 2] = a
>> 32;
100 addr
[na
- 1] = a
& 0xffffffffu
;
105 static unsigned int of_bus_default_get_flags(const u32
*addr
)
107 return IORESOURCE_MEM
;
113 * PCI bus specific translator
116 static int of_bus_pci_match(struct device_node
*np
)
118 /* "vci" is for the /chaos bridge on 1st-gen PCI powermacs */
119 return !strcmp(np
->type
, "pci") || !strcmp(np
->type
, "vci");
122 static void of_bus_pci_count_cells(struct device_node
*np
,
123 int *addrc
, int *sizec
)
131 static unsigned int of_bus_pci_get_flags(const u32
*addr
)
133 unsigned int flags
= 0;
136 switch((w
>> 24) & 0x03) {
138 flags
|= IORESOURCE_IO
;
140 case 0x02: /* 32 bits */
141 case 0x03: /* 64 bits */
142 flags
|= IORESOURCE_MEM
;
146 flags
|= IORESOURCE_PREFETCH
;
150 static u64
of_bus_pci_map(u32
*addr
, const u32
*range
, int na
, int ns
, int pna
)
155 af
= of_bus_pci_get_flags(addr
);
156 rf
= of_bus_pci_get_flags(range
);
158 /* Check address type match */
159 if ((af
^ rf
) & (IORESOURCE_MEM
| IORESOURCE_IO
))
162 /* Read address values, skipping high cell */
163 cp
= of_read_number(range
+ 1, na
- 1);
164 s
= of_read_number(range
+ na
+ pna
, ns
);
165 da
= of_read_number(addr
+ 1, na
- 1);
167 DBG("OF: PCI map, cp="PRu64
", s="PRu64
", da="PRu64
"\n", cp
, s
, da
);
169 if (da
< cp
|| da
>= (cp
+ s
))
174 static int of_bus_pci_translate(u32
*addr
, u64 offset
, int na
)
176 return of_bus_default_translate(addr
+ 1, offset
, na
- 1);
179 const u32
*of_get_pci_address(struct device_node
*dev
, int bar_no
, u64
*size
,
184 struct device_node
*parent
;
186 int onesize
, i
, na
, ns
;
188 /* Get parent & match bus type */
189 parent
= of_get_parent(dev
);
192 bus
= of_match_bus(parent
);
193 if (strcmp(bus
->name
, "pci")) {
197 bus
->count_cells(dev
, &na
, &ns
);
199 if (!OF_CHECK_COUNTS(na
, ns
))
202 /* Get "reg" or "assigned-addresses" property */
203 prop
= of_get_property(dev
, bus
->addresses
, &psize
);
209 for (i
= 0; psize
>= onesize
; psize
-= onesize
, prop
+= onesize
, i
++)
210 if ((prop
[0] & 0xff) == ((bar_no
* 4) + PCI_BASE_ADDRESS_0
)) {
212 *size
= of_read_number(prop
+ na
, ns
);
214 *flags
= bus
->get_flags(prop
);
219 EXPORT_SYMBOL(of_get_pci_address
);
221 int of_pci_address_to_resource(struct device_node
*dev
, int bar
,
228 addrp
= of_get_pci_address(dev
, bar
, &size
, &flags
);
231 return __of_address_to_resource(dev
, addrp
, size
, flags
, r
);
233 EXPORT_SYMBOL_GPL(of_pci_address_to_resource
);
235 static u8
of_irq_pci_swizzle(u8 slot
, u8 pin
)
237 return (((pin
- 1) + slot
) % 4) + 1;
240 int of_irq_map_pci(struct pci_dev
*pdev
, struct of_irq
*out_irq
)
242 struct device_node
*dn
, *ppnode
;
243 struct pci_dev
*ppdev
;
249 /* Check if we have a device node, if yes, fallback to standard OF
252 dn
= pci_device_to_OF_node(pdev
);
254 return of_irq_map_one(dn
, 0, out_irq
);
256 /* Ok, we don't, time to have fun. Let's start by building up an
257 * interrupt spec. we assume #interrupt-cells is 1, which is standard
258 * for PCI. If you do different, then don't use that routine.
260 rc
= pci_read_config_byte(pdev
, PCI_INTERRUPT_PIN
, &pin
);
267 /* Now we walk up the PCI tree */
270 /* Get the pci_dev of our parent */
271 ppdev
= pdev
->bus
->self
;
273 /* Ouch, it's a host bridge... */
276 ppnode
= pci_bus_to_OF_node(pdev
->bus
);
278 struct pci_controller
*host
;
279 host
= pci_bus_to_host(pdev
->bus
);
280 ppnode
= host
? host
->dn
: NULL
;
282 /* No node for host bridge ? give up */
286 /* We found a P2P bridge, check if it has a node */
287 ppnode
= pci_device_to_OF_node(ppdev
);
289 /* Ok, we have found a parent with a device-node, hand over to
290 * the OF parsing code.
291 * We build a unit address from the linux device to be used for
292 * resolution. Note that we use the linux bus number which may
293 * not match your firmware bus numbering.
294 * Fortunately, in most cases, interrupt-map-mask doesn't include
295 * the bus number as part of the matching.
296 * You should still be careful about that though if you intend
297 * to rely on this function (you ship a firmware that doesn't
298 * create device nodes for all PCI devices).
303 /* We can only get here if we hit a P2P bridge with no node,
304 * let's do standard swizzling and try again
306 lspec
= of_irq_pci_swizzle(PCI_SLOT(pdev
->devfn
), lspec
);
310 laddr
[0] = (pdev
->bus
->number
<< 16)
311 | (pdev
->devfn
<< 8);
312 laddr
[1] = laddr
[2] = 0;
313 return of_irq_map_raw(ppnode
, &lspec
, 1, laddr
, out_irq
);
315 EXPORT_SYMBOL_GPL(of_irq_map_pci
);
316 #endif /* CONFIG_PCI */
319 * ISA bus specific translator
322 static int of_bus_isa_match(struct device_node
*np
)
324 return !strcmp(np
->name
, "isa");
327 static void of_bus_isa_count_cells(struct device_node
*child
,
328 int *addrc
, int *sizec
)
336 static u64
of_bus_isa_map(u32
*addr
, const u32
*range
, int na
, int ns
, int pna
)
340 /* Check address type match */
341 if ((addr
[0] ^ range
[0]) & 0x00000001)
344 /* Read address values, skipping high cell */
345 cp
= of_read_number(range
+ 1, na
- 1);
346 s
= of_read_number(range
+ na
+ pna
, ns
);
347 da
= of_read_number(addr
+ 1, na
- 1);
349 DBG("OF: ISA map, cp="PRu64
", s="PRu64
", da="PRu64
"\n", cp
, s
, da
);
351 if (da
< cp
|| da
>= (cp
+ s
))
356 static int of_bus_isa_translate(u32
*addr
, u64 offset
, int na
)
358 return of_bus_default_translate(addr
+ 1, offset
, na
- 1);
361 static unsigned int of_bus_isa_get_flags(const u32
*addr
)
363 unsigned int flags
= 0;
367 flags
|= IORESOURCE_IO
;
369 flags
|= IORESOURCE_MEM
;
375 * Array of bus specific translators
378 static struct of_bus of_busses
[] = {
383 .addresses
= "assigned-addresses",
384 .match
= of_bus_pci_match
,
385 .count_cells
= of_bus_pci_count_cells
,
386 .map
= of_bus_pci_map
,
387 .translate
= of_bus_pci_translate
,
388 .get_flags
= of_bus_pci_get_flags
,
390 #endif /* CONFIG_PCI */
395 .match
= of_bus_isa_match
,
396 .count_cells
= of_bus_isa_count_cells
,
397 .map
= of_bus_isa_map
,
398 .translate
= of_bus_isa_translate
,
399 .get_flags
= of_bus_isa_get_flags
,
406 .count_cells
= of_bus_default_count_cells
,
407 .map
= of_bus_default_map
,
408 .translate
= of_bus_default_translate
,
409 .get_flags
= of_bus_default_get_flags
,
413 static struct of_bus
*of_match_bus(struct device_node
*np
)
417 for (i
= 0; i
< ARRAY_SIZE(of_busses
); i
++)
418 if (!of_busses
[i
].match
|| of_busses
[i
].match(np
))
419 return &of_busses
[i
];
424 static int of_translate_one(struct device_node
*parent
, struct of_bus
*bus
,
425 struct of_bus
*pbus
, u32
*addr
,
426 int na
, int ns
, int pna
, const char *rprop
)
431 u64 offset
= OF_BAD_ADDR
;
433 /* Normally, an absence of a "ranges" property means we are
434 * crossing a non-translatable boundary, and thus the addresses
435 * below the current not cannot be converted to CPU physical ones.
436 * Unfortunately, while this is very clear in the spec, it's not
437 * what Apple understood, and they do have things like /uni-n or
438 * /ht nodes with no "ranges" property and a lot of perfectly
439 * useable mapped devices below them. Thus we treat the absence of
440 * "ranges" as equivalent to an empty "ranges" property which means
441 * a 1:1 translation at that level. It's up to the caller not to try
442 * to translate addresses that aren't supposed to be translated in
443 * the first place. --BenH.
445 ranges
= of_get_property(parent
, rprop
, &rlen
);
446 if (ranges
== NULL
|| rlen
== 0) {
447 offset
= of_read_number(addr
, na
);
448 memset(addr
, 0, pna
* 4);
449 DBG("OF: no ranges, 1:1 translation\n");
453 DBG("OF: walking ranges...\n");
455 /* Now walk through the ranges */
457 rone
= na
+ pna
+ ns
;
458 for (; rlen
>= rone
; rlen
-= rone
, ranges
+= rone
) {
459 offset
= bus
->map(addr
, ranges
, na
, ns
, pna
);
460 if (offset
!= OF_BAD_ADDR
)
463 if (offset
== OF_BAD_ADDR
) {
464 DBG("OF: not found !\n");
467 memcpy(addr
, ranges
+ na
, 4 * pna
);
470 of_dump_addr("OF: parent translation for:", addr
, pna
);
471 DBG("OF: with offset: "PRu64
"\n", offset
);
473 /* Translate it into parent bus space */
474 return pbus
->translate(addr
, offset
, pna
);
479 * Translate an address from the device-tree into a CPU physical address,
480 * this walks up the tree and applies the various bus mappings on the
483 * Note: We consider that crossing any level with #size-cells == 0 to mean
484 * that translation is impossible (that is we are not dealing with a value
485 * that can be mapped to a cpu physical address). This is not really specified
486 * that way, but this is traditionally the way IBM at least do things
488 u64
__of_translate_address(struct device_node
*dev
, const u32
*in_addr
,
491 struct device_node
*parent
= NULL
;
492 struct of_bus
*bus
, *pbus
;
493 u32 addr
[OF_MAX_ADDR_CELLS
];
494 int na
, ns
, pna
, pns
;
495 u64 result
= OF_BAD_ADDR
;
497 DBG("OF: ** translation for device %s **\n", dev
->full_name
);
499 /* Increase refcount at current level */
502 /* Get parent & match bus type */
503 parent
= of_get_parent(dev
);
506 bus
= of_match_bus(parent
);
508 /* Cound address cells & copy address locally */
509 bus
->count_cells(dev
, &na
, &ns
);
510 if (!OF_CHECK_COUNTS(na
, ns
)) {
511 printk(KERN_ERR
"prom_parse: Bad cell count for %s\n",
515 memcpy(addr
, in_addr
, na
* 4);
517 DBG("OF: bus is %s (na=%d, ns=%d) on %s\n",
518 bus
->name
, na
, ns
, parent
->full_name
);
519 of_dump_addr("OF: translating address:", addr
, na
);
523 /* Switch to parent bus */
526 parent
= of_get_parent(dev
);
528 /* If root, we have finished */
529 if (parent
== NULL
) {
530 DBG("OF: reached root node\n");
531 result
= of_read_number(addr
, na
);
535 /* Get new parent bus and counts */
536 pbus
= of_match_bus(parent
);
537 pbus
->count_cells(dev
, &pna
, &pns
);
538 if (!OF_CHECK_COUNTS(pna
, pns
)) {
539 printk(KERN_ERR
"prom_parse: Bad cell count for %s\n",
544 DBG("OF: parent bus is %s (na=%d, ns=%d) on %s\n",
545 pbus
->name
, pna
, pns
, parent
->full_name
);
547 /* Apply bus translation */
548 if (of_translate_one(dev
, bus
, pbus
, addr
, na
, ns
, pna
, rprop
))
551 /* Complete the move up one level */
556 of_dump_addr("OF: one level translation:", addr
, na
);
565 u64
of_translate_address(struct device_node
*dev
, const u32
*in_addr
)
567 return __of_translate_address(dev
, in_addr
, "ranges");
569 EXPORT_SYMBOL(of_translate_address
);
571 u64
of_translate_dma_address(struct device_node
*dev
, const u32
*in_addr
)
573 return __of_translate_address(dev
, in_addr
, "dma-ranges");
575 EXPORT_SYMBOL(of_translate_dma_address
);
577 const u32
*of_get_address(struct device_node
*dev
, int index
, u64
*size
,
582 struct device_node
*parent
;
584 int onesize
, i
, na
, ns
;
586 /* Get parent & match bus type */
587 parent
= of_get_parent(dev
);
590 bus
= of_match_bus(parent
);
591 bus
->count_cells(dev
, &na
, &ns
);
593 if (!OF_CHECK_COUNTS(na
, ns
))
596 /* Get "reg" or "assigned-addresses" property */
597 prop
= of_get_property(dev
, bus
->addresses
, &psize
);
603 for (i
= 0; psize
>= onesize
; psize
-= onesize
, prop
+= onesize
, i
++)
606 *size
= of_read_number(prop
+ na
, ns
);
608 *flags
= bus
->get_flags(prop
);
613 EXPORT_SYMBOL(of_get_address
);
615 static int __of_address_to_resource(struct device_node
*dev
, const u32
*addrp
,
616 u64 size
, unsigned int flags
,
621 if ((flags
& (IORESOURCE_IO
| IORESOURCE_MEM
)) == 0)
623 taddr
= of_translate_address(dev
, addrp
);
624 if (taddr
== OF_BAD_ADDR
)
626 memset(r
, 0, sizeof(struct resource
));
627 if (flags
& IORESOURCE_IO
) {
629 port
= pci_address_to_pio(taddr
);
630 if (port
== (unsigned long)-1)
633 r
->end
= port
+ size
- 1;
636 r
->end
= taddr
+ size
- 1;
643 int of_address_to_resource(struct device_node
*dev
, int index
,
650 addrp
= of_get_address(dev
, index
, &size
, &flags
);
653 return __of_address_to_resource(dev
, addrp
, size
, flags
, r
);
655 EXPORT_SYMBOL_GPL(of_address_to_resource
);
657 void of_parse_dma_window(struct device_node
*dn
, const void *dma_window_prop
,
658 unsigned long *busno
, unsigned long *phys
, unsigned long *size
)
660 const u32
*dma_window
;
662 const unsigned char *prop
;
664 dma_window
= dma_window_prop
;
666 /* busno is always one cell */
667 *busno
= *(dma_window
++);
669 prop
= of_get_property(dn
, "ibm,#dma-address-cells", NULL
);
671 prop
= of_get_property(dn
, "#address-cells", NULL
);
673 cells
= prop
? *(u32
*)prop
: of_n_addr_cells(dn
);
674 *phys
= of_read_number(dma_window
, cells
);
678 prop
= of_get_property(dn
, "ibm,#dma-size-cells", NULL
);
679 cells
= prop
? *(u32
*)prop
: of_n_size_cells(dn
);
680 *size
= of_read_number(dma_window
, cells
);
687 static unsigned int of_irq_workarounds
;
688 static struct device_node
*of_irq_dflt_pic
;
690 static struct device_node
*of_irq_find_parent(struct device_node
*child
)
692 struct device_node
*p
;
695 if (!of_node_get(child
))
699 parp
= of_get_property(child
, "interrupt-parent", NULL
);
701 p
= of_get_parent(child
);
703 if (of_irq_workarounds
& OF_IMAP_NO_PHANDLE
)
704 p
= of_node_get(of_irq_dflt_pic
);
706 p
= of_find_node_by_phandle(*parp
);
710 } while (p
&& of_get_property(p
, "#interrupt-cells", NULL
) == NULL
);
715 /* This doesn't need to be called if you don't have any special workaround
718 void of_irq_map_init(unsigned int flags
)
720 of_irq_workarounds
= flags
;
722 /* OldWorld, don't bother looking at other things */
723 if (flags
& OF_IMAP_OLDWORLD_MAC
)
726 /* If we don't have phandles, let's try to locate a default interrupt
727 * controller (happens when booting with BootX). We do a first match
728 * here, hopefully, that only ever happens on machines with one
731 if (flags
& OF_IMAP_NO_PHANDLE
) {
732 struct device_node
*np
;
734 for(np
= NULL
; (np
= of_find_all_nodes(np
)) != NULL
;) {
735 if (of_get_property(np
, "interrupt-controller", NULL
)
738 /* Skip /chosen/interrupt-controller */
739 if (strcmp(np
->name
, "chosen") == 0)
741 /* It seems like at least one person on this planet wants
742 * to use BootX on a machine with an AppleKiwi controller
743 * which happens to pretend to be an interrupt
746 if (strcmp(np
->name
, "AppleKiwi") == 0)
748 /* I think we found one ! */
749 of_irq_dflt_pic
= np
;
756 int of_irq_map_raw(struct device_node
*parent
, const u32
*intspec
, u32 ointsize
,
757 const u32
*addr
, struct of_irq
*out_irq
)
759 struct device_node
*ipar
, *tnode
, *old
= NULL
, *newpar
= NULL
;
760 const u32
*tmp
, *imap
, *imask
;
761 u32 intsize
= 1, addrsize
, newintsize
= 0, newaddrsize
= 0;
762 int imaplen
, match
, i
;
764 DBG("of_irq_map_raw: par=%s,intspec=[0x%08x 0x%08x...],ointsize=%d\n",
765 parent
->full_name
, intspec
[0], intspec
[1], ointsize
);
767 ipar
= of_node_get(parent
);
769 /* First get the #interrupt-cells property of the current cursor
770 * that tells us how to interpret the passed-in intspec. If there
771 * is none, we are nice and just walk up the tree
774 tmp
= of_get_property(ipar
, "#interrupt-cells", NULL
);
780 ipar
= of_irq_find_parent(ipar
);
784 DBG(" -> no parent found !\n");
788 DBG("of_irq_map_raw: ipar=%s, size=%d\n", ipar
->full_name
, intsize
);
790 if (ointsize
!= intsize
)
793 /* Look for this #address-cells. We have to implement the old linux
794 * trick of looking for the parent here as some device-trees rely on it
796 old
= of_node_get(ipar
);
798 tmp
= of_get_property(old
, "#address-cells", NULL
);
799 tnode
= of_get_parent(old
);
802 } while(old
&& tmp
== NULL
);
805 addrsize
= (tmp
== NULL
) ? 2 : *tmp
;
807 DBG(" -> addrsize=%d\n", addrsize
);
809 /* Now start the actual "proper" walk of the interrupt tree */
810 while (ipar
!= NULL
) {
811 /* Now check if cursor is an interrupt-controller and if it is
814 if (of_get_property(ipar
, "interrupt-controller", NULL
) !=
816 DBG(" -> got it !\n");
817 memcpy(out_irq
->specifier
, intspec
,
818 intsize
* sizeof(u32
));
819 out_irq
->size
= intsize
;
820 out_irq
->controller
= ipar
;
825 /* Now look for an interrupt-map */
826 imap
= of_get_property(ipar
, "interrupt-map", &imaplen
);
827 /* No interrupt map, check for an interrupt parent */
829 DBG(" -> no map, getting parent\n");
830 newpar
= of_irq_find_parent(ipar
);
833 imaplen
/= sizeof(u32
);
835 /* Look for a mask */
836 imask
= of_get_property(ipar
, "interrupt-map-mask", NULL
);
838 /* If we were passed no "reg" property and we attempt to parse
839 * an interrupt-map, then #address-cells must be 0.
842 if (addr
== NULL
&& addrsize
!= 0) {
843 DBG(" -> no reg passed in when needed !\n");
847 /* Parse interrupt-map */
849 while (imaplen
> (addrsize
+ intsize
+ 1) && !match
) {
850 /* Compare specifiers */
852 for (i
= 0; i
< addrsize
&& match
; ++i
) {
853 u32 mask
= imask
? imask
[i
] : 0xffffffffu
;
854 match
= ((addr
[i
] ^ imap
[i
]) & mask
) == 0;
856 for (; i
< (addrsize
+ intsize
) && match
; ++i
) {
857 u32 mask
= imask
? imask
[i
] : 0xffffffffu
;
859 ((intspec
[i
-addrsize
] ^ imap
[i
]) & mask
) == 0;
861 imap
+= addrsize
+ intsize
;
862 imaplen
-= addrsize
+ intsize
;
864 DBG(" -> match=%d (imaplen=%d)\n", match
, imaplen
);
866 /* Get the interrupt parent */
867 if (of_irq_workarounds
& OF_IMAP_NO_PHANDLE
)
868 newpar
= of_node_get(of_irq_dflt_pic
);
870 newpar
= of_find_node_by_phandle((phandle
)*imap
);
874 /* Check if not found */
875 if (newpar
== NULL
) {
876 DBG(" -> imap parent not found !\n");
880 /* Get #interrupt-cells and #address-cells of new
883 tmp
= of_get_property(newpar
, "#interrupt-cells", NULL
);
885 DBG(" -> parent lacks #interrupt-cells !\n");
889 tmp
= of_get_property(newpar
, "#address-cells", NULL
);
890 newaddrsize
= (tmp
== NULL
) ? 0 : *tmp
;
892 DBG(" -> newintsize=%d, newaddrsize=%d\n",
893 newintsize
, newaddrsize
);
895 /* Check for malformed properties */
896 if (imaplen
< (newaddrsize
+ newintsize
))
899 imap
+= newaddrsize
+ newintsize
;
900 imaplen
-= newaddrsize
+ newintsize
;
902 DBG(" -> imaplen=%d\n", imaplen
);
908 old
= of_node_get(newpar
);
909 addrsize
= newaddrsize
;
910 intsize
= newintsize
;
911 intspec
= imap
- intsize
;
912 addr
= intspec
- addrsize
;
915 /* Iterate again with new parent */
916 DBG(" -> new parent: %s\n", newpar
? newpar
->full_name
: "<>");
928 EXPORT_SYMBOL_GPL(of_irq_map_raw
);
930 #if defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32)
931 static int of_irq_map_oldworld(struct device_node
*device
, int index
,
932 struct of_irq
*out_irq
)
934 const u32
*ints
= NULL
;
938 * Old machines just have a list of interrupt numbers
939 * and no interrupt-controller nodes. We also have dodgy
940 * cases where the APPL,interrupts property is completely
941 * missing behind pci-pci bridges and we have to get it
942 * from the parent (the bridge itself, as apple just wired
943 * everything together on these)
946 ints
= of_get_property(device
, "AAPL,interrupts", &intlen
);
949 device
= device
->parent
;
950 if (device
&& strcmp(device
->type
, "pci") != 0)
955 intlen
/= sizeof(u32
);
960 out_irq
->controller
= NULL
;
961 out_irq
->specifier
[0] = ints
[index
];
966 #else /* defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32) */
967 static int of_irq_map_oldworld(struct device_node
*device
, int index
,
968 struct of_irq
*out_irq
)
972 #endif /* !(defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32)) */
974 int of_irq_map_one(struct device_node
*device
, int index
, struct of_irq
*out_irq
)
976 struct device_node
*p
;
977 const u32
*intspec
, *tmp
, *addr
;
981 DBG("of_irq_map_one: dev=%s, index=%d\n", device
->full_name
, index
);
983 /* OldWorld mac stuff is "special", handle out of line */
984 if (of_irq_workarounds
& OF_IMAP_OLDWORLD_MAC
)
985 return of_irq_map_oldworld(device
, index
, out_irq
);
987 /* Get the interrupts property */
988 intspec
= of_get_property(device
, "interrupts", &intlen
);
991 intlen
/= sizeof(u32
);
993 /* Get the reg property (if any) */
994 addr
= of_get_property(device
, "reg", NULL
);
996 /* Look for the interrupt parent. */
997 p
= of_irq_find_parent(device
);
1001 /* Get size of interrupt specifier */
1002 tmp
= of_get_property(p
, "#interrupt-cells", NULL
);
1009 DBG(" intsize=%d intlen=%d\n", intsize
, intlen
);
1012 if ((index
+ 1) * intsize
> intlen
)
1015 /* Get new specifier and map it */
1016 res
= of_irq_map_raw(p
, intspec
+ index
* intsize
, intsize
,
1021 EXPORT_SYMBOL_GPL(of_irq_map_one
);
1024 * Search the device tree for the best MAC address to use. 'mac-address' is
1025 * checked first, because that is supposed to contain to "most recent" MAC
1026 * address. If that isn't set, then 'local-mac-address' is checked next,
1027 * because that is the default address. If that isn't set, then the obsolete
1028 * 'address' is checked, just in case we're using an old device tree.
1030 * Note that the 'address' property is supposed to contain a virtual address of
1031 * the register set, but some DTS files have redefined that property to be the
1034 * All-zero MAC addresses are rejected, because those could be properties that
1035 * exist in the device tree, but were not set by U-Boot. For example, the
1036 * DTS could define 'mac-address' and 'local-mac-address', with zero MAC
1037 * addresses. Some older U-Boots only initialized 'local-mac-address'. In
1038 * this case, the real MAC is in 'local-mac-address', and 'mac-address' exists
1041 const void *of_get_mac_address(struct device_node
*np
)
1043 struct property
*pp
;
1045 pp
= of_find_property(np
, "mac-address", NULL
);
1046 if (pp
&& (pp
->length
== 6) && is_valid_ether_addr(pp
->value
))
1049 pp
= of_find_property(np
, "local-mac-address", NULL
);
1050 if (pp
&& (pp
->length
== 6) && is_valid_ether_addr(pp
->value
))
1053 pp
= of_find_property(np
, "address", NULL
);
1054 if (pp
&& (pp
->length
== 6) && is_valid_ether_addr(pp
->value
))
1059 EXPORT_SYMBOL(of_get_mac_address
);
1061 int of_irq_to_resource(struct device_node
*dev
, int index
, struct resource
*r
)
1063 int irq
= irq_of_parse_and_map(dev
, index
);
1065 /* Only dereference the resource if both the
1066 * resource and the irq are valid. */
1067 if (r
&& irq
!= NO_IRQ
) {
1068 r
->start
= r
->end
= irq
;
1069 r
->flags
= IORESOURCE_IRQ
;
1074 EXPORT_SYMBOL_GPL(of_irq_to_resource
);
1076 void __iomem
*of_iomap(struct device_node
*np
, int index
)
1078 struct resource res
;
1080 if (of_address_to_resource(np
, index
, &res
))
1083 return ioremap(res
.start
, 1 + res
.end
- res
.start
);
1085 EXPORT_SYMBOL(of_iomap
);