sparc: make proces_ver_nack a bit more readable
[linux-2.6] / arch / sparc / kernel / of_device_64.c
1 #include <linux/string.h>
2 #include <linux/kernel.h>
3 #include <linux/of.h>
4 #include <linux/init.h>
5 #include <linux/module.h>
6 #include <linux/mod_devicetable.h>
7 #include <linux/slab.h>
8 #include <linux/errno.h>
9 #include <linux/irq.h>
10 #include <linux/of_device.h>
11 #include <linux/of_platform.h>
12
13 void __iomem *of_ioremap(struct resource *res, unsigned long offset, unsigned long size, char *name)
14 {
15         unsigned long ret = res->start + offset;
16         struct resource *r;
17
18         if (res->flags & IORESOURCE_MEM)
19                 r = request_mem_region(ret, size, name);
20         else
21                 r = request_region(ret, size, name);
22         if (!r)
23                 ret = 0;
24
25         return (void __iomem *) ret;
26 }
27 EXPORT_SYMBOL(of_ioremap);
28
29 void of_iounmap(struct resource *res, void __iomem *base, unsigned long size)
30 {
31         if (res->flags & IORESOURCE_MEM)
32                 release_mem_region((unsigned long) base, size);
33         else
34                 release_region((unsigned long) base, size);
35 }
36 EXPORT_SYMBOL(of_iounmap);
37
38 static int node_match(struct device *dev, void *data)
39 {
40         struct of_device *op = to_of_device(dev);
41         struct device_node *dp = data;
42
43         return (op->node == dp);
44 }
45
46 struct of_device *of_find_device_by_node(struct device_node *dp)
47 {
48         struct device *dev = bus_find_device(&of_platform_bus_type, NULL,
49                                              dp, node_match);
50
51         if (dev)
52                 return to_of_device(dev);
53
54         return NULL;
55 }
56 EXPORT_SYMBOL(of_find_device_by_node);
57
58 unsigned int irq_of_parse_and_map(struct device_node *node, int index)
59 {
60         struct of_device *op = of_find_device_by_node(node);
61
62         if (!op || index >= op->num_irqs)
63                 return 0;
64
65         return op->irqs[index];
66 }
67 EXPORT_SYMBOL(irq_of_parse_and_map);
68
69 /* Take the archdata values for IOMMU, STC, and HOSTDATA found in
70  * BUS and propagate to all child of_device objects.
71  */
72 void of_propagate_archdata(struct of_device *bus)
73 {
74         struct dev_archdata *bus_sd = &bus->dev.archdata;
75         struct device_node *bus_dp = bus->node;
76         struct device_node *dp;
77
78         for (dp = bus_dp->child; dp; dp = dp->sibling) {
79                 struct of_device *op = of_find_device_by_node(dp);
80
81                 op->dev.archdata.iommu = bus_sd->iommu;
82                 op->dev.archdata.stc = bus_sd->stc;
83                 op->dev.archdata.host_controller = bus_sd->host_controller;
84                 op->dev.archdata.numa_node = bus_sd->numa_node;
85
86                 if (dp->child)
87                         of_propagate_archdata(op);
88         }
89 }
90
91 struct bus_type of_platform_bus_type;
92 EXPORT_SYMBOL(of_platform_bus_type);
93
94 static inline u64 of_read_addr(const u32 *cell, int size)
95 {
96         u64 r = 0;
97         while (size--)
98                 r = (r << 32) | *(cell++);
99         return r;
100 }
101
102 static void __init get_cells(struct device_node *dp,
103                              int *addrc, int *sizec)
104 {
105         if (addrc)
106                 *addrc = of_n_addr_cells(dp);
107         if (sizec)
108                 *sizec = of_n_size_cells(dp);
109 }
110
111 /* Max address size we deal with */
112 #define OF_MAX_ADDR_CELLS       4
113
114 struct of_bus {
115         const char      *name;
116         const char      *addr_prop_name;
117         int             (*match)(struct device_node *parent);
118         void            (*count_cells)(struct device_node *child,
119                                        int *addrc, int *sizec);
120         int             (*map)(u32 *addr, const u32 *range,
121                                int na, int ns, int pna);
122         unsigned long   (*get_flags)(const u32 *addr, unsigned long);
123 };
124
125 /*
126  * Default translator (generic bus)
127  */
128
129 static void of_bus_default_count_cells(struct device_node *dev,
130                                        int *addrc, int *sizec)
131 {
132         get_cells(dev, addrc, sizec);
133 }
134
135 /* Make sure the least significant 64-bits are in-range.  Even
136  * for 3 or 4 cell values it is a good enough approximation.
137  */
138 static int of_out_of_range(const u32 *addr, const u32 *base,
139                            const u32 *size, int na, int ns)
140 {
141         u64 a = of_read_addr(addr, na);
142         u64 b = of_read_addr(base, na);
143
144         if (a < b)
145                 return 1;
146
147         b += of_read_addr(size, ns);
148         if (a >= b)
149                 return 1;
150
151         return 0;
152 }
153
154 static int of_bus_default_map(u32 *addr, const u32 *range,
155                               int na, int ns, int pna)
156 {
157         u32 result[OF_MAX_ADDR_CELLS];
158         int i;
159
160         if (ns > 2) {
161                 printk("of_device: Cannot handle size cells (%d) > 2.", ns);
162                 return -EINVAL;
163         }
164
165         if (of_out_of_range(addr, range, range + na + pna, na, ns))
166                 return -EINVAL;
167
168         /* Start with the parent range base.  */
169         memcpy(result, range + na, pna * 4);
170
171         /* Add in the child address offset.  */
172         for (i = 0; i < na; i++)
173                 result[pna - 1 - i] +=
174                         (addr[na - 1 - i] -
175                          range[na - 1 - i]);
176
177         memcpy(addr, result, pna * 4);
178
179         return 0;
180 }
181
182 static unsigned long of_bus_default_get_flags(const u32 *addr, unsigned long flags)
183 {
184         if (flags)
185                 return flags;
186         return IORESOURCE_MEM;
187 }
188
189 /*
190  * PCI bus specific translator
191  */
192
193 static int of_bus_pci_match(struct device_node *np)
194 {
195         if (!strcmp(np->name, "pci")) {
196                 const char *model = of_get_property(np, "model", NULL);
197
198                 if (model && !strcmp(model, "SUNW,simba"))
199                         return 0;
200
201                 /* Do not do PCI specific frobbing if the
202                  * PCI bridge lacks a ranges property.  We
203                  * want to pass it through up to the next
204                  * parent as-is, not with the PCI translate
205                  * method which chops off the top address cell.
206                  */
207                 if (!of_find_property(np, "ranges", NULL))
208                         return 0;
209
210                 return 1;
211         }
212
213         return 0;
214 }
215
216 static int of_bus_simba_match(struct device_node *np)
217 {
218         const char *model = of_get_property(np, "model", NULL);
219
220         if (model && !strcmp(model, "SUNW,simba"))
221                 return 1;
222
223         /* Treat PCI busses lacking ranges property just like
224          * simba.
225          */
226         if (!strcmp(np->name, "pci")) {
227                 if (!of_find_property(np, "ranges", NULL))
228                         return 1;
229         }
230
231         return 0;
232 }
233
234 static int of_bus_simba_map(u32 *addr, const u32 *range,
235                             int na, int ns, int pna)
236 {
237         return 0;
238 }
239
240 static void of_bus_pci_count_cells(struct device_node *np,
241                                    int *addrc, int *sizec)
242 {
243         if (addrc)
244                 *addrc = 3;
245         if (sizec)
246                 *sizec = 2;
247 }
248
249 static int of_bus_pci_map(u32 *addr, const u32 *range,
250                           int na, int ns, int pna)
251 {
252         u32 result[OF_MAX_ADDR_CELLS];
253         int i;
254
255         /* Check address type match */
256         if ((addr[0] ^ range[0]) & 0x03000000)
257                 return -EINVAL;
258
259         if (of_out_of_range(addr + 1, range + 1, range + na + pna,
260                             na - 1, ns))
261                 return -EINVAL;
262
263         /* Start with the parent range base.  */
264         memcpy(result, range + na, pna * 4);
265
266         /* Add in the child address offset, skipping high cell.  */
267         for (i = 0; i < na - 1; i++)
268                 result[pna - 1 - i] +=
269                         (addr[na - 1 - i] -
270                          range[na - 1 - i]);
271
272         memcpy(addr, result, pna * 4);
273
274         return 0;
275 }
276
277 static unsigned long of_bus_pci_get_flags(const u32 *addr, unsigned long flags)
278 {
279         u32 w = addr[0];
280
281         /* For PCI, we override whatever child busses may have used.  */
282         flags = 0;
283         switch((w >> 24) & 0x03) {
284         case 0x01:
285                 flags |= IORESOURCE_IO;
286                 break;
287
288         case 0x02: /* 32 bits */
289         case 0x03: /* 64 bits */
290                 flags |= IORESOURCE_MEM;
291                 break;
292         }
293         if (w & 0x40000000)
294                 flags |= IORESOURCE_PREFETCH;
295         return flags;
296 }
297
298 /*
299  * SBUS bus specific translator
300  */
301
302 static int of_bus_sbus_match(struct device_node *np)
303 {
304         return !strcmp(np->name, "sbus") ||
305                 !strcmp(np->name, "sbi");
306 }
307
308 static void of_bus_sbus_count_cells(struct device_node *child,
309                                    int *addrc, int *sizec)
310 {
311         if (addrc)
312                 *addrc = 2;
313         if (sizec)
314                 *sizec = 1;
315 }
316
317 /*
318  * FHC/Central bus specific translator.
319  *
320  * This is just needed to hard-code the address and size cell
321  * counts.  'fhc' and 'central' nodes lack the #address-cells and
322  * #size-cells properties, and if you walk to the root on such
323  * Enterprise boxes all you'll get is a #size-cells of 2 which is
324  * not what we want to use.
325  */
326 static int of_bus_fhc_match(struct device_node *np)
327 {
328         return !strcmp(np->name, "fhc") ||
329                 !strcmp(np->name, "central");
330 }
331
332 #define of_bus_fhc_count_cells of_bus_sbus_count_cells
333
334 /*
335  * Array of bus specific translators
336  */
337
338 static struct of_bus of_busses[] = {
339         /* PCI */
340         {
341                 .name = "pci",
342                 .addr_prop_name = "assigned-addresses",
343                 .match = of_bus_pci_match,
344                 .count_cells = of_bus_pci_count_cells,
345                 .map = of_bus_pci_map,
346                 .get_flags = of_bus_pci_get_flags,
347         },
348         /* SIMBA */
349         {
350                 .name = "simba",
351                 .addr_prop_name = "assigned-addresses",
352                 .match = of_bus_simba_match,
353                 .count_cells = of_bus_pci_count_cells,
354                 .map = of_bus_simba_map,
355                 .get_flags = of_bus_pci_get_flags,
356         },
357         /* SBUS */
358         {
359                 .name = "sbus",
360                 .addr_prop_name = "reg",
361                 .match = of_bus_sbus_match,
362                 .count_cells = of_bus_sbus_count_cells,
363                 .map = of_bus_default_map,
364                 .get_flags = of_bus_default_get_flags,
365         },
366         /* FHC */
367         {
368                 .name = "fhc",
369                 .addr_prop_name = "reg",
370                 .match = of_bus_fhc_match,
371                 .count_cells = of_bus_fhc_count_cells,
372                 .map = of_bus_default_map,
373                 .get_flags = of_bus_default_get_flags,
374         },
375         /* Default */
376         {
377                 .name = "default",
378                 .addr_prop_name = "reg",
379                 .match = NULL,
380                 .count_cells = of_bus_default_count_cells,
381                 .map = of_bus_default_map,
382                 .get_flags = of_bus_default_get_flags,
383         },
384 };
385
386 static struct of_bus *of_match_bus(struct device_node *np)
387 {
388         int i;
389
390         for (i = 0; i < ARRAY_SIZE(of_busses); i ++)
391                 if (!of_busses[i].match || of_busses[i].match(np))
392                         return &of_busses[i];
393         BUG();
394         return NULL;
395 }
396
397 static int __init build_one_resource(struct device_node *parent,
398                                      struct of_bus *bus,
399                                      struct of_bus *pbus,
400                                      u32 *addr,
401                                      int na, int ns, int pna)
402 {
403         const u32 *ranges;
404         int rone, rlen;
405
406         ranges = of_get_property(parent, "ranges", &rlen);
407         if (ranges == NULL || rlen == 0) {
408                 u32 result[OF_MAX_ADDR_CELLS];
409                 int i;
410
411                 memset(result, 0, pna * 4);
412                 for (i = 0; i < na; i++)
413                         result[pna - 1 - i] =
414                                 addr[na - 1 - i];
415
416                 memcpy(addr, result, pna * 4);
417                 return 0;
418         }
419
420         /* Now walk through the ranges */
421         rlen /= 4;
422         rone = na + pna + ns;
423         for (; rlen >= rone; rlen -= rone, ranges += rone) {
424                 if (!bus->map(addr, ranges, na, ns, pna))
425                         return 0;
426         }
427
428         /* When we miss an I/O space match on PCI, just pass it up
429          * to the next PCI bridge and/or controller.
430          */
431         if (!strcmp(bus->name, "pci") &&
432             (addr[0] & 0x03000000) == 0x01000000)
433                 return 0;
434
435         return 1;
436 }
437
438 static int __init use_1to1_mapping(struct device_node *pp)
439 {
440         /* If we have a ranges property in the parent, use it.  */
441         if (of_find_property(pp, "ranges", NULL) != NULL)
442                 return 0;
443
444         /* If the parent is the dma node of an ISA bus, pass
445          * the translation up to the root.
446          *
447          * Some SBUS devices use intermediate nodes to express
448          * hierarchy within the device itself.  These aren't
449          * real bus nodes, and don't have a 'ranges' property.
450          * But, we should still pass the translation work up
451          * to the SBUS itself.
452          */
453         if (!strcmp(pp->name, "dma") ||
454             !strcmp(pp->name, "espdma") ||
455             !strcmp(pp->name, "ledma") ||
456             !strcmp(pp->name, "lebuffer"))
457                 return 0;
458
459         /* Similarly for all PCI bridges, if we get this far
460          * it lacks a ranges property, and this will include
461          * cases like Simba.
462          */
463         if (!strcmp(pp->name, "pci"))
464                 return 0;
465
466         return 1;
467 }
468
469 static int of_resource_verbose;
470
471 static void __init build_device_resources(struct of_device *op,
472                                           struct device *parent)
473 {
474         struct of_device *p_op;
475         struct of_bus *bus;
476         int na, ns;
477         int index, num_reg;
478         const void *preg;
479
480         if (!parent)
481                 return;
482
483         p_op = to_of_device(parent);
484         bus = of_match_bus(p_op->node);
485         bus->count_cells(op->node, &na, &ns);
486
487         preg = of_get_property(op->node, bus->addr_prop_name, &num_reg);
488         if (!preg || num_reg == 0)
489                 return;
490
491         /* Convert to num-cells.  */
492         num_reg /= 4;
493
494         /* Convert to num-entries.  */
495         num_reg /= na + ns;
496
497         /* Prevent overrunning the op->resources[] array.  */
498         if (num_reg > PROMREG_MAX) {
499                 printk(KERN_WARNING "%s: Too many regs (%d), "
500                        "limiting to %d.\n",
501                        op->node->full_name, num_reg, PROMREG_MAX);
502                 num_reg = PROMREG_MAX;
503         }
504
505         for (index = 0; index < num_reg; index++) {
506                 struct resource *r = &op->resource[index];
507                 u32 addr[OF_MAX_ADDR_CELLS];
508                 const u32 *reg = (preg + (index * ((na + ns) * 4)));
509                 struct device_node *dp = op->node;
510                 struct device_node *pp = p_op->node;
511                 struct of_bus *pbus, *dbus;
512                 u64 size, result = OF_BAD_ADDR;
513                 unsigned long flags;
514                 int dna, dns;
515                 int pna, pns;
516
517                 size = of_read_addr(reg + na, ns);
518                 memcpy(addr, reg, na * 4);
519
520                 flags = bus->get_flags(addr, 0);
521
522                 if (use_1to1_mapping(pp)) {
523                         result = of_read_addr(addr, na);
524                         goto build_res;
525                 }
526
527                 dna = na;
528                 dns = ns;
529                 dbus = bus;
530
531                 while (1) {
532                         dp = pp;
533                         pp = dp->parent;
534                         if (!pp) {
535                                 result = of_read_addr(addr, dna);
536                                 break;
537                         }
538
539                         pbus = of_match_bus(pp);
540                         pbus->count_cells(dp, &pna, &pns);
541
542                         if (build_one_resource(dp, dbus, pbus, addr,
543                                                dna, dns, pna))
544                                 break;
545
546                         flags = pbus->get_flags(addr, flags);
547
548                         dna = pna;
549                         dns = pns;
550                         dbus = pbus;
551                 }
552
553         build_res:
554                 memset(r, 0, sizeof(*r));
555
556                 if (of_resource_verbose)
557                         printk("%s reg[%d] -> %lx\n",
558                                op->node->full_name, index,
559                                result);
560
561                 if (result != OF_BAD_ADDR) {
562                         if (tlb_type == hypervisor)
563                                 result &= 0x0fffffffffffffffUL;
564
565                         r->start = result;
566                         r->end = result + size - 1;
567                         r->flags = flags;
568                 }
569                 r->name = op->node->name;
570         }
571 }
572
573 static struct device_node * __init
574 apply_interrupt_map(struct device_node *dp, struct device_node *pp,
575                     const u32 *imap, int imlen, const u32 *imask,
576                     unsigned int *irq_p)
577 {
578         struct device_node *cp;
579         unsigned int irq = *irq_p;
580         struct of_bus *bus;
581         phandle handle;
582         const u32 *reg;
583         int na, num_reg, i;
584
585         bus = of_match_bus(pp);
586         bus->count_cells(dp, &na, NULL);
587
588         reg = of_get_property(dp, "reg", &num_reg);
589         if (!reg || !num_reg)
590                 return NULL;
591
592         imlen /= ((na + 3) * 4);
593         handle = 0;
594         for (i = 0; i < imlen; i++) {
595                 int j;
596
597                 for (j = 0; j < na; j++) {
598                         if ((reg[j] & imask[j]) != imap[j])
599                                 goto next;
600                 }
601                 if (imap[na] == irq) {
602                         handle = imap[na + 1];
603                         irq = imap[na + 2];
604                         break;
605                 }
606
607         next:
608                 imap += (na + 3);
609         }
610         if (i == imlen) {
611                 /* Psycho and Sabre PCI controllers can have 'interrupt-map'
612                  * properties that do not include the on-board device
613                  * interrupts.  Instead, the device's 'interrupts' property
614                  * is already a fully specified INO value.
615                  *
616                  * Handle this by deciding that, if we didn't get a
617                  * match in the parent's 'interrupt-map', and the
618                  * parent is an IRQ translater, then use the parent as
619                  * our IRQ controller.
620                  */
621                 if (pp->irq_trans)
622                         return pp;
623
624                 return NULL;
625         }
626
627         *irq_p = irq;
628         cp = of_find_node_by_phandle(handle);
629
630         return cp;
631 }
632
633 static unsigned int __init pci_irq_swizzle(struct device_node *dp,
634                                            struct device_node *pp,
635                                            unsigned int irq)
636 {
637         const struct linux_prom_pci_registers *regs;
638         unsigned int bus, devfn, slot, ret;
639
640         if (irq < 1 || irq > 4)
641                 return irq;
642
643         regs = of_get_property(dp, "reg", NULL);
644         if (!regs)
645                 return irq;
646
647         bus = (regs->phys_hi >> 16) & 0xff;
648         devfn = (regs->phys_hi >> 8) & 0xff;
649         slot = (devfn >> 3) & 0x1f;
650
651         if (pp->irq_trans) {
652                 /* Derived from Table 8-3, U2P User's Manual.  This branch
653                  * is handling a PCI controller that lacks a proper set of
654                  * interrupt-map and interrupt-map-mask properties.  The
655                  * Ultra-E450 is one example.
656                  *
657                  * The bit layout is BSSLL, where:
658                  * B: 0 on bus A, 1 on bus B
659                  * D: 2-bit slot number, derived from PCI device number as
660                  *    (dev - 1) for bus A, or (dev - 2) for bus B
661                  * L: 2-bit line number
662                  */
663                 if (bus & 0x80) {
664                         /* PBM-A */
665                         bus  = 0x00;
666                         slot = (slot - 1) << 2;
667                 } else {
668                         /* PBM-B */
669                         bus  = 0x10;
670                         slot = (slot - 2) << 2;
671                 }
672                 irq -= 1;
673
674                 ret = (bus | slot | irq);
675         } else {
676                 /* Going through a PCI-PCI bridge that lacks a set of
677                  * interrupt-map and interrupt-map-mask properties.
678                  */
679                 ret = ((irq - 1 + (slot & 3)) & 3) + 1;
680         }
681
682         return ret;
683 }
684
685 static int of_irq_verbose;
686
687 static unsigned int __init build_one_device_irq(struct of_device *op,
688                                                 struct device *parent,
689                                                 unsigned int irq)
690 {
691         struct device_node *dp = op->node;
692         struct device_node *pp, *ip;
693         unsigned int orig_irq = irq;
694         int nid;
695
696         if (irq == 0xffffffff)
697                 return irq;
698
699         if (dp->irq_trans) {
700                 irq = dp->irq_trans->irq_build(dp, irq,
701                                                dp->irq_trans->data);
702
703                 if (of_irq_verbose)
704                         printk("%s: direct translate %x --> %x\n",
705                                dp->full_name, orig_irq, irq);
706
707                 goto out;
708         }
709
710         /* Something more complicated.  Walk up to the root, applying
711          * interrupt-map or bus specific translations, until we hit
712          * an IRQ translator.
713          *
714          * If we hit a bus type or situation we cannot handle, we
715          * stop and assume that the original IRQ number was in a
716          * format which has special meaning to it's immediate parent.
717          */
718         pp = dp->parent;
719         ip = NULL;
720         while (pp) {
721                 const void *imap, *imsk;
722                 int imlen;
723
724                 imap = of_get_property(pp, "interrupt-map", &imlen);
725                 imsk = of_get_property(pp, "interrupt-map-mask", NULL);
726                 if (imap && imsk) {
727                         struct device_node *iret;
728                         int this_orig_irq = irq;
729
730                         iret = apply_interrupt_map(dp, pp,
731                                                    imap, imlen, imsk,
732                                                    &irq);
733
734                         if (of_irq_verbose)
735                                 printk("%s: Apply [%s:%x] imap --> [%s:%x]\n",
736                                        op->node->full_name,
737                                        pp->full_name, this_orig_irq,
738                                        (iret ? iret->full_name : "NULL"), irq);
739
740                         if (!iret)
741                                 break;
742
743                         if (iret->irq_trans) {
744                                 ip = iret;
745                                 break;
746                         }
747                 } else {
748                         if (!strcmp(pp->name, "pci")) {
749                                 unsigned int this_orig_irq = irq;
750
751                                 irq = pci_irq_swizzle(dp, pp, irq);
752                                 if (of_irq_verbose)
753                                         printk("%s: PCI swizzle [%s] "
754                                                "%x --> %x\n",
755                                                op->node->full_name,
756                                                pp->full_name, this_orig_irq,
757                                                irq);
758
759                         }
760
761                         if (pp->irq_trans) {
762                                 ip = pp;
763                                 break;
764                         }
765                 }
766                 dp = pp;
767                 pp = pp->parent;
768         }
769         if (!ip)
770                 return orig_irq;
771
772         irq = ip->irq_trans->irq_build(op->node, irq,
773                                        ip->irq_trans->data);
774         if (of_irq_verbose)
775                 printk("%s: Apply IRQ trans [%s] %x --> %x\n",
776                        op->node->full_name, ip->full_name, orig_irq, irq);
777
778 out:
779         nid = of_node_to_nid(dp);
780         if (nid != -1) {
781                 cpumask_t numa_mask = *cpumask_of_node(nid);
782
783                 irq_set_affinity(irq, &numa_mask);
784         }
785
786         return irq;
787 }
788
789 static struct of_device * __init scan_one_device(struct device_node *dp,
790                                                  struct device *parent)
791 {
792         struct of_device *op = kzalloc(sizeof(*op), GFP_KERNEL);
793         const unsigned int *irq;
794         struct dev_archdata *sd;
795         int len, i;
796
797         if (!op)
798                 return NULL;
799
800         sd = &op->dev.archdata;
801         sd->prom_node = dp;
802         sd->op = op;
803
804         op->node = dp;
805
806         op->clock_freq = of_getintprop_default(dp, "clock-frequency",
807                                                (25*1000*1000));
808         op->portid = of_getintprop_default(dp, "upa-portid", -1);
809         if (op->portid == -1)
810                 op->portid = of_getintprop_default(dp, "portid", -1);
811
812         irq = of_get_property(dp, "interrupts", &len);
813         if (irq) {
814                 op->num_irqs = len / 4;
815
816                 /* Prevent overrunning the op->irqs[] array.  */
817                 if (op->num_irqs > PROMINTR_MAX) {
818                         printk(KERN_WARNING "%s: Too many irqs (%d), "
819                                "limiting to %d.\n",
820                                dp->full_name, op->num_irqs, PROMINTR_MAX);
821                         op->num_irqs = PROMINTR_MAX;
822                 }
823                 memcpy(op->irqs, irq, op->num_irqs * 4);
824         } else {
825                 op->num_irqs = 0;
826         }
827
828         build_device_resources(op, parent);
829         for (i = 0; i < op->num_irqs; i++)
830                 op->irqs[i] = build_one_device_irq(op, parent, op->irqs[i]);
831
832         op->dev.parent = parent;
833         op->dev.bus = &of_platform_bus_type;
834         if (!parent)
835                 dev_set_name(&op->dev, "root");
836         else
837                 dev_set_name(&op->dev, "%08x", dp->node);
838
839         if (of_device_register(op)) {
840                 printk("%s: Could not register of device.\n",
841                        dp->full_name);
842                 kfree(op);
843                 op = NULL;
844         }
845
846         return op;
847 }
848
849 static void __init scan_tree(struct device_node *dp, struct device *parent)
850 {
851         while (dp) {
852                 struct of_device *op = scan_one_device(dp, parent);
853
854                 if (op)
855                         scan_tree(dp->child, &op->dev);
856
857                 dp = dp->sibling;
858         }
859 }
860
861 static void __init scan_of_devices(void)
862 {
863         struct device_node *root = of_find_node_by_path("/");
864         struct of_device *parent;
865
866         parent = scan_one_device(root, NULL);
867         if (!parent)
868                 return;
869
870         scan_tree(root->child, &parent->dev);
871 }
872
873 static int __init of_bus_driver_init(void)
874 {
875         int err;
876
877         err = of_bus_type_init(&of_platform_bus_type, "of");
878         if (!err)
879                 scan_of_devices();
880
881         return err;
882 }
883
884 postcore_initcall(of_bus_driver_init);
885
886 static int __init of_debug(char *str)
887 {
888         int val = 0;
889
890         get_option(&str, &val);
891         if (val & 1)
892                 of_resource_verbose = 1;
893         if (val & 2)
894                 of_irq_verbose = 1;
895         return 1;
896 }
897
898 __setup("of_debug=", of_debug);