Merge master.kernel.org:/pub/scm/linux/kernel/git/bunk/trivial
[linux-2.6] / arch / ppc / syslib / prom.c
1 /*
2  * Procedures for interfacing to the Open Firmware PROM on
3  * Power Macintosh computers.
4  *
5  * In particular, we are interested in the device tree
6  * and in using some of its services (exit, write to stdout).
7  *
8  * Paul Mackerras       August 1996.
9  * Copyright (C) 1996 Paul Mackerras.
10  */
11 #include <stdarg.h>
12 #include <linux/config.h>
13 #include <linux/kernel.h>
14 #include <linux/string.h>
15 #include <linux/init.h>
16 #include <linux/version.h>
17 #include <linux/threads.h>
18 #include <linux/spinlock.h>
19 #include <linux/ioport.h>
20 #include <linux/pci.h>
21 #include <linux/slab.h>
22 #include <linux/bitops.h>
23
24 #include <asm/sections.h>
25 #include <asm/prom.h>
26 #include <asm/page.h>
27 #include <asm/processor.h>
28 #include <asm/irq.h>
29 #include <asm/io.h>
30 #include <asm/smp.h>
31 #include <asm/bootx.h>
32 #include <asm/system.h>
33 #include <asm/mmu.h>
34 #include <asm/pgtable.h>
35 #include <asm/bootinfo.h>
36 #include <asm/btext.h>
37 #include <asm/pci-bridge.h>
38 #include <asm/open_pic.h>
39
40
41 struct pci_address {
42         unsigned a_hi;
43         unsigned a_mid;
44         unsigned a_lo;
45 };
46
47 struct pci_reg_property {
48         struct pci_address addr;
49         unsigned size_hi;
50         unsigned size_lo;
51 };
52
53 struct isa_reg_property {
54         unsigned space;
55         unsigned address;
56         unsigned size;
57 };
58
59 typedef unsigned long interpret_func(struct device_node *, unsigned long,
60                                      int, int);
61 static interpret_func interpret_pci_props;
62 static interpret_func interpret_dbdma_props;
63 static interpret_func interpret_isa_props;
64 static interpret_func interpret_macio_props;
65 static interpret_func interpret_root_props;
66
67 extern char *klimit;
68
69 /* Set for a newworld or CHRP machine */
70 int use_of_interrupt_tree;
71 struct device_node *dflt_interrupt_controller;
72 int num_interrupt_controllers;
73
74 int pmac_newworld;
75
76 extern unsigned int rtas_entry;  /* physical pointer */
77
78 extern struct device_node *allnodes;
79
80 static unsigned long finish_node(struct device_node *, unsigned long,
81                                  interpret_func *, int, int);
82 static unsigned long finish_node_interrupts(struct device_node *, unsigned long);
83 static struct device_node *find_phandle(phandle);
84
85 extern void enter_rtas(void *);
86 void phys_call_rtas(int, int, int, ...);
87
88 extern char cmd_line[512];      /* XXX */
89 extern boot_infos_t *boot_infos;
90 unsigned long dev_tree_size;
91
92 void
93 phys_call_rtas(int service, int nargs, int nret, ...)
94 {
95         va_list list;
96         union {
97                 unsigned long words[16];
98                 double align;
99         } u;
100         void (*rtas)(void *, unsigned long);
101         int i;
102
103         u.words[0] = service;
104         u.words[1] = nargs;
105         u.words[2] = nret;
106         va_start(list, nret);
107         for (i = 0; i < nargs; ++i)
108                 u.words[i+3] = va_arg(list, unsigned long);
109         va_end(list);
110
111         rtas = (void (*)(void *, unsigned long)) rtas_entry;
112         rtas(&u, rtas_data);
113 }
114
115 /*
116  * finish_device_tree is called once things are running normally
117  * (i.e. with text and data mapped to the address they were linked at).
118  * It traverses the device tree and fills in the name, type,
119  * {n_}addrs and {n_}intrs fields of each node.
120  */
121 void __init
122 finish_device_tree(void)
123 {
124         unsigned long mem = (unsigned long) klimit;
125         struct device_node *np;
126
127         /* All newworld pmac machines and CHRPs now use the interrupt tree */
128         for (np = allnodes; np != NULL; np = np->allnext) {
129                 if (get_property(np, "interrupt-parent", NULL)) {
130                         use_of_interrupt_tree = 1;
131                         break;
132                 }
133         }
134         if (_machine == _MACH_Pmac && use_of_interrupt_tree)
135                 pmac_newworld = 1;
136
137 #ifdef CONFIG_BOOTX_TEXT
138         if (boot_infos && pmac_newworld) {
139                 prom_print("WARNING ! BootX/miBoot booting is not supported on this machine\n");
140                 prom_print("          You should use an Open Firmware bootloader\n");
141         }
142 #endif /* CONFIG_BOOTX_TEXT */
143
144         if (use_of_interrupt_tree) {
145                 /*
146                  * We want to find out here how many interrupt-controller
147                  * nodes there are, and if we are booted from BootX,
148                  * we need a pointer to the first (and hopefully only)
149                  * such node.  But we can't use find_devices here since
150                  * np->name has not been set yet.  -- paulus
151                  */
152                 int n = 0;
153                 char *name, *ic;
154                 int iclen;
155
156                 for (np = allnodes; np != NULL; np = np->allnext) {
157                         ic = get_property(np, "interrupt-controller", &iclen);
158                         name = get_property(np, "name", NULL);
159                         /* checking iclen makes sure we don't get a false
160                            match on /chosen.interrupt_controller */
161                         if ((name != NULL
162                              && strcmp(name, "interrupt-controller") == 0)
163                             || (ic != NULL && iclen == 0 && strcmp(name, "AppleKiwi"))) {
164                                 if (n == 0)
165                                         dflt_interrupt_controller = np;
166                                 ++n;
167                         }
168                 }
169                 num_interrupt_controllers = n;
170         }
171
172         mem = finish_node(allnodes, mem, NULL, 1, 1);
173         dev_tree_size = mem - (unsigned long) allnodes;
174         klimit = (char *) mem;
175 }
176
177 static unsigned long __init
178 finish_node(struct device_node *np, unsigned long mem_start,
179             interpret_func *ifunc, int naddrc, int nsizec)
180 {
181         struct device_node *child;
182         int *ip;
183
184         np->name = get_property(np, "name", NULL);
185         np->type = get_property(np, "device_type", NULL);
186
187         if (!np->name)
188                 np->name = "<NULL>";
189         if (!np->type)
190                 np->type = "<NULL>";
191
192         /* get the device addresses and interrupts */
193         if (ifunc != NULL)
194                 mem_start = ifunc(np, mem_start, naddrc, nsizec);
195
196         if (use_of_interrupt_tree)
197                 mem_start = finish_node_interrupts(np, mem_start);
198
199         /* Look for #address-cells and #size-cells properties. */
200         ip = (int *) get_property(np, "#address-cells", NULL);
201         if (ip != NULL)
202                 naddrc = *ip;
203         ip = (int *) get_property(np, "#size-cells", NULL);
204         if (ip != NULL)
205                 nsizec = *ip;
206
207         if (np->parent == NULL)
208                 ifunc = interpret_root_props;
209         else if (np->type == 0)
210                 ifunc = NULL;
211         else if (!strcmp(np->type, "pci") || !strcmp(np->type, "vci"))
212                 ifunc = interpret_pci_props;
213         else if (!strcmp(np->type, "dbdma"))
214                 ifunc = interpret_dbdma_props;
215         else if (!strcmp(np->type, "mac-io")
216                  || ifunc == interpret_macio_props)
217                 ifunc = interpret_macio_props;
218         else if (!strcmp(np->type, "isa"))
219                 ifunc = interpret_isa_props;
220         else if (!strcmp(np->name, "uni-n") || !strcmp(np->name, "u3"))
221                 ifunc = interpret_root_props;
222         else if (!((ifunc == interpret_dbdma_props
223                     || ifunc == interpret_macio_props)
224                    && (!strcmp(np->type, "escc")
225                        || !strcmp(np->type, "media-bay"))))
226                 ifunc = NULL;
227
228         /* if we were booted from BootX, convert the full name */
229         if (boot_infos
230             && strncmp(np->full_name, "Devices:device-tree", 19) == 0) {
231                 if (np->full_name[19] == 0) {
232                         strcpy(np->full_name, "/");
233                 } else if (np->full_name[19] == ':') {
234                         char *p = np->full_name + 19;
235                         np->full_name = p;
236                         for (; *p; ++p)
237                                 if (*p == ':')
238                                         *p = '/';
239                 }
240         }
241
242         for (child = np->child; child != NULL; child = child->sibling)
243                 mem_start = finish_node(child, mem_start, ifunc,
244                                         naddrc, nsizec);
245
246         return mem_start;
247 }
248
249 /*
250  * Find the interrupt parent of a node.
251  */
252 static struct device_node * __init
253 intr_parent(struct device_node *p)
254 {
255         phandle *parp;
256
257         parp = (phandle *) get_property(p, "interrupt-parent", NULL);
258         if (parp == NULL)
259                 return p->parent;
260         p = find_phandle(*parp);
261         if (p != NULL)
262                 return p;
263         /*
264          * On a powermac booted with BootX, we don't get to know the
265          * phandles for any nodes, so find_phandle will return NULL.
266          * Fortunately these machines only have one interrupt controller
267          * so there isn't in fact any ambiguity.  -- paulus
268          */
269         if (num_interrupt_controllers == 1)
270                 p = dflt_interrupt_controller;
271         return p;
272 }
273
274 /*
275  * Find out the size of each entry of the interrupts property
276  * for a node.
277  */
278 static int __init
279 prom_n_intr_cells(struct device_node *np)
280 {
281         struct device_node *p;
282         unsigned int *icp;
283
284         for (p = np; (p = intr_parent(p)) != NULL; ) {
285                 icp = (unsigned int *)
286                         get_property(p, "#interrupt-cells", NULL);
287                 if (icp != NULL)
288                         return *icp;
289                 if (get_property(p, "interrupt-controller", NULL) != NULL
290                     || get_property(p, "interrupt-map", NULL) != NULL) {
291                         printk("oops, node %s doesn't have #interrupt-cells\n",
292                                p->full_name);
293                         return 1;
294                 }
295         }
296         printk("prom_n_intr_cells failed for %s\n", np->full_name);
297         return 1;
298 }
299
300 /*
301  * Map an interrupt from a device up to the platform interrupt
302  * descriptor.
303  */
304 static int __init
305 map_interrupt(unsigned int **irq, struct device_node **ictrler,
306               struct device_node *np, unsigned int *ints, int nintrc)
307 {
308         struct device_node *p, *ipar;
309         unsigned int *imap, *imask, *ip;
310         int i, imaplen, match;
311         int newintrc = 1, newaddrc = 1;
312         unsigned int *reg;
313         int naddrc;
314
315         reg = (unsigned int *) get_property(np, "reg", NULL);
316         naddrc = prom_n_addr_cells(np);
317         p = intr_parent(np);
318         while (p != NULL) {
319                 if (get_property(p, "interrupt-controller", NULL) != NULL)
320                         /* this node is an interrupt controller, stop here */
321                         break;
322                 imap = (unsigned int *)
323                         get_property(p, "interrupt-map", &imaplen);
324                 if (imap == NULL) {
325                         p = intr_parent(p);
326                         continue;
327                 }
328                 imask = (unsigned int *)
329                         get_property(p, "interrupt-map-mask", NULL);
330                 if (imask == NULL) {
331                         printk("oops, %s has interrupt-map but no mask\n",
332                                p->full_name);
333                         return 0;
334                 }
335                 imaplen /= sizeof(unsigned int);
336                 match = 0;
337                 ipar = NULL;
338                 while (imaplen > 0 && !match) {
339                         /* check the child-interrupt field */
340                         match = 1;
341                         for (i = 0; i < naddrc && match; ++i)
342                                 match = ((reg[i] ^ imap[i]) & imask[i]) == 0;
343                         for (; i < naddrc + nintrc && match; ++i)
344                                 match = ((ints[i-naddrc] ^ imap[i]) & imask[i]) == 0;
345                         imap += naddrc + nintrc;
346                         imaplen -= naddrc + nintrc;
347                         /* grab the interrupt parent */
348                         ipar = find_phandle((phandle) *imap++);
349                         --imaplen;
350                         if (ipar == NULL && num_interrupt_controllers == 1)
351                                 /* cope with BootX not giving us phandles */
352                                 ipar = dflt_interrupt_controller;
353                         if (ipar == NULL) {
354                                 printk("oops, no int parent %x in map of %s\n",
355                                        imap[-1], p->full_name);
356                                 return 0;
357                         }
358                         /* find the parent's # addr and intr cells */
359                         ip = (unsigned int *)
360                                 get_property(ipar, "#interrupt-cells", NULL);
361                         if (ip == NULL) {
362                                 printk("oops, no #interrupt-cells on %s\n",
363                                        ipar->full_name);
364                                 return 0;
365                         }
366                         newintrc = *ip;
367                         ip = (unsigned int *)
368                                 get_property(ipar, "#address-cells", NULL);
369                         newaddrc = (ip == NULL)? 0: *ip;
370                         imap += newaddrc + newintrc;
371                         imaplen -= newaddrc + newintrc;
372                 }
373                 if (imaplen < 0) {
374                         printk("oops, error decoding int-map on %s, len=%d\n",
375                                p->full_name, imaplen);
376                         return 0;
377                 }
378                 if (!match) {
379                         printk("oops, no match in %s int-map for %s\n",
380                                p->full_name, np->full_name);
381                         return 0;
382                 }
383                 p = ipar;
384                 naddrc = newaddrc;
385                 nintrc = newintrc;
386                 ints = imap - nintrc;
387                 reg = ints - naddrc;
388         }
389         if (p == NULL)
390                 printk("hmmm, int tree for %s doesn't have ctrler\n",
391                        np->full_name);
392         *irq = ints;
393         *ictrler = p;
394         return nintrc;
395 }
396
397 /*
398  * New version of finish_node_interrupts.
399  */
400 static unsigned long __init
401 finish_node_interrupts(struct device_node *np, unsigned long mem_start)
402 {
403         unsigned int *ints;
404         int intlen, intrcells;
405         int i, j, n, offset;
406         unsigned int *irq;
407         struct device_node *ic;
408
409         ints = (unsigned int *) get_property(np, "interrupts", &intlen);
410         if (ints == NULL)
411                 return mem_start;
412         intrcells = prom_n_intr_cells(np);
413         intlen /= intrcells * sizeof(unsigned int);
414         np->n_intrs = intlen;
415         np->intrs = (struct interrupt_info *) mem_start;
416         mem_start += intlen * sizeof(struct interrupt_info);
417
418         for (i = 0; i < intlen; ++i) {
419                 np->intrs[i].line = 0;
420                 np->intrs[i].sense = 1;
421                 n = map_interrupt(&irq, &ic, np, ints, intrcells);
422                 if (n <= 0)
423                         continue;
424                 offset = 0;
425                 /*
426                  * On a CHRP we have an 8259 which is subordinate to
427                  * the openpic in the interrupt tree, but we want the
428                  * openpic's interrupt numbers offsetted, not the 8259's.
429                  * So we apply the offset if the controller is at the
430                  * root of the interrupt tree, i.e. has no interrupt-parent.
431                  * This doesn't cope with the general case of multiple
432                  * cascaded interrupt controllers, but then neither will
433                  * irq.c at the moment either.  -- paulus
434                  * The G5 triggers that code, I add a machine test. On
435                  * those machines, we want to offset interrupts from the
436                  * second openpic by 128 -- BenH
437                  */
438                 if (_machine != _MACH_Pmac && num_interrupt_controllers > 1
439                     && ic != NULL
440                     && get_property(ic, "interrupt-parent", NULL) == NULL)
441                         offset = 16;
442                 else if (_machine == _MACH_Pmac && num_interrupt_controllers > 1
443                          && ic != NULL && ic->parent != NULL) {
444                         char *name = get_property(ic->parent, "name", NULL);
445                         if (name && !strcmp(name, "u3"))
446                                 offset = 128;
447                 }
448
449                 np->intrs[i].line = irq[0] + offset;
450                 if (n > 1)
451                         np->intrs[i].sense = irq[1];
452                 if (n > 2) {
453                         printk("hmmm, got %d intr cells for %s:", n,
454                                np->full_name);
455                         for (j = 0; j < n; ++j)
456                                 printk(" %d", irq[j]);
457                         printk("\n");
458                 }
459                 ints += intrcells;
460         }
461
462         return mem_start;
463 }
464
465 /*
466  * When BootX makes a copy of the device tree from the MacOS
467  * Name Registry, it is in the format we use but all of the pointers
468  * are offsets from the start of the tree.
469  * This procedure updates the pointers.
470  */
471 void __init
472 relocate_nodes(void)
473 {
474         unsigned long base;
475         struct device_node *np;
476         struct property *pp;
477
478 #define ADDBASE(x)      (x = (typeof (x))((x)? ((unsigned long)(x) + base): 0))
479
480         base = (unsigned long) boot_infos + boot_infos->deviceTreeOffset;
481         allnodes = (struct device_node *)(base + 4);
482         for (np = allnodes; np != 0; np = np->allnext) {
483                 ADDBASE(np->full_name);
484                 ADDBASE(np->properties);
485                 ADDBASE(np->parent);
486                 ADDBASE(np->child);
487                 ADDBASE(np->sibling);
488                 ADDBASE(np->allnext);
489                 for (pp = np->properties; pp != 0; pp = pp->next) {
490                         ADDBASE(pp->name);
491                         ADDBASE(pp->value);
492                         ADDBASE(pp->next);
493                 }
494         }
495 }
496
497 int
498 prom_n_addr_cells(struct device_node* np)
499 {
500         int* ip;
501         do {
502                 if (np->parent)
503                         np = np->parent;
504                 ip = (int *) get_property(np, "#address-cells", NULL);
505                 if (ip != NULL)
506                         return *ip;
507         } while (np->parent);
508         /* No #address-cells property for the root node, default to 1 */
509         return 1;
510 }
511
512 int
513 prom_n_size_cells(struct device_node* np)
514 {
515         int* ip;
516         do {
517                 if (np->parent)
518                         np = np->parent;
519                 ip = (int *) get_property(np, "#size-cells", NULL);
520                 if (ip != NULL)
521                         return *ip;
522         } while (np->parent);
523         /* No #size-cells property for the root node, default to 1 */
524         return 1;
525 }
526
527 static unsigned long __init
528 map_addr(struct device_node *np, unsigned long space, unsigned long addr)
529 {
530         int na;
531         unsigned int *ranges;
532         int rlen = 0;
533         unsigned int type;
534
535         type = (space >> 24) & 3;
536         if (type == 0)
537                 return addr;
538
539         while ((np = np->parent) != NULL) {
540                 if (strcmp(np->type, "pci") != 0)
541                         continue;
542                 /* PCI bridge: map the address through the ranges property */
543                 na = prom_n_addr_cells(np);
544                 ranges = (unsigned int *) get_property(np, "ranges", &rlen);
545                 while ((rlen -= (na + 5) * sizeof(unsigned int)) >= 0) {
546                         if (((ranges[0] >> 24) & 3) == type
547                             && ranges[2] <= addr
548                             && addr - ranges[2] < ranges[na+4]) {
549                                 /* ok, this matches, translate it */
550                                 addr += ranges[na+2] - ranges[2];
551                                 break;
552                         }
553                         ranges += na + 5;
554                 }
555         }
556         return addr;
557 }
558
559 static unsigned long __init
560 interpret_pci_props(struct device_node *np, unsigned long mem_start,
561                     int naddrc, int nsizec)
562 {
563         struct address_range *adr;
564         struct pci_reg_property *pci_addrs;
565         int i, l, *ip;
566
567         pci_addrs = (struct pci_reg_property *)
568                 get_property(np, "assigned-addresses", &l);
569         if (pci_addrs != 0 && l >= sizeof(struct pci_reg_property)) {
570                 i = 0;
571                 adr = (struct address_range *) mem_start;
572                 while ((l -= sizeof(struct pci_reg_property)) >= 0) {
573                         adr[i].space = pci_addrs[i].addr.a_hi;
574                         adr[i].address = map_addr(np, pci_addrs[i].addr.a_hi,
575                                                   pci_addrs[i].addr.a_lo);
576                         adr[i].size = pci_addrs[i].size_lo;
577                         ++i;
578                 }
579                 np->addrs = adr;
580                 np->n_addrs = i;
581                 mem_start += i * sizeof(struct address_range);
582         }
583
584         if (use_of_interrupt_tree)
585                 return mem_start;
586
587         ip = (int *) get_property(np, "AAPL,interrupts", &l);
588         if (ip == 0 && np->parent)
589                 ip = (int *) get_property(np->parent, "AAPL,interrupts", &l);
590         if (ip == 0)
591                 ip = (int *) get_property(np, "interrupts", &l);
592         if (ip != 0) {
593                 np->intrs = (struct interrupt_info *) mem_start;
594                 np->n_intrs = l / sizeof(int);
595                 mem_start += np->n_intrs * sizeof(struct interrupt_info);
596                 for (i = 0; i < np->n_intrs; ++i) {
597                         np->intrs[i].line = *ip++;
598                         np->intrs[i].sense = 1;
599                 }
600         }
601
602         return mem_start;
603 }
604
605 static unsigned long __init
606 interpret_dbdma_props(struct device_node *np, unsigned long mem_start,
607                       int naddrc, int nsizec)
608 {
609         struct reg_property *rp;
610         struct address_range *adr;
611         unsigned long base_address;
612         int i, l, *ip;
613         struct device_node *db;
614
615         base_address = 0;
616         for (db = np->parent; db != NULL; db = db->parent) {
617                 if (!strcmp(db->type, "dbdma") && db->n_addrs != 0) {
618                         base_address = db->addrs[0].address;
619                         break;
620                 }
621         }
622
623         rp = (struct reg_property *) get_property(np, "reg", &l);
624         if (rp != 0 && l >= sizeof(struct reg_property)) {
625                 i = 0;
626                 adr = (struct address_range *) mem_start;
627                 while ((l -= sizeof(struct reg_property)) >= 0) {
628                         adr[i].space = 2;
629                         adr[i].address = rp[i].address + base_address;
630                         adr[i].size = rp[i].size;
631                         ++i;
632                 }
633                 np->addrs = adr;
634                 np->n_addrs = i;
635                 mem_start += i * sizeof(struct address_range);
636         }
637
638         if (use_of_interrupt_tree)
639                 return mem_start;
640
641         ip = (int *) get_property(np, "AAPL,interrupts", &l);
642         if (ip == 0)
643                 ip = (int *) get_property(np, "interrupts", &l);
644         if (ip != 0) {
645                 np->intrs = (struct interrupt_info *) mem_start;
646                 np->n_intrs = l / sizeof(int);
647                 mem_start += np->n_intrs * sizeof(struct interrupt_info);
648                 for (i = 0; i < np->n_intrs; ++i) {
649                         np->intrs[i].line = *ip++;
650                         np->intrs[i].sense = 1;
651                 }
652         }
653
654         return mem_start;
655 }
656
657 static unsigned long __init
658 interpret_macio_props(struct device_node *np, unsigned long mem_start,
659                       int naddrc, int nsizec)
660 {
661         struct reg_property *rp;
662         struct address_range *adr;
663         unsigned long base_address;
664         int i, l, *ip;
665         struct device_node *db;
666
667         base_address = 0;
668         for (db = np->parent; db != NULL; db = db->parent) {
669                 if (!strcmp(db->type, "mac-io") && db->n_addrs != 0) {
670                         base_address = db->addrs[0].address;
671                         break;
672                 }
673         }
674
675         rp = (struct reg_property *) get_property(np, "reg", &l);
676         if (rp != 0 && l >= sizeof(struct reg_property)) {
677                 i = 0;
678                 adr = (struct address_range *) mem_start;
679                 while ((l -= sizeof(struct reg_property)) >= 0) {
680                         adr[i].space = 2;
681                         adr[i].address = rp[i].address + base_address;
682                         adr[i].size = rp[i].size;
683                         ++i;
684                 }
685                 np->addrs = adr;
686                 np->n_addrs = i;
687                 mem_start += i * sizeof(struct address_range);
688         }
689
690         if (use_of_interrupt_tree)
691                 return mem_start;
692
693         ip = (int *) get_property(np, "interrupts", &l);
694         if (ip == 0)
695                 ip = (int *) get_property(np, "AAPL,interrupts", &l);
696         if (ip != 0) {
697                 np->intrs = (struct interrupt_info *) mem_start;
698                 np->n_intrs = l / sizeof(int);
699                 for (i = 0; i < np->n_intrs; ++i) {
700                         np->intrs[i].line = *ip++;
701                         np->intrs[i].sense = 1;
702                 }
703                 mem_start += np->n_intrs * sizeof(struct interrupt_info);
704         }
705
706         return mem_start;
707 }
708
709 static unsigned long __init
710 interpret_isa_props(struct device_node *np, unsigned long mem_start,
711                     int naddrc, int nsizec)
712 {
713         struct isa_reg_property *rp;
714         struct address_range *adr;
715         int i, l, *ip;
716
717         rp = (struct isa_reg_property *) get_property(np, "reg", &l);
718         if (rp != 0 && l >= sizeof(struct isa_reg_property)) {
719                 i = 0;
720                 adr = (struct address_range *) mem_start;
721                 while ((l -= sizeof(struct reg_property)) >= 0) {
722                         adr[i].space = rp[i].space;
723                         adr[i].address = rp[i].address
724                                 + (adr[i].space? 0: _ISA_MEM_BASE);
725                         adr[i].size = rp[i].size;
726                         ++i;
727                 }
728                 np->addrs = adr;
729                 np->n_addrs = i;
730                 mem_start += i * sizeof(struct address_range);
731         }
732
733         if (use_of_interrupt_tree)
734                 return mem_start;
735
736         ip = (int *) get_property(np, "interrupts", &l);
737         if (ip != 0) {
738                 np->intrs = (struct interrupt_info *) mem_start;
739                 np->n_intrs = l / (2 * sizeof(int));
740                 mem_start += np->n_intrs * sizeof(struct interrupt_info);
741                 for (i = 0; i < np->n_intrs; ++i) {
742                         np->intrs[i].line = *ip++;
743                         np->intrs[i].sense = *ip++;
744                 }
745         }
746
747         return mem_start;
748 }
749
750 static unsigned long __init
751 interpret_root_props(struct device_node *np, unsigned long mem_start,
752                      int naddrc, int nsizec)
753 {
754         struct address_range *adr;
755         int i, l, *ip;
756         unsigned int *rp;
757         int rpsize = (naddrc + nsizec) * sizeof(unsigned int);
758
759         rp = (unsigned int *) get_property(np, "reg", &l);
760         if (rp != 0 && l >= rpsize) {
761                 i = 0;
762                 adr = (struct address_range *) mem_start;
763                 while ((l -= rpsize) >= 0) {
764                         adr[i].space = (naddrc >= 2? rp[naddrc-2]: 2);
765                         adr[i].address = rp[naddrc - 1];
766                         adr[i].size = rp[naddrc + nsizec - 1];
767                         ++i;
768                         rp += naddrc + nsizec;
769                 }
770                 np->addrs = adr;
771                 np->n_addrs = i;
772                 mem_start += i * sizeof(struct address_range);
773         }
774
775         if (use_of_interrupt_tree)
776                 return mem_start;
777
778         ip = (int *) get_property(np, "AAPL,interrupts", &l);
779         if (ip == 0)
780                 ip = (int *) get_property(np, "interrupts", &l);
781         if (ip != 0) {
782                 np->intrs = (struct interrupt_info *) mem_start;
783                 np->n_intrs = l / sizeof(int);
784                 mem_start += np->n_intrs * sizeof(struct interrupt_info);
785                 for (i = 0; i < np->n_intrs; ++i) {
786                         np->intrs[i].line = *ip++;
787                         np->intrs[i].sense = 1;
788                 }
789         }
790
791         return mem_start;
792 }
793
794 /*
795  * Work out the sense (active-low level / active-high edge)
796  * of each interrupt from the device tree.
797  */
798 void __init
799 prom_get_irq_senses(unsigned char *senses, int off, int max)
800 {
801         struct device_node *np;
802         int i, j;
803
804         /* default to level-triggered */
805         memset(senses, 1, max - off);
806         if (!use_of_interrupt_tree)
807                 return;
808
809         for (np = allnodes; np != 0; np = np->allnext) {
810                 for (j = 0; j < np->n_intrs; j++) {
811                         i = np->intrs[j].line;
812                         if (i >= off && i < max) {
813                                 if (np->intrs[j].sense == 1)
814                                         senses[i-off] = (IRQ_SENSE_LEVEL
815                                                 | IRQ_POLARITY_NEGATIVE);
816                                 else
817                                         senses[i-off] = (IRQ_SENSE_EDGE
818                                                 | IRQ_POLARITY_POSITIVE);
819                         }
820                 }
821         }
822 }
823
824 /*
825  * Construct and return a list of the device_nodes with a given name.
826  */
827 struct device_node *
828 find_devices(const char *name)
829 {
830         struct device_node *head, **prevp, *np;
831
832         prevp = &head;
833         for (np = allnodes; np != 0; np = np->allnext) {
834                 if (np->name != 0 && strcasecmp(np->name, name) == 0) {
835                         *prevp = np;
836                         prevp = &np->next;
837                 }
838         }
839         *prevp = NULL;
840         return head;
841 }
842
843 /*
844  * Construct and return a list of the device_nodes with a given type.
845  */
846 struct device_node *
847 find_type_devices(const char *type)
848 {
849         struct device_node *head, **prevp, *np;
850
851         prevp = &head;
852         for (np = allnodes; np != 0; np = np->allnext) {
853                 if (np->type != 0 && strcasecmp(np->type, type) == 0) {
854                         *prevp = np;
855                         prevp = &np->next;
856                 }
857         }
858         *prevp = NULL;
859         return head;
860 }
861
862 /*
863  * Returns all nodes linked together
864  */
865 struct device_node *
866 find_all_nodes(void)
867 {
868         struct device_node *head, **prevp, *np;
869
870         prevp = &head;
871         for (np = allnodes; np != 0; np = np->allnext) {
872                 *prevp = np;
873                 prevp = &np->next;
874         }
875         *prevp = NULL;
876         return head;
877 }
878
879 /* Checks if the given "compat" string matches one of the strings in
880  * the device's "compatible" property
881  */
882 int
883 device_is_compatible(struct device_node *device, const char *compat)
884 {
885         const char* cp;
886         int cplen, l;
887
888         cp = (char *) get_property(device, "compatible", &cplen);
889         if (cp == NULL)
890                 return 0;
891         while (cplen > 0) {
892                 if (strncasecmp(cp, compat, strlen(compat)) == 0)
893                         return 1;
894                 l = strlen(cp) + 1;
895                 cp += l;
896                 cplen -= l;
897         }
898
899         return 0;
900 }
901
902
903 /*
904  * Indicates whether the root node has a given value in its
905  * compatible property.
906  */
907 int
908 machine_is_compatible(const char *compat)
909 {
910         struct device_node *root;
911
912         root = find_path_device("/");
913         if (root == 0)
914                 return 0;
915         return device_is_compatible(root, compat);
916 }
917
918 /*
919  * Construct and return a list of the device_nodes with a given type
920  * and compatible property.
921  */
922 struct device_node *
923 find_compatible_devices(const char *type, const char *compat)
924 {
925         struct device_node *head, **prevp, *np;
926
927         prevp = &head;
928         for (np = allnodes; np != 0; np = np->allnext) {
929                 if (type != NULL
930                     && !(np->type != 0 && strcasecmp(np->type, type) == 0))
931                         continue;
932                 if (device_is_compatible(np, compat)) {
933                         *prevp = np;
934                         prevp = &np->next;
935                 }
936         }
937         *prevp = NULL;
938         return head;
939 }
940
941 /*
942  * Find the device_node with a given full_name.
943  */
944 struct device_node *
945 find_path_device(const char *path)
946 {
947         struct device_node *np;
948
949         for (np = allnodes; np != 0; np = np->allnext)
950                 if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0)
951                         return np;
952         return NULL;
953 }
954
955 /*******
956  *
957  * New implementation of the OF "find" APIs, return a refcounted
958  * object, call of_node_put() when done. Currently, still lacks
959  * locking as old implementation, this is beeing done for ppc64.
960  *
961  * Note that property management will need some locking as well,
962  * this isn't dealt with yet
963  *
964  *******/
965
966 /**
967  *      of_find_node_by_name - Find a node by it's "name" property
968  *      @from:  The node to start searching from or NULL, the node
969  *              you pass will not be searched, only the next one
970  *              will; typically, you pass what the previous call
971  *              returned. of_node_put() will be called on it
972  *      @name:  The name string to match against
973  *
974  *      Returns a node pointer with refcount incremented, use
975  *      of_node_put() on it when done.
976  */
977 struct device_node *of_find_node_by_name(struct device_node *from,
978         const char *name)
979 {
980         struct device_node *np = from ? from->allnext : allnodes;
981
982         for (; np != 0; np = np->allnext)
983                 if (np->name != 0 && strcasecmp(np->name, name) == 0)
984                         break;
985         if (from)
986                 of_node_put(from);
987         return of_node_get(np);
988 }
989
990 /**
991  *      of_find_node_by_type - Find a node by it's "device_type" property
992  *      @from:  The node to start searching from or NULL, the node
993  *              you pass will not be searched, only the next one
994  *              will; typically, you pass what the previous call
995  *              returned. of_node_put() will be called on it
996  *      @name:  The type string to match against
997  *
998  *      Returns a node pointer with refcount incremented, use
999  *      of_node_put() on it when done.
1000  */
1001 struct device_node *of_find_node_by_type(struct device_node *from,
1002         const char *type)
1003 {
1004         struct device_node *np = from ? from->allnext : allnodes;
1005
1006         for (; np != 0; np = np->allnext)
1007                 if (np->type != 0 && strcasecmp(np->type, type) == 0)
1008                         break;
1009         if (from)
1010                 of_node_put(from);
1011         return of_node_get(np);
1012 }
1013
1014 /**
1015  *      of_find_compatible_node - Find a node based on type and one of the
1016  *                                tokens in it's "compatible" property
1017  *      @from:          The node to start searching from or NULL, the node
1018  *                      you pass will not be searched, only the next one
1019  *                      will; typically, you pass what the previous call
1020  *                      returned. of_node_put() will be called on it
1021  *      @type:          The type string to match "device_type" or NULL to ignore
1022  *      @compatible:    The string to match to one of the tokens in the device
1023  *                      "compatible" list.
1024  *
1025  *      Returns a node pointer with refcount incremented, use
1026  *      of_node_put() on it when done.
1027  */
1028 struct device_node *of_find_compatible_node(struct device_node *from,
1029         const char *type, const char *compatible)
1030 {
1031         struct device_node *np = from ? from->allnext : allnodes;
1032
1033         for (; np != 0; np = np->allnext) {
1034                 if (type != NULL
1035                     && !(np->type != 0 && strcasecmp(np->type, type) == 0))
1036                         continue;
1037                 if (device_is_compatible(np, compatible))
1038                         break;
1039         }
1040         if (from)
1041                 of_node_put(from);
1042         return of_node_get(np);
1043 }
1044
1045 /**
1046  *      of_find_node_by_path - Find a node matching a full OF path
1047  *      @path:  The full path to match
1048  *
1049  *      Returns a node pointer with refcount incremented, use
1050  *      of_node_put() on it when done.
1051  */
1052 struct device_node *of_find_node_by_path(const char *path)
1053 {
1054         struct device_node *np = allnodes;
1055
1056         for (; np != 0; np = np->allnext)
1057                 if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0)
1058                         break;
1059         return of_node_get(np);
1060 }
1061
1062 /**
1063  *      of_find_all_nodes - Get next node in global list
1064  *      @prev:  Previous node or NULL to start iteration
1065  *              of_node_put() will be called on it
1066  *
1067  *      Returns a node pointer with refcount incremented, use
1068  *      of_node_put() on it when done.
1069  */
1070 struct device_node *of_find_all_nodes(struct device_node *prev)
1071 {
1072         return of_node_get(prev ? prev->allnext : allnodes);
1073 }
1074
1075 /**
1076  *      of_get_parent - Get a node's parent if any
1077  *      @node:  Node to get parent
1078  *
1079  *      Returns a node pointer with refcount incremented, use
1080  *      of_node_put() on it when done.
1081  */
1082 struct device_node *of_get_parent(const struct device_node *node)
1083 {
1084         return node ? of_node_get(node->parent) : NULL;
1085 }
1086
1087 /**
1088  *      of_get_next_child - Iterate a node childs
1089  *      @node:  parent node
1090  *      @prev:  previous child of the parent node, or NULL to get first
1091  *
1092  *      Returns a node pointer with refcount incremented, use
1093  *      of_node_put() on it when done.
1094  */
1095 struct device_node *of_get_next_child(const struct device_node *node,
1096                                       struct device_node *prev)
1097 {
1098         struct device_node *next = prev ? prev->sibling : node->child;
1099
1100         for (; next != 0; next = next->sibling)
1101                 if (of_node_get(next))
1102                         break;
1103         if (prev)
1104                 of_node_put(prev);
1105         return next;
1106 }
1107
1108 /**
1109  *      of_node_get - Increment refcount of a node
1110  *      @node:  Node to inc refcount, NULL is supported to
1111  *              simplify writing of callers
1112  *
1113  *      Returns the node itself or NULL if gone. Current implementation
1114  *      does nothing as we don't yet do dynamic node allocation on ppc32
1115  */
1116 struct device_node *of_node_get(struct device_node *node)
1117 {
1118         return node;
1119 }
1120
1121 /**
1122  *      of_node_put - Decrement refcount of a node
1123  *      @node:  Node to dec refcount, NULL is supported to
1124  *              simplify writing of callers
1125  *
1126  *      Current implementation does nothing as we don't yet do dynamic node
1127  *      allocation on ppc32
1128  */
1129 void  of_node_put(struct device_node *node)
1130 {
1131 }
1132
1133 /*
1134  * Find the device_node with a given phandle.
1135  */
1136 static struct device_node * __init
1137 find_phandle(phandle ph)
1138 {
1139         struct device_node *np;
1140
1141         for (np = allnodes; np != 0; np = np->allnext)
1142                 if (np->node == ph)
1143                         return np;
1144         return NULL;
1145 }
1146
1147 /*
1148  * Find a property with a given name for a given node
1149  * and return the value.
1150  */
1151 unsigned char *
1152 get_property(struct device_node *np, const char *name, int *lenp)
1153 {
1154         struct property *pp;
1155
1156         for (pp = np->properties; pp != 0; pp = pp->next)
1157                 if (pp->name != NULL && strcmp(pp->name, name) == 0) {
1158                         if (lenp != 0)
1159                                 *lenp = pp->length;
1160                         return pp->value;
1161                 }
1162         return NULL;
1163 }
1164
1165 /*
1166  * Add a property to a node
1167  */
1168 void
1169 prom_add_property(struct device_node* np, struct property* prop)
1170 {
1171         struct property **next = &np->properties;
1172
1173         prop->next = NULL;
1174         while (*next)
1175                 next = &(*next)->next;
1176         *next = prop;
1177 }
1178
1179 /* I quickly hacked that one, check against spec ! */
1180 static inline unsigned long
1181 bus_space_to_resource_flags(unsigned int bus_space)
1182 {
1183         u8 space = (bus_space >> 24) & 0xf;
1184         if (space == 0)
1185                 space = 0x02;
1186         if (space == 0x02)
1187                 return IORESOURCE_MEM;
1188         else if (space == 0x01)
1189                 return IORESOURCE_IO;
1190         else {
1191                 printk(KERN_WARNING "prom.c: bus_space_to_resource_flags(), space: %x\n",
1192                         bus_space);
1193                 return 0;
1194         }
1195 }
1196
1197 static struct resource*
1198 find_parent_pci_resource(struct pci_dev* pdev, struct address_range *range)
1199 {
1200         unsigned long mask;
1201         int i;
1202
1203         /* Check this one */
1204         mask = bus_space_to_resource_flags(range->space);
1205         for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
1206                 if ((pdev->resource[i].flags & mask) == mask &&
1207                         pdev->resource[i].start <= range->address &&
1208                         pdev->resource[i].end > range->address) {
1209                                 if ((range->address + range->size - 1) > pdev->resource[i].end) {
1210                                         /* Add better message */
1211                                         printk(KERN_WARNING "PCI/OF resource overlap !\n");
1212                                         return NULL;
1213                                 }
1214                                 break;
1215                         }
1216         }
1217         if (i == DEVICE_COUNT_RESOURCE)
1218                 return NULL;
1219         return &pdev->resource[i];
1220 }
1221
1222 /*
1223  * Request an OF device resource. Currently handles child of PCI devices,
1224  * or other nodes attached to the root node. Ultimately, put some
1225  * link to resources in the OF node.
1226  */
1227 struct resource*
1228 request_OF_resource(struct device_node* node, int index, const char* name_postfix)
1229 {
1230         struct pci_dev* pcidev;
1231         u8 pci_bus, pci_devfn;
1232         unsigned long iomask;
1233         struct device_node* nd;
1234         struct resource* parent;
1235         struct resource *res = NULL;
1236         int nlen, plen;
1237
1238         if (index >= node->n_addrs)
1239                 goto fail;
1240
1241         /* Sanity check on bus space */
1242         iomask = bus_space_to_resource_flags(node->addrs[index].space);
1243         if (iomask & IORESOURCE_MEM)
1244                 parent = &iomem_resource;
1245         else if (iomask & IORESOURCE_IO)
1246                 parent = &ioport_resource;
1247         else
1248                 goto fail;
1249
1250         /* Find a PCI parent if any */
1251         nd = node;
1252         pcidev = NULL;
1253         while(nd) {
1254                 if (!pci_device_from_OF_node(nd, &pci_bus, &pci_devfn))
1255                         pcidev = pci_find_slot(pci_bus, pci_devfn);
1256                 if (pcidev) break;
1257                 nd = nd->parent;
1258         }
1259         if (pcidev)
1260                 parent = find_parent_pci_resource(pcidev, &node->addrs[index]);
1261         if (!parent) {
1262                 printk(KERN_WARNING "request_OF_resource(%s), parent not found\n",
1263                         node->name);
1264                 goto fail;
1265         }
1266
1267         res = __request_region(parent, node->addrs[index].address, node->addrs[index].size, NULL);
1268         if (!res)
1269                 goto fail;
1270         nlen = strlen(node->name);
1271         plen = name_postfix ? strlen(name_postfix) : 0;
1272         res->name = (const char *)kmalloc(nlen+plen+1, GFP_KERNEL);
1273         if (res->name) {
1274                 strcpy((char *)res->name, node->name);
1275                 if (plen)
1276                         strcpy((char *)res->name+nlen, name_postfix);
1277         }
1278         return res;
1279 fail:
1280         return NULL;
1281 }
1282
1283 int
1284 release_OF_resource(struct device_node* node, int index)
1285 {
1286         struct pci_dev* pcidev;
1287         u8 pci_bus, pci_devfn;
1288         unsigned long iomask, start, end;
1289         struct device_node* nd;
1290         struct resource* parent;
1291         struct resource *res = NULL;
1292
1293         if (index >= node->n_addrs)
1294                 return -EINVAL;
1295
1296         /* Sanity check on bus space */
1297         iomask = bus_space_to_resource_flags(node->addrs[index].space);
1298         if (iomask & IORESOURCE_MEM)
1299                 parent = &iomem_resource;
1300         else if (iomask & IORESOURCE_IO)
1301                 parent = &ioport_resource;
1302         else
1303                 return -EINVAL;
1304
1305         /* Find a PCI parent if any */
1306         nd = node;
1307         pcidev = NULL;
1308         while(nd) {
1309                 if (!pci_device_from_OF_node(nd, &pci_bus, &pci_devfn))
1310                         pcidev = pci_find_slot(pci_bus, pci_devfn);
1311                 if (pcidev) break;
1312                 nd = nd->parent;
1313         }
1314         if (pcidev)
1315                 parent = find_parent_pci_resource(pcidev, &node->addrs[index]);
1316         if (!parent) {
1317                 printk(KERN_WARNING "release_OF_resource(%s), parent not found\n",
1318                         node->name);
1319                 return -ENODEV;
1320         }
1321
1322         /* Find us in the parent and its childs */
1323         res = parent->child;
1324         start = node->addrs[index].address;
1325         end = start + node->addrs[index].size - 1;
1326         while (res) {
1327                 if (res->start == start && res->end == end &&
1328                     (res->flags & IORESOURCE_BUSY))
1329                         break;
1330                 if (res->start <= start && res->end >= end)
1331                         res = res->child;
1332                 else
1333                         res = res->sibling;
1334         }
1335         if (!res)
1336                 return -ENODEV;
1337
1338         kfree(res->name);
1339         res->name = NULL;
1340         release_resource(res);
1341         kfree(res);
1342
1343         return 0;
1344 }
1345
1346 #if 0
1347 void
1348 print_properties(struct device_node *np)
1349 {
1350         struct property *pp;
1351         char *cp;
1352         int i, n;
1353
1354         for (pp = np->properties; pp != 0; pp = pp->next) {
1355                 printk(KERN_INFO "%s", pp->name);
1356                 for (i = strlen(pp->name); i < 16; ++i)
1357                         printk(" ");
1358                 cp = (char *) pp->value;
1359                 for (i = pp->length; i > 0; --i, ++cp)
1360                         if ((i > 1 && (*cp < 0x20 || *cp > 0x7e))
1361                             || (i == 1 && *cp != 0))
1362                                 break;
1363                 if (i == 0 && pp->length > 1) {
1364                         /* looks like a string */
1365                         printk(" %s\n", (char *) pp->value);
1366                 } else {
1367                         /* dump it in hex */
1368                         n = pp->length;
1369                         if (n > 64)
1370                                 n = 64;
1371                         if (pp->length % 4 == 0) {
1372                                 unsigned int *p = (unsigned int *) pp->value;
1373
1374                                 n /= 4;
1375                                 for (i = 0; i < n; ++i) {
1376                                         if (i != 0 && (i % 4) == 0)
1377                                                 printk("\n                ");
1378                                         printk(" %08x", *p++);
1379                                 }
1380                         } else {
1381                                 unsigned char *bp = pp->value;
1382
1383                                 for (i = 0; i < n; ++i) {
1384                                         if (i != 0 && (i % 16) == 0)
1385                                                 printk("\n                ");
1386                                         printk(" %02x", *bp++);
1387                                 }
1388                         }
1389                         printk("\n");
1390                         if (pp->length > 64)
1391                                 printk("                 ... (length = %d)\n",
1392                                        pp->length);
1393                 }
1394         }
1395 }
1396 #endif
1397
1398 static DEFINE_SPINLOCK(rtas_lock);
1399
1400 /* this can be called after setup -- Cort */
1401 int
1402 call_rtas(const char *service, int nargs, int nret,
1403           unsigned long *outputs, ...)
1404 {
1405         va_list list;
1406         int i;
1407         unsigned long s;
1408         struct device_node *rtas;
1409         int *tokp;
1410         union {
1411                 unsigned long words[16];
1412                 double align;
1413         } u;
1414
1415         rtas = find_devices("rtas");
1416         if (rtas == NULL)
1417                 return -1;
1418         tokp = (int *) get_property(rtas, service, NULL);
1419         if (tokp == NULL) {
1420                 printk(KERN_ERR "No RTAS service called %s\n", service);
1421                 return -1;
1422         }
1423         u.words[0] = *tokp;
1424         u.words[1] = nargs;
1425         u.words[2] = nret;
1426         va_start(list, outputs);
1427         for (i = 0; i < nargs; ++i)
1428                 u.words[i+3] = va_arg(list, unsigned long);
1429         va_end(list);
1430
1431         /*
1432          * RTAS doesn't use floating point.
1433          * Or at least, according to the CHRP spec we enter RTAS
1434          * with FP disabled, and it doesn't change the FP registers.
1435          *  -- paulus.
1436          */
1437         spin_lock_irqsave(&rtas_lock, s);
1438         enter_rtas((void *)__pa(&u));
1439         spin_unlock_irqrestore(&rtas_lock, s);
1440
1441         if (nret > 1 && outputs != NULL)
1442                 for (i = 0; i < nret-1; ++i)
1443                         outputs[i] = u.words[i+nargs+4];
1444         return u.words[nargs+3];
1445 }