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