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
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
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
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
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
114
115
116static int of_bus_pci_match(struct device_node *np)
117{
118
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
136 if ((addr[0] ^ range[0]) & 0x03000000)
137 return OF_BAD_ADDR;
138
139
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:
166 case 0x03:
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
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
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
246
247
248 dn = pci_device_to_OF_node(pdev);
249 if (dn)
250 return of_irq_map_one(dn, 0, out_irq);
251
252
253
254
255
256 rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
257 if (rc != 0)
258 return rc;
259
260 if (pin == 0)
261 return -ENODEV;
262
263
264 lspec = pin;
265 for (;;) {
266
267 ppdev = pdev->bus->self;
268
269
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
279 if (ppnode == NULL)
280 return -EINVAL;
281 } else
282
283 ppnode = pci_device_to_OF_node(ppdev);
284
285
286
287
288
289
290
291
292
293
294
295
296 if (ppnode)
297 break;
298
299
300
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
313
314
315
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
337 if ((addr[0] ^ range[0]) & 0x00000001)
338 return OF_BAD_ADDR;
339
340
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
372
373
374static struct of_bus of_busses[] = {
375#ifdef CONFIG_PCI
376
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
387
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
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
430
431
432
433
434
435
436
437
438
439
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
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
470 return pbus->translate(addr, offset, pna);
471}
472
473
474
475
476
477
478
479
480
481
482
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
495 of_node_get(dev);
496
497
498 parent = of_get_parent(dev);
499 if (parent == NULL)
500 goto bail;
501 bus = of_match_bus(parent);
502
503
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
517 for (;;) {
518
519 of_node_put(dev);
520 dev = parent;
521 parent = of_get_parent(dev);
522
523
524 if (parent == NULL) {
525 DBG("OF: reached root node\n");
526 result = of_read_number(addr, na);
527 break;
528 }
529
530
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
543 if (of_translate_one(dev, bus, pbus, addr, na, ns, pna))
544 break;
545
546
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
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
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
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
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
699
700
701
702void of_irq_map_init(unsigned int flags)
703{
704 of_irq_workarounds = flags;
705
706
707 if (flags & OF_IMAP_OLDWORLD_MAC)
708 return;
709
710
711
712
713
714
715 if (flags & OF_IMAP_NO_PHANDLE) {
716 struct device_node *np;
717
718 for(np = NULL; (np = of_find_all_nodes(np)) != NULL;) {
719 if (of_get_property(np, "interrupt-controller", NULL)
720 == NULL)
721 continue;
722
723 if (strcmp(np->name, "chosen") == 0)
724 continue;
725
726
727
728
729
730 if (strcmp(np->name, "AppleKiwi") == 0)
731 continue;
732
733 of_irq_dflt_pic = np;
734 break;
735 }
736 }
737
738}
739
740int of_irq_map_raw(struct device_node *parent, const u32 *intspec, u32 ointsize,
741 const u32 *addr, struct of_irq *out_irq)
742{
743 struct device_node *ipar, *tnode, *old = NULL, *newpar = NULL;
744 const u32 *tmp, *imap, *imask;
745 u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0;
746 int imaplen, match, i;
747
748 DBG("of_irq_map_raw: par=%s,intspec=[0x%08x 0x%08x...],ointsize=%d\n",
749 parent->full_name, intspec[0], intspec[1], ointsize);
750
751 ipar = of_node_get(parent);
752
753
754
755
756
757 do {
758 tmp = of_get_property(ipar, "#interrupt-cells", NULL);
759 if (tmp != NULL) {
760 intsize = *tmp;
761 break;
762 }
763 tnode = ipar;
764 ipar = of_irq_find_parent(ipar);
765 of_node_put(tnode);
766 } while (ipar);
767 if (ipar == NULL) {
768 DBG(" -> no parent found !\n");
769 goto fail;
770 }
771
772 DBG("of_irq_map_raw: ipar=%s, size=%d\n", ipar->full_name, intsize);
773
774 if (ointsize != intsize)
775 return -EINVAL;
776
777
778
779
780 old = of_node_get(ipar);
781 do {
782 tmp = of_get_property(old, "#address-cells", NULL);
783 tnode = of_get_parent(old);
784 of_node_put(old);
785 old = tnode;
786 } while(old && tmp == NULL);
787 of_node_put(old);
788 old = NULL;
789 addrsize = (tmp == NULL) ? 2 : *tmp;
790
791 DBG(" -> addrsize=%d\n", addrsize);
792
793
794 while (ipar != NULL) {
795
796
797
798 if (of_get_property(ipar, "interrupt-controller", NULL) !=
799 NULL) {
800 DBG(" -> got it !\n");
801 memcpy(out_irq->specifier, intspec,
802 intsize * sizeof(u32));
803 out_irq->size = intsize;
804 out_irq->controller = ipar;
805 of_node_put(old);
806 return 0;
807 }
808
809
810 imap = of_get_property(ipar, "interrupt-map", &imaplen);
811
812 if (imap == NULL) {
813 DBG(" -> no map, getting parent\n");
814 newpar = of_irq_find_parent(ipar);
815 goto skiplevel;
816 }
817 imaplen /= sizeof(u32);
818
819
820 imask = of_get_property(ipar, "interrupt-map-mask", NULL);
821
822
823
824
825
826 if (addr == NULL && addrsize != 0) {
827 DBG(" -> no reg passed in when needed !\n");
828 goto fail;
829 }
830
831
832 match = 0;
833 while (imaplen > (addrsize + intsize + 1) && !match) {
834
835 match = 1;
836 for (i = 0; i < addrsize && match; ++i) {
837 u32 mask = imask ? imask[i] : 0xffffffffu;
838 match = ((addr[i] ^ imap[i]) & mask) == 0;
839 }
840 for (; i < (addrsize + intsize) && match; ++i) {
841 u32 mask = imask ? imask[i] : 0xffffffffu;
842 match =
843 ((intspec[i-addrsize] ^ imap[i]) & mask) == 0;
844 }
845 imap += addrsize + intsize;
846 imaplen -= addrsize + intsize;
847
848 DBG(" -> match=%d (imaplen=%d)\n", match, imaplen);
849
850
851 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE)
852 newpar = of_node_get(of_irq_dflt_pic);
853 else
854 newpar = of_find_node_by_phandle((phandle)*imap);
855 imap++;
856 --imaplen;
857
858
859 if (newpar == NULL) {
860 DBG(" -> imap parent not found !\n");
861 goto fail;
862 }
863
864
865
866
867 tmp = of_get_property(newpar, "#interrupt-cells", NULL);
868 if (tmp == NULL) {
869 DBG(" -> parent lacks #interrupt-cells !\n");
870 goto fail;
871 }
872 newintsize = *tmp;
873 tmp = of_get_property(newpar, "#address-cells", NULL);
874 newaddrsize = (tmp == NULL) ? 0 : *tmp;
875
876 DBG(" -> newintsize=%d, newaddrsize=%d\n",
877 newintsize, newaddrsize);
878
879
880 if (imaplen < (newaddrsize + newintsize))
881 goto fail;
882
883 imap += newaddrsize + newintsize;
884 imaplen -= newaddrsize + newintsize;
885
886 DBG(" -> imaplen=%d\n", imaplen);
887 }
888 if (!match)
889 goto fail;
890
891 of_node_put(old);
892 old = of_node_get(newpar);
893 addrsize = newaddrsize;
894 intsize = newintsize;
895 intspec = imap - intsize;
896 addr = intspec - addrsize;
897
898 skiplevel:
899
900 DBG(" -> new parent: %s\n", newpar ? newpar->full_name : "<>");
901 of_node_put(ipar);
902 ipar = newpar;
903 newpar = NULL;
904 }
905 fail:
906 of_node_put(ipar);
907 of_node_put(old);
908 of_node_put(newpar);
909
910 return -EINVAL;
911}
912EXPORT_SYMBOL_GPL(of_irq_map_raw);
913
914#if defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32)
915static int of_irq_map_oldworld(struct device_node *device, int index,
916 struct of_irq *out_irq)
917{
918 const u32 *ints = NULL;
919 int intlen;
920
921
922
923
924
925
926
927
928
929 while (device) {
930 ints = of_get_property(device, "AAPL,interrupts", &intlen);
931 if (ints != NULL)
932 break;
933 device = device->parent;
934 if (device && strcmp(device->type, "pci") != 0)
935 break;
936 }
937 if (ints == NULL)
938 return -EINVAL;
939 intlen /= sizeof(u32);
940
941 if (index >= intlen)
942 return -EINVAL;
943
944 out_irq->controller = NULL;
945 out_irq->specifier[0] = ints[index];
946 out_irq->size = 1;
947
948 return 0;
949}
950#else
951static int of_irq_map_oldworld(struct device_node *device, int index,
952 struct of_irq *out_irq)
953{
954 return -EINVAL;
955}
956#endif
957
958int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq)
959{
960 struct device_node *p;
961 const u32 *intspec, *tmp, *addr;
962 u32 intsize, intlen;
963 int res;
964
965 DBG("of_irq_map_one: dev=%s, index=%d\n", device->full_name, index);
966
967
968 if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
969 return of_irq_map_oldworld(device, index, out_irq);
970
971
972 intspec = of_get_property(device, "interrupts", &intlen);
973 if (intspec == NULL)
974 return -EINVAL;
975 intlen /= sizeof(u32);
976
977
978 addr = of_get_property(device, "reg", NULL);
979
980
981 p = of_irq_find_parent(device);
982 if (p == NULL)
983 return -EINVAL;
984
985
986 tmp = of_get_property(p, "#interrupt-cells", NULL);
987 if (tmp == NULL) {
988 of_node_put(p);
989 return -EINVAL;
990 }
991 intsize = *tmp;
992
993 DBG(" intsize=%d intlen=%d\n", intsize, intlen);
994
995
996 if ((index + 1) * intsize > intlen)
997 return -EINVAL;
998
999
1000 res = of_irq_map_raw(p, intspec + index * intsize, intsize,
1001 addr, out_irq);
1002 of_node_put(p);
1003 return res;
1004}
1005EXPORT_SYMBOL_GPL(of_irq_map_one);
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025const void *of_get_mac_address(struct device_node *np)
1026{
1027 struct property *pp;
1028
1029 pp = of_find_property(np, "mac-address", NULL);
1030 if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value))
1031 return pp->value;
1032
1033 pp = of_find_property(np, "local-mac-address", NULL);
1034 if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value))
1035 return pp->value;
1036
1037 pp = of_find_property(np, "address", NULL);
1038 if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value))
1039 return pp->value;
1040
1041 return NULL;
1042}
1043EXPORT_SYMBOL(of_get_mac_address);
1044
1045int of_irq_to_resource(struct device_node *dev, int index, struct resource *r)
1046{
1047 int irq = irq_of_parse_and_map(dev, index);
1048
1049
1050
1051 if (r && irq != NO_IRQ) {
1052 r->start = r->end = irq;
1053 r->flags = IORESOURCE_IRQ;
1054 }
1055
1056 return irq;
1057}
1058EXPORT_SYMBOL_GPL(of_irq_to_resource);
1059
1060void __iomem *of_iomap(struct device_node *np, int index)
1061{
1062 struct resource res;
1063
1064 if (of_address_to_resource(np, index, &res))
1065 return NULL;
1066
1067 return ioremap(res.start, 1 + res.end - res.start);
1068}
1069EXPORT_SYMBOL(of_iomap);
1070