projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] ppc64: Save & restore of PCI device BARS
[deliverable/linux.git] / arch / powerpc / kernel / prom.c
CommitLineData
9b6b563c
PM		 1/*
2 * Procedures for creating, accessing and interpreting the device tree.
3 *
4 * Paul Mackerras August 1996.
5 * Copyright (C) 1996-2005 Paul Mackerras.
6 *
7 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
8 * {engebret|bergner}@us.ibm.com
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 */
15
16#undef DEBUG
17
18#include <stdarg.h>
19#include <linux/config.h>
20#include <linux/kernel.h>
21#include <linux/string.h>
22#include <linux/init.h>
23#include <linux/threads.h>
24#include <linux/spinlock.h>
25#include <linux/types.h>
26#include <linux/pci.h>
27#include <linux/stringify.h>
28#include <linux/delay.h>
29#include <linux/initrd.h>
30#include <linux/bitops.h>
31#include <linux/module.h>
32
33#include <asm/prom.h>
34#include <asm/rtas.h>
35#include <asm/lmb.h>
36#include <asm/page.h>
37#include <asm/processor.h>
38#include <asm/irq.h>
39#include <asm/io.h>
40#include <asm/smp.h>
41#include <asm/system.h>
42#include <asm/mmu.h>
43#include <asm/pgtable.h>
44#include <asm/pci.h>
45#include <asm/iommu.h>
46#include <asm/btext.h>
47#include <asm/sections.h>
48#include <asm/machdep.h>
49#include <asm/pSeries_reconfig.h>
40ef8cbc
PM		 50#include <asm/pci-bridge.h>
51#ifdef CONFIG_PPC64
52#include <asm/systemcfg.h>
53#endif
9b6b563c
PM		 54
55#ifdef DEBUG
56#define DBG(fmt...) printk(KERN_ERR fmt)
57#else
58#define DBG(fmt...)
59#endif
60
61struct pci_reg_property {
62 struct pci_address addr;
63 u32 size_hi;
64 u32 size_lo;
65};
66
67struct isa_reg_property {
68 u32 space;
69 u32 address;
70 u32 size;
71};
72
73
74typedef int interpret_func(struct device_node *, unsigned long *,
75 int, int, int);
76
77extern struct rtas_t rtas;
78extern struct lmb lmb;
79extern unsigned long klimit;
80
9b6b563c
PM		 81static int __initdata dt_root_addr_cells;
82static int __initdata dt_root_size_cells;
83
84#ifdef CONFIG_PPC64
85static int __initdata iommu_is_off;
86int __initdata iommu_force_on;
cf00a8d1 87unsigned long tce_alloc_start, tce_alloc_end;
9b6b563c
PM		 88#endif
89
90typedef u32 cell_t;
91
92#if 0
93static struct boot_param_header *initial_boot_params __initdata;
94#else
95struct boot_param_header *initial_boot_params;
96#endif
97
98static struct device_node *allnodes = NULL;
99
100/* use when traversing tree through the allnext, child, sibling,
101 * or parent members of struct device_node.
102 */
103static DEFINE_RWLOCK(devtree_lock);
104
105/* export that to outside world */
106struct device_node *of_chosen;
107
108struct device_node *dflt_interrupt_controller;
109int num_interrupt_controllers;
110
9b6b563c
PM		 111/*
112 * Wrapper for allocating memory for various data that needs to be
113 * attached to device nodes as they are processed at boot or when
114 * added to the device tree later (e.g. DLPAR). At boot there is
115 * already a region reserved so we just increment *mem_start by size;
116 * otherwise we call kmalloc.
117 */
118static void * prom_alloc(unsigned long size, unsigned long *mem_start)
119{
120 unsigned long tmp;
121
122 if (!mem_start)
123 return kmalloc(size, GFP_KERNEL);
124
125 tmp = *mem_start;
126 *mem_start += size;
127 return (void *)tmp;
128}
129
130/*
131 * Find the device_node with a given phandle.
132 */
133static struct device_node * find_phandle(phandle ph)
134{
135 struct device_node *np;
136
137 for (np = allnodes; np != 0; np = np->allnext)
138 if (np->linux_phandle == ph)
139 return np;
140 return NULL;
141}
142
143/*
144 * Find the interrupt parent of a node.
145 */
146static struct device_node * __devinit intr_parent(struct device_node *p)
147{
148 phandle *parp;
149
150 parp = (phandle *) get_property(p, "interrupt-parent", NULL);
151 if (parp == NULL)
152 return p->parent;
153 p = find_phandle(*parp);
154 if (p != NULL)
155 return p;
156 /*
157 * On a powermac booted with BootX, we don't get to know the
158 * phandles for any nodes, so find_phandle will return NULL.
159 * Fortunately these machines only have one interrupt controller
160 * so there isn't in fact any ambiguity. -- paulus
161 */
162 if (num_interrupt_controllers == 1)
163 p = dflt_interrupt_controller;
164 return p;
165}
166
167/*
168 * Find out the size of each entry of the interrupts property
169 * for a node.
170 */
171int __devinit prom_n_intr_cells(struct device_node *np)
172{
173 struct device_node *p;
174 unsigned int *icp;
175
176 for (p = np; (p = intr_parent(p)) != NULL; ) {
177 icp = (unsigned int *)
178 get_property(p, "#interrupt-cells", NULL);
179 if (icp != NULL)
180 return *icp;
181 if (get_property(p, "interrupt-controller", NULL) != NULL
182 || get_property(p, "interrupt-map", NULL) != NULL) {
183 printk("oops, node %s doesn't have #interrupt-cells\n",
184 p->full_name);
185 return 1;
186 }
187 }
188#ifdef DEBUG_IRQ
189 printk("prom_n_intr_cells failed for %s\n", np->full_name);
190#endif
191 return 1;
192}
193
194/*
195 * Map an interrupt from a device up to the platform interrupt
196 * descriptor.
197 */
198static int __devinit map_interrupt(unsigned int **irq, struct device_node **ictrler,
199 struct device_node *np, unsigned int *ints,
200 int nintrc)
201{
202 struct device_node *p, *ipar;
203 unsigned int *imap, *imask, *ip;
204 int i, imaplen, match;
205 int newintrc = 0, newaddrc = 0;
206 unsigned int *reg;
207 int naddrc;
208
209 reg = (unsigned int *) get_property(np, "reg", NULL);
210 naddrc = prom_n_addr_cells(np);
211 p = intr_parent(np);
212 while (p != NULL) {
213 if (get_property(p, "interrupt-controller", NULL) != NULL)
214 /* this node is an interrupt controller, stop here */
215 break;
216 imap = (unsigned int *)
217 get_property(p, "interrupt-map", &imaplen);
218 if (imap == NULL) {
219 p = intr_parent(p);
220 continue;
221 }
222 imask = (unsigned int *)
223 get_property(p, "interrupt-map-mask", NULL);
224 if (imask == NULL) {
225 printk("oops, %s has interrupt-map but no mask\n",
226 p->full_name);
227 return 0;
228 }
229 imaplen /= sizeof(unsigned int);
230 match = 0;
231 ipar = NULL;
232 while (imaplen > 0 && !match) {
233 /* check the child-interrupt field */
234 match = 1;
235 for (i = 0; i < naddrc && match; ++i)
236 match = ((reg[i] ^ imap[i]) & imask[i]) == 0;
237 for (; i < naddrc + nintrc && match; ++i)
238 match = ((ints[i-naddrc] ^ imap[i]) & imask[i]) == 0;
239 imap += naddrc + nintrc;
240 imaplen -= naddrc + nintrc;
241 /* grab the interrupt parent */
242 ipar = find_phandle((phandle) *imap++);
243 --imaplen;
244 if (ipar == NULL && num_interrupt_controllers == 1)
245 /* cope with BootX not giving us phandles */
246 ipar = dflt_interrupt_controller;
247 if (ipar == NULL) {
248 printk("oops, no int parent %x in map of %s\n",
249 imap[-1], p->full_name);
250 return 0;
251 }
252 /* find the parent's # addr and intr cells */
253 ip = (unsigned int *)
254 get_property(ipar, "#interrupt-cells", NULL);
255 if (ip == NULL) {
256 printk("oops, no #interrupt-cells on %s\n",
257 ipar->full_name);
258 return 0;
259 }
260 newintrc = *ip;
261 ip = (unsigned int *)
262 get_property(ipar, "#address-cells", NULL);
263 newaddrc = (ip == NULL)? 0: *ip;
264 imap += newaddrc + newintrc;
265 imaplen -= newaddrc + newintrc;
266 }
267 if (imaplen < 0) {
268 printk("oops, error decoding int-map on %s, len=%d\n",
269 p->full_name, imaplen);
270 return 0;
271 }
272 if (!match) {
273#ifdef DEBUG_IRQ
274 printk("oops, no match in %s int-map for %s\n",
275 p->full_name, np->full_name);
276#endif
277 return 0;
278 }
279 p = ipar;
280 naddrc = newaddrc;
281 nintrc = newintrc;
282 ints = imap - nintrc;
283 reg = ints - naddrc;
284 }
285 if (p == NULL) {
286#ifdef DEBUG_IRQ
287 printk("hmmm, int tree for %s doesn't have ctrler\n",
288 np->full_name);
289#endif
290 return 0;
291 }
292 *irq = ints;
293 *ictrler = p;
294 return nintrc;
295}
296
6d0124fc
PM		 297static unsigned char map_isa_senses[4] = {
298 IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE,
299 IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE,
300 IRQ_SENSE_EDGE | IRQ_POLARITY_NEGATIVE,
301 IRQ_SENSE_EDGE | IRQ_POLARITY_POSITIVE
302};
303
304static unsigned char map_mpic_senses[4] = {
305 IRQ_SENSE_EDGE | IRQ_POLARITY_POSITIVE,
306 IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE,
307 /* 2 seems to be used for the 8259 cascade... */
308 IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE,
309 IRQ_SENSE_EDGE | IRQ_POLARITY_NEGATIVE,
310};
311
9b6b563c
PM		 312static int __devinit finish_node_interrupts(struct device_node *np,
313 unsigned long *mem_start,
314 int measure_only)
315{
316 unsigned int *ints;
317 int intlen, intrcells, intrcount;
6d0124fc 318 int i, j, n, sense;
9b6b563c
PM		 319 unsigned int *irq, virq;
320 struct device_node *ic;
321
a575b807
PM		 322 if (num_interrupt_controllers == 0) {
323 /*
324 * Old machines just have a list of interrupt numbers
325 * and no interrupt-controller nodes.
326 */
327 ints = (unsigned int *) get_property(np, "AAPL,interrupts",
328 &intlen);
329 /* XXX old interpret_pci_props looked in parent too */
330 /* XXX old interpret_macio_props looked for interrupts
331 before AAPL,interrupts */
332 if (ints == NULL)
333 ints = (unsigned int *) get_property(np, "interrupts",
334 &intlen);
335 if (ints == NULL)
336 return 0;
337
338 np->n_intrs = intlen / sizeof(unsigned int);
339 np->intrs = prom_alloc(np->n_intrs * sizeof(np->intrs[0]),
340 mem_start);
341 if (!np->intrs)
342 return -ENOMEM;
343 if (measure_only)
344 return 0;
345
346 for (i = 0; i < np->n_intrs; ++i) {
347 np->intrs[i].line = *ints++;
6d0124fc
PM		 348 np->intrs[i].sense = IRQ_SENSE_LEVEL
349 | IRQ_POLARITY_NEGATIVE;
a575b807
PM		 350 }
351 return 0;
352 }
353
9b6b563c
PM		 354 ints = (unsigned int *) get_property(np, "interrupts", &intlen);
355 if (ints == NULL)
356 return 0;
357 intrcells = prom_n_intr_cells(np);
358 intlen /= intrcells * sizeof(unsigned int);
359
360 np->intrs = prom_alloc(intlen * sizeof(*(np->intrs)), mem_start);
361 if (!np->intrs)
362 return -ENOMEM;
363
364 if (measure_only)
365 return 0;
366
367 intrcount = 0;
368 for (i = 0; i < intlen; ++i, ints += intrcells) {
369 n = map_interrupt(&irq, &ic, np, ints, intrcells);
370 if (n <= 0)
371 continue;
372
373 /* don't map IRQ numbers under a cascaded 8259 controller */
374 if (ic && device_is_compatible(ic, "chrp,iic")) {
375 np->intrs[intrcount].line = irq[0];
6d0124fc
PM		 376 sense = (n > 1)? (irq[1] & 3): 3;
377 np->intrs[intrcount].sense = map_isa_senses[sense];
9b6b563c 378 } else {
9b6b563c 379 virq = virt_irq_create_mapping(irq[0]);
6d0124fc 380#ifdef CONFIG_PPC64
9b6b563c
PM		 381 if (virq == NO_IRQ) {
382 printk(KERN_CRIT "Could not allocate interrupt"
383 " number for %s\n", np->full_name);
384 continue;
385 }
9b6b563c 386#endif
6d0124fc
PM		 387 np->intrs[intrcount].line = irq_offset_up(virq);
388 sense = (n > 1)? (irq[1] & 3): 1;
389 np->intrs[intrcount].sense = map_mpic_senses[sense];
9b6b563c
PM		 390 }
391
392#ifdef CONFIG_PPC64
393 /* We offset irq numbers for the u3 MPIC by 128 in PowerMac */
394 if (systemcfg->platform == PLATFORM_POWERMAC && ic && ic->parent) {
395 char *name = get_property(ic->parent, "name", NULL);
396 if (name && !strcmp(name, "u3"))
397 np->intrs[intrcount].line += 128;
398 else if (!(name && !strcmp(name, "mac-io")))
399 /* ignore other cascaded controllers, such as
400 the k2-sata-root */
401 break;
402 }
403#endif
9b6b563c
PM		 404 if (n > 2) {
405 printk("hmmm, got %d intr cells for %s:", n,
406 np->full_name);
407 for (j = 0; j < n; ++j)
408 printk(" %d", irq[j]);
409 printk("\n");
410 }
411 ++intrcount;
412 }
413 np->n_intrs = intrcount;
414
415 return 0;
416}
417
418static int __devinit interpret_pci_props(struct device_node *np,
419 unsigned long *mem_start,
420 int naddrc, int nsizec,
421 int measure_only)
422{
423 struct address_range *adr;
424 struct pci_reg_property *pci_addrs;
425 int i, l, n_addrs;
426
427 pci_addrs = (struct pci_reg_property *)
428 get_property(np, "assigned-addresses", &l);
429 if (!pci_addrs)
430 return 0;
431
432 n_addrs = l / sizeof(*pci_addrs);
433
434 adr = prom_alloc(n_addrs * sizeof(*adr), mem_start);
435 if (!adr)
436 return -ENOMEM;
437
438 if (measure_only)
439 return 0;
440
441 np->addrs = adr;
442 np->n_addrs = n_addrs;
443
444 for (i = 0; i < n_addrs; i++) {
445 adr[i].space = pci_addrs[i].addr.a_hi;
446 adr[i].address = pci_addrs[i].addr.a_lo |
447 ((u64)pci_addrs[i].addr.a_mid << 32);
448 adr[i].size = pci_addrs[i].size_lo;
449 }
450
451 return 0;
452}
453
454static int __init interpret_dbdma_props(struct device_node *np,
455 unsigned long *mem_start,
456 int naddrc, int nsizec,
457 int measure_only)
458{
459 struct reg_property32 *rp;
460 struct address_range *adr;
461 unsigned long base_address;
462 int i, l;
463 struct device_node *db;
464
465 base_address = 0;
466 if (!measure_only) {
467 for (db = np->parent; db != NULL; db = db->parent) {
468 if (!strcmp(db->type, "dbdma") && db->n_addrs != 0) {
469 base_address = db->addrs[0].address;
470 break;
471 }
472 }
473 }
474
475 rp = (struct reg_property32 *) get_property(np, "reg", &l);
476 if (rp != 0 && l >= sizeof(struct reg_property32)) {
477 i = 0;
478 adr = (struct address_range *) (*mem_start);
479 while ((l -= sizeof(struct reg_property32)) >= 0) {
480 if (!measure_only) {
481 adr[i].space = 2;
482 adr[i].address = rp[i].address + base_address;
483 adr[i].size = rp[i].size;
484 }
485 ++i;
486 }
487 np->addrs = adr;
488 np->n_addrs = i;
489 (*mem_start) += i * sizeof(struct address_range);
490 }
491
492 return 0;
493}
494
495static int __init interpret_macio_props(struct device_node *np,
496 unsigned long *mem_start,
497 int naddrc, int nsizec,
498 int measure_only)
499{
500 struct reg_property32 *rp;
501 struct address_range *adr;
502 unsigned long base_address;
503 int i, l;
504 struct device_node *db;
505
506 base_address = 0;
507 if (!measure_only) {
508 for (db = np->parent; db != NULL; db = db->parent) {
509 if (!strcmp(db->type, "mac-io") && db->n_addrs != 0) {
510 base_address = db->addrs[0].address;
511 break;
512 }
513 }
514 }
515
516 rp = (struct reg_property32 *) get_property(np, "reg", &l);
517 if (rp != 0 && l >= sizeof(struct reg_property32)) {
518 i = 0;
519 adr = (struct address_range *) (*mem_start);
520 while ((l -= sizeof(struct reg_property32)) >= 0) {
521 if (!measure_only) {
522 adr[i].space = 2;
523 adr[i].address = rp[i].address + base_address;
524 adr[i].size = rp[i].size;
525 }
526 ++i;
527 }
528 np->addrs = adr;
529 np->n_addrs = i;
530 (*mem_start) += i * sizeof(struct address_range);
531 }
532
533 return 0;
534}
535
536static int __init interpret_isa_props(struct device_node *np,
537 unsigned long *mem_start,
538 int naddrc, int nsizec,
539 int measure_only)
540{
541 struct isa_reg_property *rp;
542 struct address_range *adr;
543 int i, l;
544
545 rp = (struct isa_reg_property *) get_property(np, "reg", &l);
546 if (rp != 0 && l >= sizeof(struct isa_reg_property)) {
547 i = 0;
548 adr = (struct address_range *) (*mem_start);
549 while ((l -= sizeof(struct isa_reg_property)) >= 0) {
550 if (!measure_only) {
551 adr[i].space = rp[i].space;
552 adr[i].address = rp[i].address;
553 adr[i].size = rp[i].size;
554 }
555 ++i;
556 }
557 np->addrs = adr;
558 np->n_addrs = i;
559 (*mem_start) += i * sizeof(struct address_range);
560 }
561
562 return 0;
563}
564
565static int __init interpret_root_props(struct device_node *np,
566 unsigned long *mem_start,
567 int naddrc, int nsizec,
568 int measure_only)
569{
570 struct address_range *adr;
571 int i, l;
572 unsigned int *rp;
573 int rpsize = (naddrc + nsizec) * sizeof(unsigned int);
574
575 rp = (unsigned int *) get_property(np, "reg", &l);
576 if (rp != 0 && l >= rpsize) {
577 i = 0;
578 adr = (struct address_range *) (*mem_start);
579 while ((l -= rpsize) >= 0) {
580 if (!measure_only) {
581 adr[i].space = 0;
582 adr[i].address = rp[naddrc - 1];
583 adr[i].size = rp[naddrc + nsizec - 1];
584 }
585 ++i;
586 rp += naddrc + nsizec;
587 }
588 np->addrs = adr;
589 np->n_addrs = i;
590 (*mem_start) += i * sizeof(struct address_range);
591 }
592
593 return 0;
594}
595
596static int __devinit finish_node(struct device_node *np,
597 unsigned long *mem_start,
598 interpret_func *ifunc,
599 int naddrc, int nsizec,
600 int measure_only)
601{
602 struct device_node *child;
603 int *ip, rc = 0;
604
605 /* get the device addresses and interrupts */
606 if (ifunc != NULL)
607 rc = ifunc(np, mem_start, naddrc, nsizec, measure_only);
608 if (rc)
609 goto out;
610
611 rc = finish_node_interrupts(np, mem_start, measure_only);
612 if (rc)
613 goto out;
614
615 /* Look for #address-cells and #size-cells properties. */
616 ip = (int *) get_property(np, "#address-cells", NULL);
617 if (ip != NULL)
618 naddrc = *ip;
619 ip = (int *) get_property(np, "#size-cells", NULL);
620 if (ip != NULL)
621 nsizec = *ip;
622
623 if (!strcmp(np->name, "device-tree") || np->parent == NULL)
624 ifunc = interpret_root_props;
625 else if (np->type == 0)
626 ifunc = NULL;
627 else if (!strcmp(np->type, "pci") || !strcmp(np->type, "vci"))
628 ifunc = interpret_pci_props;
629 else if (!strcmp(np->type, "dbdma"))
630 ifunc = interpret_dbdma_props;
631 else if (!strcmp(np->type, "mac-io") || ifunc == interpret_macio_props)
632 ifunc = interpret_macio_props;
633 else if (!strcmp(np->type, "isa"))
634 ifunc = interpret_isa_props;
635 else if (!strcmp(np->name, "uni-n") || !strcmp(np->name, "u3"))
636 ifunc = interpret_root_props;
637 else if (!((ifunc == interpret_dbdma_props
638 || ifunc == interpret_macio_props)
639 && (!strcmp(np->type, "escc")
640 || !strcmp(np->type, "media-bay"))))
641 ifunc = NULL;
642
643 for (child = np->child; child != NULL; child = child->sibling) {
644 rc = finish_node(child, mem_start, ifunc,
645 naddrc, nsizec, measure_only);
646 if (rc)
647 goto out;
648 }
649out:
650 return rc;
651}
652
653static void __init scan_interrupt_controllers(void)
654{
655 struct device_node *np;
656 int n = 0;
657 char *name, *ic;
658 int iclen;
659
660 for (np = allnodes; np != NULL; np = np->allnext) {
661 ic = get_property(np, "interrupt-controller", &iclen);
662 name = get_property(np, "name", NULL);
663 /* checking iclen makes sure we don't get a false
664 match on /chosen.interrupt_controller */
665 if ((name != NULL
666 && strcmp(name, "interrupt-controller") == 0)
667 || (ic != NULL && iclen == 0
668 && strcmp(name, "AppleKiwi"))) {
669 if (n == 0)
670 dflt_interrupt_controller = np;
671 ++n;
672 }
673 }
674 num_interrupt_controllers = n;
675}
676
677/**
678 * finish_device_tree is called once things are running normally
679 * (i.e. with text and data mapped to the address they were linked at).
680 * It traverses the device tree and fills in some of the additional,
681 * fields in each node like {n_}addrs and {n_}intrs, the virt interrupt
682 * mapping is also initialized at this point.
683 */
684void __init finish_device_tree(void)
685{
686 unsigned long start, end, size = 0;
687
688 DBG(" -> finish_device_tree\n");
689
690#ifdef CONFIG_PPC64
691 /* Initialize virtual IRQ map */
692 virt_irq_init();
693#endif
694 scan_interrupt_controllers();
695
696 /*
697 * Finish device-tree (pre-parsing some properties etc...)
698 * We do this in 2 passes. One with "measure_only" set, which
699 * will only measure the amount of memory needed, then we can
700 * allocate that memory, and call finish_node again. However,
701 * we must be careful as most routines will fail nowadays when
702 * prom_alloc() returns 0, so we must make sure our first pass
703 * doesn't start at 0. We pre-initialize size to 16 for that
704 * reason and then remove those additional 16 bytes
705 */
706 size = 16;
707 finish_node(allnodes, &size, NULL, 0, 0, 1);
708 size -= 16;
709 end = start = (unsigned long) __va(lmb_alloc(size, 128));
710 finish_node(allnodes, &end, NULL, 0, 0, 0);
711 BUG_ON(end != start + size);
712
713 DBG(" <- finish_device_tree\n");
714}
715
716static inline char *find_flat_dt_string(u32 offset)
717{
718 return ((char *)initial_boot_params) +
719 initial_boot_params->off_dt_strings + offset;
720}
721
722/**
723 * This function is used to scan the flattened device-tree, it is
724 * used to extract the memory informations at boot before we can
725 * unflatten the tree
726 */
3c726f8d
BH		 727int __init of_scan_flat_dt(int (*it)(unsigned long node,
728 const char *uname, int depth,
729 void *data),
730 void *data)
9b6b563c
PM		 731{
732 unsigned long p = ((unsigned long)initial_boot_params) +
733 initial_boot_params->off_dt_struct;
734 int rc = 0;
735 int depth = -1;
736
737 do {
738 u32 tag = *((u32 *)p);
739 char *pathp;
740
741 p += 4;
742 if (tag == OF_DT_END_NODE) {
743 depth --;
744 continue;
745 }
746 if (tag == OF_DT_NOP)
747 continue;
748 if (tag == OF_DT_END)
749 break;
750 if (tag == OF_DT_PROP) {
751 u32 sz = *((u32 *)p);
752 p += 8;
753 if (initial_boot_params->version < 0x10)
754 p = _ALIGN(p, sz >= 8 ? 8 : 4);
755 p += sz;
756 p = _ALIGN(p, 4);
757 continue;
758 }
759 if (tag != OF_DT_BEGIN_NODE) {
760 printk(KERN_WARNING "Invalid tag %x scanning flattened"
761 " device tree !\n", tag);
762 return -EINVAL;
763 }
764 depth++;
765 pathp = (char *)p;
766 p = _ALIGN(p + strlen(pathp) + 1, 4);
767 if ((*pathp) == '/') {
768 char *lp, *np;
769 for (lp = NULL, np = pathp; *np; np++)
770 if ((*np) == '/')
771 lp = np+1;
772 if (lp != NULL)
773 pathp = lp;
774 }
775 rc = it(p, pathp, depth, data);
776 if (rc != 0)
777 break;
778 } while(1);
779
780 return rc;
781}
782
783/**
784 * This function can be used within scan_flattened_dt callback to get
785 * access to properties
786 */
3c726f8d
BH		 787void* __init of_get_flat_dt_prop(unsigned long node, const char *name,
788 unsigned long *size)
9b6b563c
PM		 789{
790 unsigned long p = node;
791
792 do {
793 u32 tag = *((u32 *)p);
794 u32 sz, noff;
795 const char *nstr;
796
797 p += 4;
798 if (tag == OF_DT_NOP)
799 continue;
800 if (tag != OF_DT_PROP)
801 return NULL;
802
803 sz = *((u32 *)p);
804 noff = *((u32 *)(p + 4));
805 p += 8;
806 if (initial_boot_params->version < 0x10)
807 p = _ALIGN(p, sz >= 8 ? 8 : 4);
808
809 nstr = find_flat_dt_string(noff);
810 if (nstr == NULL) {
811 printk(KERN_WARNING "Can't find property index"
812 " name !\n");
813 return NULL;
814 }
815 if (strcmp(name, nstr) == 0) {
816 if (size)
817 *size = sz;
818 return (void *)p;
819 }
820 p += sz;
821 p = _ALIGN(p, 4);
822 } while(1);
823}
824
825static void *__init unflatten_dt_alloc(unsigned long *mem, unsigned long size,
826 unsigned long align)
827{
828 void *res;
829
830 *mem = _ALIGN(*mem, align);
831 res = (void *)*mem;
832 *mem += size;
833
834 return res;
835}
836
837static unsigned long __init unflatten_dt_node(unsigned long mem,
838 unsigned long *p,
839 struct device_node *dad,
840 struct device_node ***allnextpp,
841 unsigned long fpsize)
842{
843 struct device_node *np;
844 struct property *pp, **prev_pp = NULL;
845 char *pathp;
846 u32 tag;
847 unsigned int l, allocl;
848 int has_name = 0;
849 int new_format = 0;
850
851 tag = *((u32 *)(*p));
852 if (tag != OF_DT_BEGIN_NODE) {
853 printk("Weird tag at start of node: %x\n", tag);
854 return mem;
855 }
856 *p += 4;
857 pathp = (char *)*p;
858 l = allocl = strlen(pathp) + 1;
859 *p = _ALIGN(*p + l, 4);
860
861 /* version 0x10 has a more compact unit name here instead of the full
862 * path. we accumulate the full path size using "fpsize", we'll rebuild
863 * it later. We detect this because the first character of the name is
864 * not '/'.
865 */
866 if ((*pathp) != '/') {
867 new_format = 1;
868 if (fpsize == 0) {
869 /* root node: special case. fpsize accounts for path
870 * plus terminating zero. root node only has '/', so
871 * fpsize should be 2, but we want to avoid the first
872 * level nodes to have two '/' so we use fpsize 1 here
873 */
874 fpsize = 1;
875 allocl = 2;
876 } else {
877 /* account for '/' and path size minus terminal 0
878 * already in 'l'
879 */
880 fpsize += l;
881 allocl = fpsize;
882 }
883 }
884
885
886 np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
887 __alignof__(struct device_node));
888 if (allnextpp) {
889 memset(np, 0, sizeof(*np));
890 np->full_name = ((char*)np) + sizeof(struct device_node);
891 if (new_format) {
892 char *p = np->full_name;
893 /* rebuild full path for new format */
894 if (dad && dad->parent) {
895 strcpy(p, dad->full_name);
896#ifdef DEBUG
897 if ((strlen(p) + l + 1) != allocl) {
898 DBG("%s: p: %d, l: %d, a: %d\n",
899 pathp, strlen(p), l, allocl);
900 }
901#endif
902 p += strlen(p);
903 }
904 *(p++) = '/';
905 memcpy(p, pathp, l);
906 } else
907 memcpy(np->full_name, pathp, l);
908 prev_pp = &np->properties;
909 **allnextpp = np;
910 *allnextpp = &np->allnext;
911 if (dad != NULL) {
912 np->parent = dad;
913 /* we temporarily use the next field as `last_child'*/
914 if (dad->next == 0)
915 dad->child = np;
916 else
917 dad->next->sibling = np;
918 dad->next = np;
919 }
920 kref_init(&np->kref);
921 }
922 while(1) {
923 u32 sz, noff;
924 char *pname;
925
926 tag = *((u32 *)(*p));
927 if (tag == OF_DT_NOP) {
928 *p += 4;
929 continue;
930 }
931 if (tag != OF_DT_PROP)
932 break;
933 *p += 4;
934 sz = *((u32 *)(*p));
935 noff = *((u32 *)((*p) + 4));
936 *p += 8;
937 if (initial_boot_params->version < 0x10)
938 *p = _ALIGN(*p, sz >= 8 ? 8 : 4);
939
940 pname = find_flat_dt_string(noff);
941 if (pname == NULL) {
942 printk("Can't find property name in list !\n");
943 break;
944 }
945 if (strcmp(pname, "name") == 0)
946 has_name = 1;
947 l = strlen(pname) + 1;
948 pp = unflatten_dt_alloc(&mem, sizeof(struct property),
949 __alignof__(struct property));
950 if (allnextpp) {
951 if (strcmp(pname, "linux,phandle") == 0) {
952 np->node = *((u32 *)*p);
953 if (np->linux_phandle == 0)
954 np->linux_phandle = np->node;
955 }
956 if (strcmp(pname, "ibm,phandle") == 0)
957 np->linux_phandle = *((u32 *)*p);
958 pp->name = pname;
959 pp->length = sz;
960 pp->value = (void *)*p;
961 *prev_pp = pp;
962 prev_pp = &pp->next;
963 }
964 *p = _ALIGN((*p) + sz, 4);
965 }
966 /* with version 0x10 we may not have the name property, recreate
967 * it here from the unit name if absent
968 */
969 if (!has_name) {
970 char *p = pathp, *ps = pathp, *pa = NULL;
971 int sz;
972
973 while (*p) {
974 if ((*p) == '@')
975 pa = p;
976 if ((*p) == '/')
977 ps = p + 1;
978 p++;
979 }
980 if (pa < ps)
981 pa = p;
982 sz = (pa - ps) + 1;
983 pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
984 __alignof__(struct property));
985 if (allnextpp) {
986 pp->name = "name";
987 pp->length = sz;
988 pp->value = (unsigned char *)(pp + 1);
989 *prev_pp = pp;
990 prev_pp = &pp->next;
991 memcpy(pp->value, ps, sz - 1);
992 ((char *)pp->value)[sz - 1] = 0;
993 DBG("fixed up name for %s -> %s\n", pathp, pp->value);
994 }
995 }
996 if (allnextpp) {
997 *prev_pp = NULL;
998 np->name = get_property(np, "name", NULL);
999 np->type = get_property(np, "device_type", NULL);
1000
1001 if (!np->name)
1002 np->name = "<NULL>";
1003 if (!np->type)
1004 np->type = "<NULL>";
1005 }
1006 while (tag == OF_DT_BEGIN_NODE) {
1007 mem = unflatten_dt_node(mem, p, np, allnextpp, fpsize);
1008 tag = *((u32 *)(*p));
1009 }
1010 if (tag != OF_DT_END_NODE) {
1011 printk("Weird tag at end of node: %x\n", tag);
1012 return mem;
1013 }
1014 *p += 4;
1015 return mem;
1016}
1017
1018
1019/**
1020 * unflattens the device-tree passed by the firmware, creating the
1021 * tree of struct device_node. It also fills the "name" and "type"
1022 * pointers of the nodes so the normal device-tree walking functions
1023 * can be used (this used to be done by finish_device_tree)
1024 */
1025void __init unflatten_device_tree(void)
1026{
1027 unsigned long start, mem, size;
1028 struct device_node **allnextp = &allnodes;
1029 char *p = NULL;
1030 int l = 0;
1031
1032 DBG(" -> unflatten_device_tree()\n");
1033
1034 /* First pass, scan for size */
1035 start = ((unsigned long)initial_boot_params) +
1036 initial_boot_params->off_dt_struct;
1037 size = unflatten_dt_node(0, &start, NULL, NULL, 0);
1038 size = (size | 3) + 1;
1039
1040 DBG(" size is %lx, allocating...\n", size);
1041
1042 /* Allocate memory for the expanded device tree */
1043 mem = lmb_alloc(size + 4, __alignof__(struct device_node));
1044 if (!mem) {
1045 DBG("Couldn't allocate memory with lmb_alloc()!\n");
1046 panic("Couldn't allocate memory with lmb_alloc()!\n");
1047 }
1048 mem = (unsigned long) __va(mem);
1049
1050 ((u32 *)mem)[size / 4] = 0xdeadbeef;
1051
1052 DBG(" unflattening %lx...\n", mem);
1053
1054 /* Second pass, do actual unflattening */
1055 start = ((unsigned long)initial_boot_params) +
1056 initial_boot_params->off_dt_struct;
1057 unflatten_dt_node(mem, &start, NULL, &allnextp, 0);
1058 if (*((u32 *)start) != OF_DT_END)
1059 printk(KERN_WARNING "Weird tag at end of tree: %08x\n", *((u32 *)start));
1060 if (((u32 *)mem)[size / 4] != 0xdeadbeef)
1061 printk(KERN_WARNING "End of tree marker overwritten: %08x\n",
1062 ((u32 *)mem)[size / 4] );
1063 *allnextp = NULL;
1064
1065 /* Get pointer to OF "/chosen" node for use everywhere */
1066 of_chosen = of_find_node_by_path("/chosen");
a575b807
PM		 1067 if (of_chosen == NULL)
1068 of_chosen = of_find_node_by_path("/chosen@0");
9b6b563c
PM		 1069
1070 /* Retreive command line */
1071 if (of_chosen != NULL) {
1072 p = (char *)get_property(of_chosen, "bootargs", &l);
1073 if (p != NULL && l > 0)
1074 strlcpy(cmd_line, p, min(l, COMMAND_LINE_SIZE));
1075 }
1076#ifdef CONFIG_CMDLINE
1077 if (l == 0 || (l == 1 && (*p) == 0))
1078 strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
1079#endif /* CONFIG_CMDLINE */
1080
1081 DBG("Command line is: %s\n", cmd_line);
1082
1083 DBG(" <- unflatten_device_tree()\n");
1084}
1085
1086
1087static int __init early_init_dt_scan_cpus(unsigned long node,
1088 const char *uname, int depth, void *data)
1089{
3c726f8d 1090 char *type = of_get_flat_dt_prop(node, "device_type", NULL);
9b6b563c
PM		 1091 u32 *prop;
1092 unsigned long size = 0;
1093
1094 /* We are scanning "cpu" nodes only */
1095 if (type == NULL || strcmp(type, "cpu") != 0)
1096 return 0;
1097
80579e1f
PM		 1098 boot_cpuid = 0;
1099 boot_cpuid_phys = 0;
9b6b563c
PM		 1100 if (initial_boot_params && initial_boot_params->version >= 2) {
1101 /* version 2 of the kexec param format adds the phys cpuid
1102 * of booted proc.
1103 */
1104 boot_cpuid_phys = initial_boot_params->boot_cpuid_phys;
9b6b563c 1105 } else {
80579e1f 1106 /* Check if it's the boot-cpu, set it's hw index now */
3c726f8d
BH		 1107 if (of_get_flat_dt_prop(node,
1108 "linux,boot-cpu", NULL) != NULL) {
1109 prop = of_get_flat_dt_prop(node, "reg", NULL);
80579e1f
PM		 1110 if (prop != NULL)
1111 boot_cpuid_phys = *prop;
9b6b563c
PM		 1112 }
1113 }
80579e1f 1114 set_hard_smp_processor_id(0, boot_cpuid_phys);
9b6b563c
PM		 1115
1116#ifdef CONFIG_ALTIVEC
1117 /* Check if we have a VMX and eventually update CPU features */
3c726f8d 1118 prop = (u32 *)of_get_flat_dt_prop(node, "ibm,vmx", &size);
9b6b563c
PM		 1119 if (prop && (*prop) > 0) {
1120 cur_cpu_spec->cpu_features |= CPU_FTR_ALTIVEC;
1121 cur_cpu_spec->cpu_user_features |= PPC_FEATURE_HAS_ALTIVEC;
1122 }
1123
1124 /* Same goes for Apple's "altivec" property */
3c726f8d 1125 prop = (u32 *)of_get_flat_dt_prop(node, "altivec", NULL);
9b6b563c
PM		 1126 if (prop) {
1127 cur_cpu_spec->cpu_features |= CPU_FTR_ALTIVEC;
1128 cur_cpu_spec->cpu_user_features |= PPC_FEATURE_HAS_ALTIVEC;
1129 }
1130#endif /* CONFIG_ALTIVEC */
1131
1132#ifdef CONFIG_PPC_PSERIES
1133 /*
1134 * Check for an SMT capable CPU and set the CPU feature. We do
1135 * this by looking at the size of the ibm,ppc-interrupt-server#s
1136 * property
1137 */
3c726f8d 1138 prop = (u32 *)of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s",
9b6b563c
PM		 1139 &size);
1140 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT;
1141 if (prop && ((size / sizeof(u32)) > 1))
1142 cur_cpu_spec->cpu_features |= CPU_FTR_SMT;
1143#endif
1144
1145 return 0;
1146}
1147
1148static int __init early_init_dt_scan_chosen(unsigned long node,
1149 const char *uname, int depth, void *data)
1150{
1151 u32 *prop;
1152 unsigned long *lprop;
1153
1154 DBG("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
1155
a575b807
PM		 1156 if (depth != 1 ||
1157 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
9b6b563c
PM		 1158 return 0;
1159
1160 /* get platform type */
3c726f8d 1161 prop = (u32 *)of_get_flat_dt_prop(node, "linux,platform", NULL);
9b6b563c
PM		 1162 if (prop == NULL)
1163 return 0;
1164#ifdef CONFIG_PPC64
1165 systemcfg->platform = *prop;
1166#else
60dda256 1167#ifdef CONFIG_PPC_MULTIPLATFORM
9b6b563c
PM		 1168 _machine = *prop;
1169#endif
60dda256 1170#endif
9b6b563c
PM		 1171
1172#ifdef CONFIG_PPC64
1173 /* check if iommu is forced on or off */
3c726f8d 1174 if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL)
9b6b563c 1175 iommu_is_off = 1;
3c726f8d 1176 if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL)
9b6b563c
PM		 1177 iommu_force_on = 1;
1178#endif
1179
3c726f8d 1180 lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL);
9b6b563c
PM		 1181 if (lprop)
1182 memory_limit = *lprop;
1183
1184#ifdef CONFIG_PPC64
3c726f8d 1185 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL);
9b6b563c
PM		 1186 if (lprop)
1187 tce_alloc_start = *lprop;
3c726f8d 1188 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL);
9b6b563c
PM		 1189 if (lprop)
1190 tce_alloc_end = *lprop;
1191#endif
1192
1193#ifdef CONFIG_PPC_RTAS
1194 /* To help early debugging via the front panel, we retreive a minimal
1195 * set of RTAS infos now if available
1196 */
1197 {
1198 u64 *basep, *entryp;
1199
3c726f8d
BH		 1200 basep = of_get_flat_dt_prop(node, "linux,rtas-base", NULL);
1201 entryp = of_get_flat_dt_prop(node, "linux,rtas-entry", NULL);
1202 prop = of_get_flat_dt_prop(node, "linux,rtas-size", NULL);
9b6b563c
PM		 1203 if (basep && entryp && prop) {
1204 rtas.base = *basep;
1205 rtas.entry = *entryp;
1206 rtas.size = *prop;
1207 }
1208 }
1209#endif /* CONFIG_PPC_RTAS */
1210
1211 /* break now */
1212 return 1;
1213}
1214
1215static int __init early_init_dt_scan_root(unsigned long node,
1216 const char *uname, int depth, void *data)
1217{
1218 u32 *prop;
1219
1220 if (depth != 0)
1221 return 0;
1222
3c726f8d 1223 prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
9b6b563c
PM		 1224 dt_root_size_cells = (prop == NULL) ? 1 : *prop;
1225 DBG("dt_root_size_cells = %x\n", dt_root_size_cells);
1226
3c726f8d 1227 prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
9b6b563c
PM		 1228 dt_root_addr_cells = (prop == NULL) ? 2 : *prop;
1229 DBG("dt_root_addr_cells = %x\n", dt_root_addr_cells);
1230
1231 /* break now */
1232 return 1;
1233}
1234
1235static unsigned long __init dt_mem_next_cell(int s, cell_t **cellp)
1236{
1237 cell_t *p = *cellp;
1238 unsigned long r;
1239
1240 /* Ignore more than 2 cells */
1241 while (s > sizeof(unsigned long) / 4) {
1242 p++;
1243 s--;
1244 }
1245 r = *p++;
1246#ifdef CONFIG_PPC64
1247 if (s > 1) {
1248 r <<= 32;
1249 r |= *(p++);
1250 s--;
1251 }
1252#endif
1253
1254 *cellp = p;
1255 return r;
1256}
1257
1258
1259static int __init early_init_dt_scan_memory(unsigned long node,
1260 const char *uname, int depth, void *data)
1261{
3c726f8d 1262 char *type = of_get_flat_dt_prop(node, "device_type", NULL);
9b6b563c
PM		 1263 cell_t *reg, *endp;
1264 unsigned long l;
1265
1266 /* We are scanning "memory" nodes only */
1267 if (type == NULL || strcmp(type, "memory") != 0)
1268 return 0;
1269
3c726f8d 1270 reg = (cell_t *)of_get_flat_dt_prop(node, "reg", &l);
9b6b563c
PM		 1271 if (reg == NULL)
1272 return 0;
1273
1274 endp = reg + (l / sizeof(cell_t));
1275
358c86fd 1276 DBG("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
9b6b563c
PM		 1277 uname, l, reg[0], reg[1], reg[2], reg[3]);
1278
1279 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
1280 unsigned long base, size;
1281
1282 base = dt_mem_next_cell(dt_root_addr_cells, &reg);
1283 size = dt_mem_next_cell(dt_root_size_cells, &reg);
1284
1285 if (size == 0)
1286 continue;
1287 DBG(" - %lx , %lx\n", base, size);
1288#ifdef CONFIG_PPC64
1289 if (iommu_is_off) {
1290 if (base >= 0x80000000ul)
1291 continue;
1292 if ((base + size) > 0x80000000ul)
1293 size = 0x80000000ul - base;
1294 }
1295#endif
1296 lmb_add(base, size);
1297 }
1298 return 0;
1299}
1300
1301static void __init early_reserve_mem(void)
1302{
1303 unsigned long base, size;
1304 unsigned long *reserve_map;
1305
1306 reserve_map = (unsigned long *)(((unsigned long)initial_boot_params) +
1307 initial_boot_params->off_mem_rsvmap);
1308 while (1) {
1309 base = *(reserve_map++);
1310 size = *(reserve_map++);
1311 if (size == 0)
1312 break;
1313 DBG("reserving: %lx -> %lx\n", base, size);
1314 lmb_reserve(base, size);
1315 }
1316
1317#if 0
1318 DBG("memory reserved, lmbs :\n");
1319 lmb_dump_all();
1320#endif
1321}
1322
1323void __init early_init_devtree(void *params)
1324{
1325 DBG(" -> early_init_devtree()\n");
1326
1327 /* Setup flat device-tree pointer */
1328 initial_boot_params = params;
1329
1330 /* Retrieve various informations from the /chosen node of the
1331 * device-tree, including the platform type, initrd location and
1332 * size, TCE reserve, and more ...
1333 */
3c726f8d 1334 of_scan_flat_dt(early_init_dt_scan_chosen, NULL);
9b6b563c
PM		 1335
1336 /* Scan memory nodes and rebuild LMBs */
1337 lmb_init();
3c726f8d
BH		 1338 of_scan_flat_dt(early_init_dt_scan_root, NULL);
1339 of_scan_flat_dt(early_init_dt_scan_memory, NULL);
9b6b563c
PM		 1340 lmb_enforce_memory_limit(memory_limit);
1341 lmb_analyze();
1342#ifdef CONFIG_PPC64
1343 systemcfg->physicalMemorySize = lmb_phys_mem_size();
1344#endif
1345 lmb_reserve(0, __pa(klimit));
1346
1347 DBG("Phys. mem: %lx\n", lmb_phys_mem_size());
1348
1349 /* Reserve LMB regions used by kernel, initrd, dt, etc... */
1350 early_reserve_mem();
1351
1352 DBG("Scanning CPUs ...\n");
1353
3c726f8d
BH		 1354 /* Retreive CPU related informations from the flat tree
1355 * (altivec support, boot CPU ID, ...)
9b6b563c 1356 */
3c726f8d 1357 of_scan_flat_dt(early_init_dt_scan_cpus, NULL);
9b6b563c 1358
9b6b563c
PM		 1359 DBG(" <- early_init_devtree()\n");
1360}
1361
1362#undef printk
1363
1364int
1365prom_n_addr_cells(struct device_node* np)
1366{
1367 int* ip;
1368 do {
1369 if (np->parent)
1370 np = np->parent;
1371 ip = (int *) get_property(np, "#address-cells", NULL);
1372 if (ip != NULL)
1373 return *ip;
1374 } while (np->parent);
1375 /* No #address-cells property for the root node, default to 1 */
1376 return 1;
1377}
1378
1379int
1380prom_n_size_cells(struct device_node* np)
1381{
1382 int* ip;
1383 do {
1384 if (np->parent)
1385 np = np->parent;
1386 ip = (int *) get_property(np, "#size-cells", NULL);
1387 if (ip != NULL)
1388 return *ip;
1389 } while (np->parent);
1390 /* No #size-cells property for the root node, default to 1 */
1391 return 1;
1392}
1393
1394/**
1395 * Work out the sense (active-low level / active-high edge)
1396 * of each interrupt from the device tree.
1397 */
1398void __init prom_get_irq_senses(unsigned char *senses, int off, int max)
1399{
1400 struct device_node *np;
1401 int i, j;
1402
1403 /* default to level-triggered */
6d0124fc 1404 memset(senses, IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE, max - off);
9b6b563c
PM		 1405
1406 for (np = allnodes; np != 0; np = np->allnext) {
1407 for (j = 0; j < np->n_intrs; j++) {
1408 i = np->intrs[j].line;
1409 if (i >= off && i < max)
6d0124fc 1410 senses[i-off] = np->intrs[j].sense;
9b6b563c
PM		 1411 }
1412 }
1413}
1414
1415/**
1416 * Construct and return a list of the device_nodes with a given name.
1417 */
1418struct device_node *find_devices(const char *name)
1419{
1420 struct device_node *head, **prevp, *np;
1421
1422 prevp = &head;
1423 for (np = allnodes; np != 0; np = np->allnext) {
1424 if (np->name != 0 && strcasecmp(np->name, name) == 0) {
1425 *prevp = np;
1426 prevp = &np->next;
1427 }
1428 }
1429 *prevp = NULL;
1430 return head;
1431}
1432EXPORT_SYMBOL(find_devices);
1433
1434/**
1435 * Construct and return a list of the device_nodes with a given type.
1436 */
1437struct device_node *find_type_devices(const char *type)
1438{
1439 struct device_node *head, **prevp, *np;
1440
1441 prevp = &head;
1442 for (np = allnodes; np != 0; np = np->allnext) {
1443 if (np->type != 0 && strcasecmp(np->type, type) == 0) {
1444 *prevp = np;
1445 prevp = &np->next;
1446 }
1447 }
1448 *prevp = NULL;
1449 return head;
1450}
1451EXPORT_SYMBOL(find_type_devices);
1452
1453/**
1454 * Returns all nodes linked together
1455 */
1456struct device_node *find_all_nodes(void)
1457{
1458 struct device_node *head, **prevp, *np;
1459
1460 prevp = &head;
1461 for (np = allnodes; np != 0; np = np->allnext) {
1462 *prevp = np;
1463 prevp = &np->next;
1464 }
1465 *prevp = NULL;
1466 return head;
1467}
1468EXPORT_SYMBOL(find_all_nodes);
1469
1470/** Checks if the given "compat" string matches one of the strings in
1471 * the device's "compatible" property
1472 */
1473int device_is_compatible(struct device_node *device, const char *compat)
1474{
1475 const char* cp;
1476 int cplen, l;
1477
1478 cp = (char *) get_property(device, "compatible", &cplen);
1479 if (cp == NULL)
1480 return 0;
1481 while (cplen > 0) {
1482 if (strncasecmp(cp, compat, strlen(compat)) == 0)
1483 return 1;
1484 l = strlen(cp) + 1;
1485 cp += l;
1486 cplen -= l;
1487 }
1488
1489 return 0;
1490}
1491EXPORT_SYMBOL(device_is_compatible);
1492
1493
1494/**
1495 * Indicates whether the root node has a given value in its
1496 * compatible property.
1497 */
1498int machine_is_compatible(const char *compat)
1499{
1500 struct device_node *root;
1501 int rc = 0;
1502
1503 root = of_find_node_by_path("/");
1504 if (root) {
1505 rc = device_is_compatible(root, compat);
1506 of_node_put(root);
1507 }
1508 return rc;
1509}
1510EXPORT_SYMBOL(machine_is_compatible);
1511
1512/**
1513 * Construct and return a list of the device_nodes with a given type
1514 * and compatible property.
1515 */
1516struct device_node *find_compatible_devices(const char *type,
1517 const char *compat)
1518{
1519 struct device_node *head, **prevp, *np;
1520
1521 prevp = &head;
1522 for (np = allnodes; np != 0; np = np->allnext) {
1523 if (type != NULL
1524 && !(np->type != 0 && strcasecmp(np->type, type) == 0))
1525 continue;
1526 if (device_is_compatible(np, compat)) {
1527 *prevp = np;
1528 prevp = &np->next;
1529 }
1530 }
1531 *prevp = NULL;
1532 return head;
1533}
1534EXPORT_SYMBOL(find_compatible_devices);
1535
1536/**
1537 * Find the device_node with a given full_name.
1538 */
1539struct device_node *find_path_device(const char *path)
1540{
1541 struct device_node *np;
1542
1543 for (np = allnodes; np != 0; np = np->allnext)
1544 if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0)
1545 return np;
1546 return NULL;
1547}
1548EXPORT_SYMBOL(find_path_device);
1549
1550/*******
1551 *
1552 * New implementation of the OF "find" APIs, return a refcounted
1553 * object, call of_node_put() when done. The device tree and list
1554 * are protected by a rw_lock.
1555 *
1556 * Note that property management will need some locking as well,
1557 * this isn't dealt with yet.
1558 *
1559 *******/
1560
1561/**
1562 * of_find_node_by_name - Find a node by its "name" property
1563 * @from: The node to start searching from or NULL, the node
1564 * you pass will not be searched, only the next one
1565 * will; typically, you pass what the previous call
1566 * returned. of_node_put() will be called on it
1567 * @name: The name string to match against
1568 *
1569 * Returns a node pointer with refcount incremented, use
1570 * of_node_put() on it when done.
1571 */
1572struct device_node *of_find_node_by_name(struct device_node *from,
1573 const char *name)
1574{
1575 struct device_node *np;
1576
1577 read_lock(&devtree_lock);
1578 np = from ? from->allnext : allnodes;
1579 for (; np != 0; np = np->allnext)
1580 if (np->name != 0 && strcasecmp(np->name, name) == 0
1581 && of_node_get(np))
1582 break;
1583 if (from)
1584 of_node_put(from);
1585 read_unlock(&devtree_lock);
1586 return np;
1587}
1588EXPORT_SYMBOL(of_find_node_by_name);
1589
1590/**
1591 * of_find_node_by_type - Find a node by its "device_type" property
1592 * @from: The node to start searching from or NULL, the node
1593 * you pass will not be searched, only the next one
1594 * will; typically, you pass what the previous call
1595 * returned. of_node_put() will be called on it
1596 * @name: The type string to match against
1597 *
1598 * Returns a node pointer with refcount incremented, use
1599 * of_node_put() on it when done.
1600 */
1601struct device_node *of_find_node_by_type(struct device_node *from,
1602 const char *type)
1603{
1604 struct device_node *np;
1605
1606 read_lock(&devtree_lock);
1607 np = from ? from->allnext : allnodes;
1608 for (; np != 0; np = np->allnext)
1609 if (np->type != 0 && strcasecmp(np->type, type) == 0
1610 && of_node_get(np))
1611 break;
1612 if (from)
1613 of_node_put(from);
1614 read_unlock(&devtree_lock);
1615 return np;
1616}
1617EXPORT_SYMBOL(of_find_node_by_type);
1618
1619/**
1620 * of_find_compatible_node - Find a node based on type and one of the
1621 * tokens in its "compatible" property
1622 * @from: The node to start searching from or NULL, the node
1623 * you pass will not be searched, only the next one
1624 * will; typically, you pass what the previous call
1625 * returned. of_node_put() will be called on it
1626 * @type: The type string to match "device_type" or NULL to ignore
1627 * @compatible: The string to match to one of the tokens in the device
1628 * "compatible" list.
1629 *
1630 * Returns a node pointer with refcount incremented, use
1631 * of_node_put() on it when done.
1632 */
1633struct device_node *of_find_compatible_node(struct device_node *from,
1634 const char *type, const char *compatible)
1635{
1636 struct device_node *np;
1637
1638 read_lock(&devtree_lock);
1639 np = from ? from->allnext : allnodes;
1640 for (; np != 0; np = np->allnext) {
1641 if (type != NULL
1642 && !(np->type != 0 && strcasecmp(np->type, type) == 0))
1643 continue;
1644 if (device_is_compatible(np, compatible) && of_node_get(np))
1645 break;
1646 }
1647 if (from)
1648 of_node_put(from);
1649 read_unlock(&devtree_lock);
1650 return np;
1651}
1652EXPORT_SYMBOL(of_find_compatible_node);
1653
1654/**
1655 * of_find_node_by_path - Find a node matching a full OF path
1656 * @path: The full path to match
1657 *
1658 * Returns a node pointer with refcount incremented, use
1659 * of_node_put() on it when done.
1660 */
1661struct device_node *of_find_node_by_path(const char *path)
1662{
1663 struct device_node *np = allnodes;
1664
1665 read_lock(&devtree_lock);
1666 for (; np != 0; np = np->allnext) {
1667 if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0
1668 && of_node_get(np))
1669 break;
1670 }
1671 read_unlock(&devtree_lock);
1672 return np;
1673}
1674EXPORT_SYMBOL(of_find_node_by_path);
1675
1676/**
1677 * of_find_node_by_phandle - Find a node given a phandle
1678 * @handle: phandle of the node to find
1679 *
1680 * Returns a node pointer with refcount incremented, use
1681 * of_node_put() on it when done.
1682 */
1683struct device_node *of_find_node_by_phandle(phandle handle)
1684{
1685 struct device_node *np;
1686
1687 read_lock(&devtree_lock);
1688 for (np = allnodes; np != 0; np = np->allnext)
1689 if (np->linux_phandle == handle)
1690 break;
1691 if (np)
1692 of_node_get(np);
1693 read_unlock(&devtree_lock);
1694 return np;
1695}
1696EXPORT_SYMBOL(of_find_node_by_phandle);
1697
1698/**
1699 * of_find_all_nodes - Get next node in global list
1700 * @prev: Previous node or NULL to start iteration
1701 * of_node_put() will be called on it
1702 *
1703 * Returns a node pointer with refcount incremented, use
1704 * of_node_put() on it when done.
1705 */
1706struct device_node *of_find_all_nodes(struct device_node *prev)
1707{
1708 struct device_node *np;
1709
1710 read_lock(&devtree_lock);
1711 np = prev ? prev->allnext : allnodes;
1712 for (; np != 0; np = np->allnext)
1713 if (of_node_get(np))
1714 break;
1715 if (prev)
1716 of_node_put(prev);
1717 read_unlock(&devtree_lock);
1718 return np;
1719}
1720EXPORT_SYMBOL(of_find_all_nodes);
1721
1722/**
1723 * of_get_parent - Get a node's parent if any
1724 * @node: Node to get parent
1725 *
1726 * Returns a node pointer with refcount incremented, use
1727 * of_node_put() on it when done.
1728 */
1729struct device_node *of_get_parent(const struct device_node *node)
1730{
1731 struct device_node *np;
1732
1733 if (!node)
1734 return NULL;
1735
1736 read_lock(&devtree_lock);
1737 np = of_node_get(node->parent);
1738 read_unlock(&devtree_lock);
1739 return np;
1740}
1741EXPORT_SYMBOL(of_get_parent);
1742
1743/**
1744 * of_get_next_child - Iterate a node childs
1745 * @node: parent node
1746 * @prev: previous child of the parent node, or NULL to get first
1747 *
1748 * Returns a node pointer with refcount incremented, use
1749 * of_node_put() on it when done.
1750 */
1751struct device_node *of_get_next_child(const struct device_node *node,
1752 struct device_node *prev)
1753{
1754 struct device_node *next;
1755
1756 read_lock(&devtree_lock);
1757 next = prev ? prev->sibling : node->child;
1758 for (; next != 0; next = next->sibling)
1759 if (of_node_get(next))
1760 break;
1761 if (prev)
1762 of_node_put(prev);
1763 read_unlock(&devtree_lock);
1764 return next;
1765}
1766EXPORT_SYMBOL(of_get_next_child);
1767
1768/**
1769 * of_node_get - Increment refcount of a node
1770 * @node: Node to inc refcount, NULL is supported to
1771 * simplify writing of callers
1772 *
1773 * Returns node.
1774 */
1775struct device_node *of_node_get(struct device_node *node)
1776{
1777 if (node)
1778 kref_get(&node->kref);
1779 return node;
1780}
1781EXPORT_SYMBOL(of_node_get);
1782
1783static inline struct device_node * kref_to_device_node(struct kref *kref)
1784{
1785 return container_of(kref, struct device_node, kref);
1786}
1787
1788/**
1789 * of_node_release - release a dynamically allocated node
1790 * @kref: kref element of the node to be released
1791 *
1792 * In of_node_put() this function is passed to kref_put()
1793 * as the destructor.
1794 */
1795static void of_node_release(struct kref *kref)
1796{
1797 struct device_node *node = kref_to_device_node(kref);
1798 struct property *prop = node->properties;
1799
1800 if (!OF_IS_DYNAMIC(node))
1801 return;
1802 while (prop) {
1803 struct property *next = prop->next;
1804 kfree(prop->name);
1805 kfree(prop->value);
1806 kfree(prop);
1807 prop = next;
1808 }
1809 kfree(node->intrs);
1810 kfree(node->addrs);
1811 kfree(node->full_name);
1812 kfree(node->data);
1813 kfree(node);
1814}
1815
1816/**
1817 * of_node_put - Decrement refcount of a node
1818 * @node: Node to dec refcount, NULL is supported to
1819 * simplify writing of callers
1820 *
1821 */
1822void of_node_put(struct device_node *node)
1823{
1824 if (node)
1825 kref_put(&node->kref, of_node_release);
1826}
1827EXPORT_SYMBOL(of_node_put);
1828
1829/*
1830 * Plug a device node into the tree and global list.
1831 */
1832void of_attach_node(struct device_node *np)
1833{
1834 write_lock(&devtree_lock);
1835 np->sibling = np->parent->child;
1836 np->allnext = allnodes;
1837 np->parent->child = np;
1838 allnodes = np;
1839 write_unlock(&devtree_lock);
1840}
1841
1842/*
1843 * "Unplug" a node from the device tree. The caller must hold
1844 * a reference to the node. The memory associated with the node
1845 * is not freed until its refcount goes to zero.
1846 */
1847void of_detach_node(const struct device_node *np)
1848{
1849 struct device_node *parent;
1850
1851 write_lock(&devtree_lock);
1852
1853 parent = np->parent;
1854
1855 if (allnodes == np)
1856 allnodes = np->allnext;
1857 else {
1858 struct device_node *prev;
1859 for (prev = allnodes;
1860 prev->allnext != np;
1861 prev = prev->allnext)
1862 ;
1863 prev->allnext = np->allnext;
1864 }
1865
1866 if (parent->child == np)
1867 parent->child = np->sibling;
1868 else {
1869 struct device_node *prevsib;
1870 for (prevsib = np->parent->child;
1871 prevsib->sibling != np;
1872 prevsib = prevsib->sibling)
1873 ;
1874 prevsib->sibling = np->sibling;
1875 }
1876
1877 write_unlock(&devtree_lock);
1878}
1879
1880#ifdef CONFIG_PPC_PSERIES
1881/*
1882 * Fix up the uninitialized fields in a new device node:
1883 * name, type, n_addrs, addrs, n_intrs, intrs, and pci-specific fields
1884 *
1885 * A lot of boot-time code is duplicated here, because functions such
1886 * as finish_node_interrupts, interpret_pci_props, etc. cannot use the
1887 * slab allocator.
1888 *
1889 * This should probably be split up into smaller chunks.
1890 */
1891
1892static int of_finish_dynamic_node(struct device_node *node,
1893 unsigned long *unused1, int unused2,
1894 int unused3, int unused4)
1895{
1896 struct device_node *parent = of_get_parent(node);
1897 int err = 0;
1898 phandle *ibm_phandle;
1899
1900 node->name = get_property(node, "name", NULL);
1901 node->type = get_property(node, "device_type", NULL);
1902
1903 if (!parent) {
1904 err = -ENODEV;
1905 goto out;
1906 }
1907
1908 /* We don't support that function on PowerMac, at least
1909 * not yet
1910 */
1911 if (systemcfg->platform == PLATFORM_POWERMAC)
1912 return -ENODEV;
1913
1914 /* fix up new node's linux_phandle field */
1915 if ((ibm_phandle = (unsigned int *)get_property(node, "ibm,phandle", NULL)))
1916 node->linux_phandle = *ibm_phandle;
1917
1918out:
1919 of_node_put(parent);
1920 return err;
1921}
1922
1923static int prom_reconfig_notifier(struct notifier_block *nb,
1924 unsigned long action, void *node)
1925{
1926 int err;
1927
1928 switch (action) {
1929 case PSERIES_RECONFIG_ADD:
1930 err = finish_node(node, NULL, of_finish_dynamic_node, 0, 0, 0);
1931 if (err < 0) {
1932 printk(KERN_ERR "finish_node returned %d\n", err);
1933 err = NOTIFY_BAD;
1934 }
1935 break;
1936 default:
1937 err = NOTIFY_DONE;
1938 break;
1939 }
1940 return err;
1941}
1942
1943static struct notifier_block prom_reconfig_nb = {
1944 .notifier_call = prom_reconfig_notifier,
1945 .priority = 10, /* This one needs to run first */
1946};
1947
1948static int __init prom_reconfig_setup(void)
1949{
1950 return pSeries_reconfig_notifier_register(&prom_reconfig_nb);
1951}
1952__initcall(prom_reconfig_setup);
1953#endif
1954
1955/*
1956 * Find a property with a given name for a given node
1957 * and return the value.
1958 */
1959unsigned char *get_property(struct device_node *np, const char *name,
1960 int *lenp)
1961{
1962 struct property *pp;
1963
1964 for (pp = np->properties; pp != 0; pp = pp->next)
1965 if (strcmp(pp->name, name) == 0) {
1966 if (lenp != 0)
1967 *lenp = pp->length;
1968 return pp->value;
1969 }
1970 return NULL;
1971}
1972EXPORT_SYMBOL(get_property);
1973
1974/*
1975 * Add a property to a node
1976 */
183d0202 1977int prom_add_property(struct device_node* np, struct property* prop)
9b6b563c 1978{
183d0202 1979 struct property **next;
9b6b563c
PM		 1980
1981 prop->next = NULL;
183d0202
BH		 1982 write_lock(&devtree_lock);
1983 next = &np->properties;
1984 while (*next) {
1985 if (strcmp(prop->name, (*next)->name) == 0) {
1986 /* duplicate ! don't insert it */
1987 write_unlock(&devtree_lock);
1988 return -1;
1989 }
9b6b563c 1990 next = &(*next)->next;
183d0202 1991 }
9b6b563c 1992 *next = prop;
183d0202
BH		 1993 write_unlock(&devtree_lock);
1994
1995 /* try to add to proc as well if it was initialized */
1996 if (np->pde)
1997 proc_device_tree_add_prop(np->pde, prop);
1998
1999 return 0;
9b6b563c
PM		 2000}
2001
2002/* I quickly hacked that one, check against spec ! */
2003static inline unsigned long
2004bus_space_to_resource_flags(unsigned int bus_space)
2005{
2006 u8 space = (bus_space >> 24) & 0xf;
2007 if (space == 0)
2008 space = 0x02;
2009 if (space == 0x02)
2010 return IORESOURCE_MEM;
2011 else if (space == 0x01)
2012 return IORESOURCE_IO;
2013 else {
2014 printk(KERN_WARNING "prom.c: bus_space_to_resource_flags(), space: %x\n",
2015 bus_space);
2016 return 0;
2017 }
2018}
2019
60dda256 2020#ifdef CONFIG_PCI
9b6b563c
PM		 2021static struct resource *find_parent_pci_resource(struct pci_dev* pdev,
2022 struct address_range *range)
2023{
2024 unsigned long mask;
2025 int i;
2026
2027 /* Check this one */
2028 mask = bus_space_to_resource_flags(range->space);
2029 for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
2030 if ((pdev->resource[i].flags & mask) == mask &&
2031 pdev->resource[i].start <= range->address &&
2032 pdev->resource[i].end > range->address) {
2033 if ((range->address + range->size - 1) > pdev->resource[i].end) {
2034 /* Add better message */
2035 printk(KERN_WARNING "PCI/OF resource overlap !\n");
2036 return NULL;
2037 }
2038 break;
2039 }
2040 }
2041 if (i == DEVICE_COUNT_RESOURCE)
2042 return NULL;
2043 return &pdev->resource[i];
2044}
2045
2046/*
2047 * Request an OF device resource. Currently handles child of PCI devices,
2048 * or other nodes attached to the root node. Ultimately, put some
2049 * link to resources in the OF node.
2050 */
2051struct resource *request_OF_resource(struct device_node* node, int index,
2052 const char* name_postfix)
2053{
2054 struct pci_dev* pcidev;
2055 u8 pci_bus, pci_devfn;
2056 unsigned long iomask;
2057 struct device_node* nd;
2058 struct resource* parent;
2059 struct resource *res = NULL;
2060 int nlen, plen;
2061
2062 if (index >= node->n_addrs)
2063 goto fail;
2064
2065 /* Sanity check on bus space */
2066 iomask = bus_space_to_resource_flags(node->addrs[index].space);
2067 if (iomask & IORESOURCE_MEM)
2068 parent = &iomem_resource;
2069 else if (iomask & IORESOURCE_IO)
2070 parent = &ioport_resource;
2071 else
2072 goto fail;
2073
2074 /* Find a PCI parent if any */
2075 nd = node;
2076 pcidev = NULL;
2077 while (nd) {
2078 if (!pci_device_from_OF_node(nd, &pci_bus, &pci_devfn))
2079 pcidev = pci_find_slot(pci_bus, pci_devfn);
2080 if (pcidev) break;
2081 nd = nd->parent;
2082 }
2083 if (pcidev)
2084 parent = find_parent_pci_resource(pcidev, &node->addrs[index]);
2085 if (!parent) {
2086 printk(KERN_WARNING "request_OF_resource(%s), parent not found\n",
2087 node->name);
2088 goto fail;
2089 }
2090
2091 res = __request_region(parent, node->addrs[index].address,
2092 node->addrs[index].size, NULL);
2093 if (!res)
2094 goto fail;
2095 nlen = strlen(node->name);
2096 plen = name_postfix ? strlen(name_postfix) : 0;
2097 res->name = (const char *)kmalloc(nlen+plen+1, GFP_KERNEL);
2098 if (res->name) {
2099 strcpy((char *)res->name, node->name);
2100 if (plen)
2101 strcpy((char *)res->name+nlen, name_postfix);
2102 }
2103 return res;
2104fail:
2105 return NULL;
2106}
2107EXPORT_SYMBOL(request_OF_resource);
2108
2109int release_OF_resource(struct device_node *node, int index)
2110{
2111 struct pci_dev* pcidev;
2112 u8 pci_bus, pci_devfn;
2113 unsigned long iomask, start, end;
2114 struct device_node* nd;
2115 struct resource* parent;
2116 struct resource *res = NULL;
2117
2118 if (index >= node->n_addrs)
2119 return -EINVAL;
2120
2121 /* Sanity check on bus space */
2122 iomask = bus_space_to_resource_flags(node->addrs[index].space);
2123 if (iomask & IORESOURCE_MEM)
2124 parent = &iomem_resource;
2125 else if (iomask & IORESOURCE_IO)
2126 parent = &ioport_resource;
2127 else
2128 return -EINVAL;
2129
2130 /* Find a PCI parent if any */
2131 nd = node;
2132 pcidev = NULL;
2133 while(nd) {
2134 if (!pci_device_from_OF_node(nd, &pci_bus, &pci_devfn))
2135 pcidev = pci_find_slot(pci_bus, pci_devfn);
2136 if (pcidev) break;
2137 nd = nd->parent;
2138 }
2139 if (pcidev)
2140 parent = find_parent_pci_resource(pcidev, &node->addrs[index]);
2141 if (!parent) {
2142 printk(KERN_WARNING "release_OF_resource(%s), parent not found\n",
2143 node->name);
2144 return -ENODEV;
2145 }
2146
2147 /* Find us in the parent and its childs */
2148 res = parent->child;
2149 start = node->addrs[index].address;
2150 end = start + node->addrs[index].size - 1;
2151 while (res) {
2152 if (res->start == start && res->end == end &&
2153 (res->flags & IORESOURCE_BUSY))
2154 break;
2155 if (res->start <= start && res->end >= end)
2156 res = res->child;
2157 else
2158 res = res->sibling;
2159 }
2160 if (!res)
2161 return -ENODEV;
2162
2163 if (res->name) {
2164 kfree(res->name);
2165 res->name = NULL;
2166 }
2167 release_resource(res);
2168 kfree(res);
2169
2170 return 0;
2171}
2172EXPORT_SYMBOL(release_OF_resource);
60dda256 2173#endif /* CONFIG_PCI */
Linux kernel - Deliverables
This page took 0.114473 seconds and 5 git commands to generate.