?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: fix bogus KERN_ALERT on oops
[wrt350n-kernel.git] / arch / powerpc / kernel / prom.c
blob9f329a8928eaed27f3192e27c729e24bb73ac888
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/kernel.h>
20 #include <linux/string.h>
21 #include <linux/init.h>
22 #include <linux/threads.h>
23 #include <linux/spinlock.h>
24 #include <linux/types.h>
25 #include <linux/pci.h>
26 #include <linux/stringify.h>
27 #include <linux/delay.h>
28 #include <linux/initrd.h>
29 #include <linux/bitops.h>
30 #include <linux/module.h>
31 #include <linux/kexec.h>
32 #include <linux/debugfs.h>
33 #include <linux/irq.h>
34
35 #include <asm/prom.h>
36 #include <asm/rtas.h>
37 #include <asm/lmb.h>
38 #include <asm/page.h>
39 #include <asm/processor.h>
40 #include <asm/irq.h>
41 #include <asm/io.h>
42 #include <asm/kdump.h>
43 #include <asm/smp.h>
44 #include <asm/system.h>
45 #include <asm/mmu.h>
46 #include <asm/pgtable.h>
47 #include <asm/pci.h>
48 #include <asm/iommu.h>
49 #include <asm/btext.h>
50 #include <asm/sections.h>
51 #include <asm/machdep.h>
52 #include <asm/pSeries_reconfig.h>
53 #include <asm/pci-bridge.h>
54 #include <asm/kexec.h>
55
56 #ifdef DEBUG
57 #define DBG(fmt...) printk(KERN_ERR fmt)
58 #else
59 #define DBG(fmt...)
60 #endif
61
62
63 static int __initdata dt_root_addr_cells;
64 static int __initdata dt_root_size_cells;
65
66 #ifdef CONFIG_PPC64
67 int __initdata iommu_is_off;
68 int __initdata iommu_force_on;
69 unsigned long tce_alloc_start, tce_alloc_end;
70 #endif
71
72 typedef u32 cell_t;
73
74 #if 0
75 static struct boot_param_header *initial_boot_params __initdata;
76 #else
77 struct boot_param_header *initial_boot_params;
78 #endif
79
80 extern struct device_node *allnodes; /* temporary while merging */
81
82 extern rwlock_t devtree_lock; /* temporary while merging */
83
84 /* export that to outside world */
85 struct device_node *of_chosen;
86
87 static inline char *find_flat_dt_string(u32 offset)
88 {
89 return ((char *)initial_boot_params) +
90 initial_boot_params->off_dt_strings + offset;
91 }
92
93 /**
94 * This function is used to scan the flattened device-tree, it is
95 * used to extract the memory informations at boot before we can
96 * unflatten the tree
97 */
98 int __init of_scan_flat_dt(int (*it)(unsigned long node,
99 const char *uname, int depth,
100 void *data),
101 void *data)
102 {
103 unsigned long p = ((unsigned long)initial_boot_params) +
104 initial_boot_params->off_dt_struct;
105 int rc = 0;
106 int depth = -1;
107
108 do {
109 u32 tag = *((u32 *)p);
110 char *pathp;
111
112 p += 4;
113 if (tag == OF_DT_END_NODE) {
114 depth --;
115 continue;
116 }
117 if (tag == OF_DT_NOP)
118 continue;
119 if (tag == OF_DT_END)
120 break;
121 if (tag == OF_DT_PROP) {
122 u32 sz = *((u32 *)p);
123 p += 8;
124 if (initial_boot_params->version < 0x10)
125 p = _ALIGN(p, sz >= 8 ? 8 : 4);
126 p += sz;
127 p = _ALIGN(p, 4);
128 continue;
129 }
130 if (tag != OF_DT_BEGIN_NODE) {
131 printk(KERN_WARNING "Invalid tag %x scanning flattened"
132 " device tree !\n", tag);
133 return -EINVAL;
134 }
135 depth++;
136 pathp = (char *)p;
137 p = _ALIGN(p + strlen(pathp) + 1, 4);
138 if ((*pathp) == '/') {
139 char *lp, *np;
140 for (lp = NULL, np = pathp; *np; np++)
141 if ((*np) == '/')
142 lp = np+1;
143 if (lp != NULL)
144 pathp = lp;
145 }
146 rc = it(p, pathp, depth, data);
147 if (rc != 0)
148 break;
149 } while(1);
150
151 return rc;
152 }
153
154 unsigned long __init of_get_flat_dt_root(void)
155 {
156 unsigned long p = ((unsigned long)initial_boot_params) +
157 initial_boot_params->off_dt_struct;
158
159 while(*((u32 *)p) == OF_DT_NOP)
160 p += 4;
161 BUG_ON (*((u32 *)p) != OF_DT_BEGIN_NODE);
162 p += 4;
163 return _ALIGN(p + strlen((char *)p) + 1, 4);
164 }
165
166 /**
167 * This function can be used within scan_flattened_dt callback to get
168 * access to properties
169 */
170 void* __init of_get_flat_dt_prop(unsigned long node, const char *name,
171 unsigned long *size)
172 {
173 unsigned long p = node;
174
175 do {
176 u32 tag = *((u32 *)p);
177 u32 sz, noff;
178 const char *nstr;
179
180 p += 4;
181 if (tag == OF_DT_NOP)
182 continue;
183 if (tag != OF_DT_PROP)
184 return NULL;
185
186 sz = *((u32 *)p);
187 noff = *((u32 *)(p + 4));
188 p += 8;
189 if (initial_boot_params->version < 0x10)
190 p = _ALIGN(p, sz >= 8 ? 8 : 4);
191
192 nstr = find_flat_dt_string(noff);
193 if (nstr == NULL) {
194 printk(KERN_WARNING "Can't find property index"
195 " name !\n");
196 return NULL;
197 }
198 if (strcmp(name, nstr) == 0) {
199 if (size)
200 *size = sz;
201 return (void *)p;
202 }
203 p += sz;
204 p = _ALIGN(p, 4);
205 } while(1);
206 }
207
208 int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
209 {
210 const char* cp;
211 unsigned long cplen, l;
212
213 cp = of_get_flat_dt_prop(node, "compatible", &cplen);
214 if (cp == NULL)
215 return 0;
216 while (cplen > 0) {
217 if (strncasecmp(cp, compat, strlen(compat)) == 0)
218 return 1;
219 l = strlen(cp) + 1;
220 cp += l;
221 cplen -= l;
222 }
223
224 return 0;
225 }
226
227 static void *__init unflatten_dt_alloc(unsigned long *mem, unsigned long size,
228 unsigned long align)
229 {
230 void *res;
231
232 *mem = _ALIGN(*mem, align);
233 res = (void *)*mem;
234 *mem += size;
235
236 return res;
237 }
238
239 static unsigned long __init unflatten_dt_node(unsigned long mem,
240 unsigned long *p,
241 struct device_node *dad,
242 struct device_node ***allnextpp,
243 unsigned long fpsize)
244 {
245 struct device_node *np;
246 struct property *pp, **prev_pp = NULL;
247 char *pathp;
248 u32 tag;
249 unsigned int l, allocl;
250 int has_name = 0;
251 int new_format = 0;
252
253 tag = *((u32 *)(*p));
254 if (tag != OF_DT_BEGIN_NODE) {
255 printk("Weird tag at start of node: %x\n", tag);
256 return mem;
257 }
258 *p += 4;
259 pathp = (char *)*p;
260 l = allocl = strlen(pathp) + 1;
261 *p = _ALIGN(*p + l, 4);
262
263 /* version 0x10 has a more compact unit name here instead of the full
264 * path. we accumulate the full path size using "fpsize", we'll rebuild
265 * it later. We detect this because the first character of the name is
266 * not '/'.
267 */
268 if ((*pathp) != '/') {
269 new_format = 1;
270 if (fpsize == 0) {
271 /* root node: special case. fpsize accounts for path
272 * plus terminating zero. root node only has '/', so
273 * fpsize should be 2, but we want to avoid the first
274 * level nodes to have two '/' so we use fpsize 1 here
275 */
276 fpsize = 1;
277 allocl = 2;
278 } else {
279 /* account for '/' and path size minus terminal 0
280 * already in 'l'
281 */
282 fpsize += l;
283 allocl = fpsize;
284 }
285 }
286
287
288 np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
289 __alignof__(struct device_node));
290 if (allnextpp) {
291 memset(np, 0, sizeof(*np));
292 np->full_name = ((char*)np) + sizeof(struct device_node);
293 if (new_format) {
294 char *p = np->full_name;
295 /* rebuild full path for new format */
296 if (dad && dad->parent) {
297 strcpy(p, dad->full_name);
298 #ifdef DEBUG
299 if ((strlen(p) + l + 1) != allocl) {
300 DBG("%s: p: %d, l: %d, a: %d\n",
301 pathp, (int)strlen(p), l, allocl);
302 }
303 #endif
304 p += strlen(p);
305 }
306 *(p++) = '/';
307 memcpy(p, pathp, l);
308 } else
309 memcpy(np->full_name, pathp, l);
310 prev_pp = &np->properties;
311 **allnextpp = np;
312 *allnextpp = &np->allnext;
313 if (dad != NULL) {
314 np->parent = dad;
315 /* we temporarily use the next field as `last_child'*/
316 if (dad->next == 0)
317 dad->child = np;
318 else
319 dad->next->sibling = np;
320 dad->next = np;
321 }
322 kref_init(&np->kref);
323 }
324 while(1) {
325 u32 sz, noff;
326 char *pname;
327
328 tag = *((u32 *)(*p));
329 if (tag == OF_DT_NOP) {
330 *p += 4;
331 continue;
332 }
333 if (tag != OF_DT_PROP)
334 break;
335 *p += 4;
336 sz = *((u32 *)(*p));
337 noff = *((u32 *)((*p) + 4));
338 *p += 8;
339 if (initial_boot_params->version < 0x10)
340 *p = _ALIGN(*p, sz >= 8 ? 8 : 4);
341
342 pname = find_flat_dt_string(noff);
343 if (pname == NULL) {
344 printk("Can't find property name in list !\n");
345 break;
346 }
347 if (strcmp(pname, "name") == 0)
348 has_name = 1;
349 l = strlen(pname) + 1;
350 pp = unflatten_dt_alloc(&mem, sizeof(struct property),
351 __alignof__(struct property));
352 if (allnextpp) {
353 if (strcmp(pname, "linux,phandle") == 0) {
354 np->node = *((u32 *)*p);
355 if (np->linux_phandle == 0)
356 np->linux_phandle = np->node;
357 }
358 if (strcmp(pname, "ibm,phandle") == 0)
359 np->linux_phandle = *((u32 *)*p);
360 pp->name = pname;
361 pp->length = sz;
362 pp->value = (void *)*p;
363 *prev_pp = pp;
364 prev_pp = &pp->next;
365 }
366 *p = _ALIGN((*p) + sz, 4);
367 }
368 /* with version 0x10 we may not have the name property, recreate
369 * it here from the unit name if absent
370 */
371 if (!has_name) {
372 char *p = pathp, *ps = pathp, *pa = NULL;
373 int sz;
374
375 while (*p) {
376 if ((*p) == '@')
377 pa = p;
378 if ((*p) == '/')
379 ps = p + 1;
380 p++;
381 }
382 if (pa < ps)
383 pa = p;
384 sz = (pa - ps) + 1;
385 pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
386 __alignof__(struct property));
387 if (allnextpp) {
388 pp->name = "name";
389 pp->length = sz;
390 pp->value = pp + 1;
391 *prev_pp = pp;
392 prev_pp = &pp->next;
393 memcpy(pp->value, ps, sz - 1);
394 ((char *)pp->value)[sz - 1] = 0;
395 DBG("fixed up name for %s -> %s\n", pathp,
396 (char *)pp->value);
397 }
398 }
399 if (allnextpp) {
400 *prev_pp = NULL;
401 np->name = of_get_property(np, "name", NULL);
402 np->type = of_get_property(np, "device_type", NULL);
403
404 if (!np->name)
405 np->name = "<NULL>";
406 if (!np->type)
407 np->type = "<NULL>";
408 }
409 while (tag == OF_DT_BEGIN_NODE) {
410 mem = unflatten_dt_node(mem, p, np, allnextpp, fpsize);
411 tag = *((u32 *)(*p));
412 }
413 if (tag != OF_DT_END_NODE) {
414 printk("Weird tag at end of node: %x\n", tag);
415 return mem;
416 }
417 *p += 4;
418 return mem;
419 }
420
421 static int __init early_parse_mem(char *p)
422 {
423 if (!p)
424 return 1;
425
426 memory_limit = PAGE_ALIGN(memparse(p, &p));
427 DBG("memory limit = 0x%lx\n", memory_limit);
428
429 return 0;
430 }
431 early_param("mem", early_parse_mem);
432
433 /**
434 * move_device_tree - move tree to an unused area, if needed.
435 *
436 * The device tree may be allocated beyond our memory limit, or inside the
437 * crash kernel region for kdump. If so, move it out of the way.
438 */
439 static void move_device_tree(void)
440 {
441 unsigned long start, size;
442 void *p;
443
444 DBG("-> move_device_tree\n");
445
446 start = __pa(initial_boot_params);
447 size = initial_boot_params->totalsize;
448
449 if ((memory_limit && (start + size) > memory_limit) ||
450 overlaps_crashkernel(start, size)) {
451 p = __va(lmb_alloc_base(size, PAGE_SIZE, lmb.rmo_size));
452 memcpy(p, initial_boot_params, size);
453 initial_boot_params = (struct boot_param_header *)p;
454 DBG("Moved device tree to 0x%p\n", p);
455 }
456
457 DBG("<- move_device_tree\n");
458 }
459
460 /**
461 * unflattens the device-tree passed by the firmware, creating the
462 * tree of struct device_node. It also fills the "name" and "type"
463 * pointers of the nodes so the normal device-tree walking functions
464 * can be used (this used to be done by finish_device_tree)
465 */
466 void __init unflatten_device_tree(void)
467 {
468 unsigned long start, mem, size;
469 struct device_node **allnextp = &allnodes;
470
471 DBG(" -> unflatten_device_tree()\n");
472
473 /* First pass, scan for size */
474 start = ((unsigned long)initial_boot_params) +
475 initial_boot_params->off_dt_struct;
476 size = unflatten_dt_node(0, &start, NULL, NULL, 0);
477 size = (size | 3) + 1;
478
479 DBG(" size is %lx, allocating...\n", size);
480
481 /* Allocate memory for the expanded device tree */
482 mem = lmb_alloc(size + 4, __alignof__(struct device_node));
483 mem = (unsigned long) __va(mem);
484
485 ((u32 *)mem)[size / 4] = 0xdeadbeef;
486
487 DBG(" unflattening %lx...\n", mem);
488
489 /* Second pass, do actual unflattening */
490 start = ((unsigned long)initial_boot_params) +
491 initial_boot_params->off_dt_struct;
492 unflatten_dt_node(mem, &start, NULL, &allnextp, 0);
493 if (*((u32 *)start) != OF_DT_END)
494 printk(KERN_WARNING "Weird tag at end of tree: %08x\n", *((u32 *)start));
495 if (((u32 *)mem)[size / 4] != 0xdeadbeef)
496 printk(KERN_WARNING "End of tree marker overwritten: %08x\n",
497 ((u32 *)mem)[size / 4] );
498 *allnextp = NULL;
499
500 /* Get pointer to OF "/chosen" node for use everywhere */
501 of_chosen = of_find_node_by_path("/chosen");
502 if (of_chosen == NULL)
503 of_chosen = of_find_node_by_path("/chosen@0");
504
505 DBG(" <- unflatten_device_tree()\n");
506 }
507
508 /*
509 * ibm,pa-features is a per-cpu property that contains a string of
510 * attribute descriptors, each of which has a 2 byte header plus up
511 * to 254 bytes worth of processor attribute bits. First header
512 * byte specifies the number of bytes following the header.
513 * Second header byte is an "attribute-specifier" type, of which
514 * zero is the only currently-defined value.
515 * Implementation: Pass in the byte and bit offset for the feature
516 * that we are interested in. The function will return -1 if the
517 * pa-features property is missing, or a 1/0 to indicate if the feature
518 * is supported/not supported. Note that the bit numbers are
519 * big-endian to match the definition in PAPR.
520 */
521 static struct ibm_pa_feature {
522 unsigned long cpu_features; /* CPU_FTR_xxx bit */
523 unsigned int cpu_user_ftrs; /* PPC_FEATURE_xxx bit */
524 unsigned char pabyte; /* byte number in ibm,pa-features */
525 unsigned char pabit; /* bit number (big-endian) */
526 unsigned char invert; /* if 1, pa bit set => clear feature */
527 } ibm_pa_features[] __initdata = {
528 {0, PPC_FEATURE_HAS_MMU, 0, 0, 0},
529 {0, PPC_FEATURE_HAS_FPU, 0, 1, 0},
530 {CPU_FTR_SLB, 0, 0, 2, 0},
531 {CPU_FTR_CTRL, 0, 0, 3, 0},
532 {CPU_FTR_NOEXECUTE, 0, 0, 6, 0},
533 {CPU_FTR_NODSISRALIGN, 0, 1, 1, 1},
534 {CPU_FTR_CI_LARGE_PAGE, 0, 1, 2, 0},
535 {CPU_FTR_REAL_LE, PPC_FEATURE_TRUE_LE, 5, 0, 0},
536 };
537
538 static void __init scan_features(unsigned long node, unsigned char *ftrs,
539 unsigned long tablelen,
540 struct ibm_pa_feature *fp,
541 unsigned long ft_size)
542 {
543 unsigned long i, len, bit;
544
545 /* find descriptor with type == 0 */
546 for (;;) {
547 if (tablelen < 3)
548 return;
549 len = 2 + ftrs[0];
550 if (tablelen < len)
551 return; /* descriptor 0 not found */
552 if (ftrs[1] == 0)
553 break;
554 tablelen -= len;
555 ftrs += len;
556 }
557
558 /* loop over bits we know about */
559 for (i = 0; i < ft_size; ++i, ++fp) {
560 if (fp->pabyte >= ftrs[0])
561 continue;
562 bit = (ftrs[2 + fp->pabyte] >> (7 - fp->pabit)) & 1;
563 if (bit ^ fp->invert) {
564 cur_cpu_spec->cpu_features |= fp->cpu_features;
565 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftrs;
566 } else {
567 cur_cpu_spec->cpu_features &= ~fp->cpu_features;
568 cur_cpu_spec->cpu_user_features &= ~fp->cpu_user_ftrs;
569 }
570 }
571 }
572
573 static void __init check_cpu_pa_features(unsigned long node)
574 {
575 unsigned char *pa_ftrs;
576 unsigned long tablelen;
577
578 pa_ftrs = of_get_flat_dt_prop(node, "ibm,pa-features", &tablelen);
579 if (pa_ftrs == NULL)
580 return;
581
582 scan_features(node, pa_ftrs, tablelen,
583 ibm_pa_features, ARRAY_SIZE(ibm_pa_features));
584 }
585
586 static struct feature_property {
587 const char *name;
588 u32 min_value;
589 unsigned long cpu_feature;
590 unsigned long cpu_user_ftr;
591 } feature_properties[] __initdata = {
592 #ifdef CONFIG_ALTIVEC
593 {"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
594 {"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
595 #endif /* CONFIG_ALTIVEC */
596 #ifdef CONFIG_PPC64
597 {"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP},
598 {"ibm,purr", 1, CPU_FTR_PURR, 0},
599 {"ibm,spurr", 1, CPU_FTR_SPURR, 0},
600 #endif /* CONFIG_PPC64 */
601 };
602
603 static void __init check_cpu_feature_properties(unsigned long node)
604 {
605 unsigned long i;
606 struct feature_property *fp = feature_properties;
607 const u32 *prop;
608
609 for (i = 0; i < ARRAY_SIZE(feature_properties); ++i, ++fp) {
610 prop = of_get_flat_dt_prop(node, fp->name, NULL);
611 if (prop && *prop >= fp->min_value) {
612 cur_cpu_spec->cpu_features |= fp->cpu_feature;
613 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr;
614 }
615 }
616 }
617
618 static int __init early_init_dt_scan_cpus(unsigned long node,
619 const char *uname, int depth,
620 void *data)
621 {
622 static int logical_cpuid = 0;
623 char *type = of_get_flat_dt_prop(node, "device_type", NULL);
624 const u32 *prop;
625 const u32 *intserv;
626 int i, nthreads;
627 unsigned long len;
628 int found = 0;
629
630 /* We are scanning "cpu" nodes only */
631 if (type == NULL || strcmp(type, "cpu") != 0)
632 return 0;
633
634 /* Get physical cpuid */
635 intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len);
636 if (intserv) {
637 nthreads = len / sizeof(int);
638 } else {
639 intserv = of_get_flat_dt_prop(node, "reg", NULL);
640 nthreads = 1;
641 }
642
643 /*
644 * Now see if any of these threads match our boot cpu.
645 * NOTE: This must match the parsing done in smp_setup_cpu_maps.
646 */
647 for (i = 0; i < nthreads; i++) {
648 /*
649 * version 2 of the kexec param format adds the phys cpuid of
650 * booted proc.
651 */
652 if (initial_boot_params && initial_boot_params->version >= 2) {
653 if (intserv[i] ==
654 initial_boot_params->boot_cpuid_phys) {
655 found = 1;
656 break;
657 }
658 } else {
659 /*
660 * Check if it's the boot-cpu, set it's hw index now,
661 * unfortunately this format did not support booting
662 * off secondary threads.
663 */
664 if (of_get_flat_dt_prop(node,
665 "linux,boot-cpu", NULL) != NULL) {
666 found = 1;
667 break;
668 }
669 }
670
671 #ifdef CONFIG_SMP
672 /* logical cpu id is always 0 on UP kernels */
673 logical_cpuid++;
674 #endif
675 }
676
677 if (found) {
678 DBG("boot cpu: logical %d physical %d\n", logical_cpuid,
679 intserv[i]);
680 boot_cpuid = logical_cpuid;
681 set_hard_smp_processor_id(boot_cpuid, intserv[i]);
682
683 /*
684 * PAPR defines "logical" PVR values for cpus that
685 * meet various levels of the architecture:
686 * 0x0f000001 Architecture version 2.04
687 * 0x0f000002 Architecture version 2.05
688 * If the cpu-version property in the cpu node contains
689 * such a value, we call identify_cpu again with the
690 * logical PVR value in order to use the cpu feature
691 * bits appropriate for the architecture level.
692 *
693 * A POWER6 partition in "POWER6 architected" mode
694 * uses the 0x0f000002 PVR value; in POWER5+ mode
695 * it uses 0x0f000001.
696 */
697 prop = of_get_flat_dt_prop(node, "cpu-version", NULL);
698 if (prop && (*prop & 0xff000000) == 0x0f000000)
699 identify_cpu(0, *prop);
700 }
701
702 check_cpu_feature_properties(node);
703 check_cpu_pa_features(node);
704
705 #ifdef CONFIG_PPC_PSERIES
706 if (nthreads > 1)
707 cur_cpu_spec->cpu_features |= CPU_FTR_SMT;
708 else
709 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT;
710 #endif
711
712 return 0;
713 }
714
715 #ifdef CONFIG_BLK_DEV_INITRD
716 static void __init early_init_dt_check_for_initrd(unsigned long node)
717 {
718 unsigned long l;
719 u32 *prop;
720
721 DBG("Looking for initrd properties... ");
722
723 prop = of_get_flat_dt_prop(node, "linux,initrd-start", &l);
724 if (prop) {
725 initrd_start = (unsigned long)__va(of_read_ulong(prop, l/4));
726
727 prop = of_get_flat_dt_prop(node, "linux,initrd-end", &l);
728 if (prop) {
729 initrd_end = (unsigned long)
730 __va(of_read_ulong(prop, l/4));
731 initrd_below_start_ok = 1;
732 } else {
733 initrd_start = 0;
734 }
735 }
736
737 DBG("initrd_start=0x%lx initrd_end=0x%lx\n", initrd_start, initrd_end);
738 }
739 #else
740 static inline void early_init_dt_check_for_initrd(unsigned long node)
741 {
742 }
743 #endif /* CONFIG_BLK_DEV_INITRD */
744
745 static int __init early_init_dt_scan_chosen(unsigned long node,
746 const char *uname, int depth, void *data)
747 {
748 unsigned long *lprop;
749 unsigned long l;
750 char *p;
751
752 DBG("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
753
754 if (depth != 1 ||
755 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
756 return 0;
757
758 #ifdef CONFIG_PPC64
759 /* check if iommu is forced on or off */
760 if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL)
761 iommu_is_off = 1;
762 if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL)
763 iommu_force_on = 1;
764 #endif
765
766 /* mem=x on the command line is the preferred mechanism */
767 lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL);
768 if (lprop)
769 memory_limit = *lprop;
770
771 #ifdef CONFIG_PPC64
772 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL);
773 if (lprop)
774 tce_alloc_start = *lprop;
775 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL);
776 if (lprop)
777 tce_alloc_end = *lprop;
778 #endif
779
780 #ifdef CONFIG_KEXEC
781 lprop = (u64*)of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL);
782 if (lprop)
783 crashk_res.start = *lprop;
784
785 lprop = (u64*)of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL);
786 if (lprop)
787 crashk_res.end = crashk_res.start + *lprop - 1;
788 #endif
789
790 early_init_dt_check_for_initrd(node);
791
792 /* Retreive command line */
793 p = of_get_flat_dt_prop(node, "bootargs", &l);
794 if (p != NULL && l > 0)
795 strlcpy(cmd_line, p, min((int)l, COMMAND_LINE_SIZE));
796
797 #ifdef CONFIG_CMDLINE
798 if (p == NULL || l == 0 || (l == 1 && (*p) == 0))
799 strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
800 #endif /* CONFIG_CMDLINE */
801
802 DBG("Command line is: %s\n", cmd_line);
803
804 /* break now */
805 return 1;
806 }
807
808 static int __init early_init_dt_scan_root(unsigned long node,
809 const char *uname, int depth, void *data)
810 {
811 u32 *prop;
812
813 if (depth != 0)
814 return 0;
815
816 prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
817 dt_root_size_cells = (prop == NULL) ? 1 : *prop;
818 DBG("dt_root_size_cells = %x\n", dt_root_size_cells);
819
820 prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
821 dt_root_addr_cells = (prop == NULL) ? 2 : *prop;
822 DBG("dt_root_addr_cells = %x\n", dt_root_addr_cells);
823
824 /* break now */
825 return 1;
826 }
827
828 static unsigned long __init dt_mem_next_cell(int s, cell_t **cellp)
829 {
830 cell_t *p = *cellp;
831
832 *cellp = p + s;
833 return of_read_ulong(p, s);
834 }
835
836 #ifdef CONFIG_PPC_PSERIES
837 /*
838 * Interpret the ibm,dynamic-memory property in the
839 * /ibm,dynamic-reconfiguration-memory node.
840 * This contains a list of memory blocks along with NUMA affinity
841 * information.
842 */
843 static int __init early_init_dt_scan_drconf_memory(unsigned long node)
844 {
845 cell_t *dm, *ls;
846 unsigned long l, n;
847 unsigned long base, size, lmb_size, flags;
848
849 ls = (cell_t *)of_get_flat_dt_prop(node, "ibm,lmb-size", &l);
850 if (ls == NULL || l < dt_root_size_cells * sizeof(cell_t))
851 return 0;
852 lmb_size = dt_mem_next_cell(dt_root_size_cells, &ls);
853
854 dm = (cell_t *)of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l);
855 if (dm == NULL || l < sizeof(cell_t))
856 return 0;
857
858 n = *dm++; /* number of entries */
859 if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(cell_t))
860 return 0;
861
862 for (; n != 0; --n) {
863 base = dt_mem_next_cell(dt_root_addr_cells, &dm);
864 flags = dm[3];
865 /* skip DRC index, pad, assoc. list index, flags */
866 dm += 4;
867 /* skip this block if the reserved bit is set in flags (0x80)
868 or if the block is not assigned to this partition (0x8) */
869 if ((flags & 0x80) || !(flags & 0x8))
870 continue;
871 size = lmb_size;
872 if (iommu_is_off) {
873 if (base >= 0x80000000ul)
874 continue;
875 if ((base + size) > 0x80000000ul)
876 size = 0x80000000ul - base;
877 }
878 lmb_add(base, size);
879 }
880 lmb_dump_all();
881 return 0;
882 }
883 #else
884 #define early_init_dt_scan_drconf_memory(node) 0
885 #endif /* CONFIG_PPC_PSERIES */
886
887 static int __init early_init_dt_scan_memory(unsigned long node,
888 const char *uname, int depth, void *data)
889 {
890 char *type = of_get_flat_dt_prop(node, "device_type", NULL);
891 cell_t *reg, *endp;
892 unsigned long l;
893
894 /* Look for the ibm,dynamic-reconfiguration-memory node */
895 if (depth == 1 &&
896 strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0)
897 return early_init_dt_scan_drconf_memory(node);
898
899 /* We are scanning "memory" nodes only */
900 if (type == NULL) {
901 /*
902 * The longtrail doesn't have a device_type on the
903 * /memory node, so look for the node called /memory@0.
904 */
905 if (depth != 1 || strcmp(uname, "memory@0") != 0)
906 return 0;
907 } else if (strcmp(type, "memory") != 0)
908 return 0;
909
910 reg = (cell_t *)of_get_flat_dt_prop(node, "linux,usable-memory", &l);
911 if (reg == NULL)
912 reg = (cell_t *)of_get_flat_dt_prop(node, "reg", &l);
913 if (reg == NULL)
914 return 0;
915
916 endp = reg + (l / sizeof(cell_t));
917
918 DBG("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
919 uname, l, reg[0], reg[1], reg[2], reg[3]);
920
921 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
922 unsigned long base, size;
923
924 base = dt_mem_next_cell(dt_root_addr_cells, &reg);
925 size = dt_mem_next_cell(dt_root_size_cells, &reg);
926
927 if (size == 0)
928 continue;
929 DBG(" - %lx , %lx\n", base, size);
930 #ifdef CONFIG_PPC64
931 if (iommu_is_off) {
932 if (base >= 0x80000000ul)
933 continue;
934 if ((base + size) > 0x80000000ul)
935 size = 0x80000000ul - base;
936 }
937 #endif
938 lmb_add(base, size);
939 }
940 return 0;
941 }
942
943 static void __init early_reserve_mem(void)
944 {
945 u64 base, size;
946 u64 *reserve_map;
947 unsigned long self_base;
948 unsigned long self_size;
949
950 reserve_map = (u64 *)(((unsigned long)initial_boot_params) +
951 initial_boot_params->off_mem_rsvmap);
952
953 /* before we do anything, lets reserve the dt blob */
954 self_base = __pa((unsigned long)initial_boot_params);
955 self_size = initial_boot_params->totalsize;
956 lmb_reserve(self_base, self_size);
957
958 #ifdef CONFIG_BLK_DEV_INITRD
959 /* then reserve the initrd, if any */
960 if (initrd_start && (initrd_end > initrd_start))
961 lmb_reserve(__pa(initrd_start), initrd_end - initrd_start);
962 #endif /* CONFIG_BLK_DEV_INITRD */
963
964 #ifdef CONFIG_PPC32
965 /*
966 * Handle the case where we might be booting from an old kexec
967 * image that setup the mem_rsvmap as pairs of 32-bit values
968 */
969 if (*reserve_map > 0xffffffffull) {
970 u32 base_32, size_32;
971 u32 *reserve_map_32 = (u32 *)reserve_map;
972
973 while (1) {
974 base_32 = *(reserve_map_32++);
975 size_32 = *(reserve_map_32++);
976 if (size_32 == 0)
977 break;
978 /* skip if the reservation is for the blob */
979 if (base_32 == self_base && size_32 == self_size)
980 continue;
981 DBG("reserving: %x -> %x\n", base_32, size_32);
982 lmb_reserve(base_32, size_32);
983 }
984 return;
985 }
986 #endif
987 while (1) {
988 base = *(reserve_map++);
989 size = *(reserve_map++);
990 if (size == 0)
991 break;
992 DBG("reserving: %llx -> %llx\n", base, size);
993 lmb_reserve(base, size);
994 }
995
996 #if 0
997 DBG("memory reserved, lmbs :\n");
998 lmb_dump_all();
999 #endif
1000 }
1001
1002 void __init early_init_devtree(void *params)
1003 {
1004 DBG(" -> early_init_devtree(%p)\n", params);
1005
1006 /* Setup flat device-tree pointer */
1007 initial_boot_params = params;
1008
1009 #ifdef CONFIG_PPC_RTAS
1010 /* Some machines might need RTAS info for debugging, grab it now. */
1011 of_scan_flat_dt(early_init_dt_scan_rtas, NULL);
1012 #endif
1013
1014 /* Retrieve various informations from the /chosen node of the
1015 * device-tree, including the platform type, initrd location and
1016 * size, TCE reserve, and more ...
1017 */
1018 of_scan_flat_dt(early_init_dt_scan_chosen, NULL);
1019
1020 /* Scan memory nodes and rebuild LMBs */
1021 lmb_init();
1022 of_scan_flat_dt(early_init_dt_scan_root, NULL);
1023 of_scan_flat_dt(early_init_dt_scan_memory, NULL);
1024
1025 /* Save command line for /proc/cmdline and then parse parameters */
1026 strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE);
1027 parse_early_param();
1028
1029 /* Reserve LMB regions used by kernel, initrd, dt, etc... */
1030 lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
1031 reserve_kdump_trampoline();
1032 reserve_crashkernel();
1033 early_reserve_mem();
1034
1035 lmb_enforce_memory_limit(memory_limit);
1036 lmb_analyze();
1037
1038 DBG("Phys. mem: %lx\n", lmb_phys_mem_size());
1039
1040 /* We may need to relocate the flat tree, do it now.
1041 * FIXME .. and the initrd too? */
1042 move_device_tree();
1043
1044 DBG("Scanning CPUs ...\n");
1045
1046 /* Retreive CPU related informations from the flat tree
1047 * (altivec support, boot CPU ID, ...)
1048 */
1049 of_scan_flat_dt(early_init_dt_scan_cpus, NULL);
1050
1051 DBG(" <- early_init_devtree()\n");
1052 }
1053
1054
1055 /**
1056 * Indicates whether the root node has a given value in its
1057 * compatible property.
1058 */
1059 int machine_is_compatible(const char *compat)
1060 {
1061 struct device_node *root;
1062 int rc = 0;
1063
1064 root = of_find_node_by_path("/");
1065 if (root) {
1066 rc = of_device_is_compatible(root, compat);
1067 of_node_put(root);
1068 }
1069 return rc;
1070 }
1071 EXPORT_SYMBOL(machine_is_compatible);
1072
1073 /*******
1074 *
1075 * New implementation of the OF "find" APIs, return a refcounted
1076 * object, call of_node_put() when done. The device tree and list
1077 * are protected by a rw_lock.
1078 *
1079 * Note that property management will need some locking as well,
1080 * this isn't dealt with yet.
1081 *
1082 *******/
1083
1084 /**
1085 * of_find_node_by_phandle - Find a node given a phandle
1086 * @handle: phandle of the node to find
1087 *
1088 * Returns a node pointer with refcount incremented, use
1089 * of_node_put() on it when done.
1090 */
1091 struct device_node *of_find_node_by_phandle(phandle handle)
1092 {
1093 struct device_node *np;
1094
1095 read_lock(&devtree_lock);
1096 for (np = allnodes; np != 0; np = np->allnext)
1097 if (np->linux_phandle == handle)
1098 break;
1099 of_node_get(np);
1100 read_unlock(&devtree_lock);
1101 return np;
1102 }
1103 EXPORT_SYMBOL(of_find_node_by_phandle);
1104
1105 /**
1106 * of_find_all_nodes - Get next node in global list
1107 * @prev: Previous node or NULL to start iteration
1108 * of_node_put() will be called on it
1109 *
1110 * Returns a node pointer with refcount incremented, use
1111 * of_node_put() on it when done.
1112 */
1113 struct device_node *of_find_all_nodes(struct device_node *prev)
1114 {
1115 struct device_node *np;
1116
1117 read_lock(&devtree_lock);
1118 np = prev ? prev->allnext : allnodes;
1119 for (; np != 0; np = np->allnext)
1120 if (of_node_get(np))
1121 break;
1122 of_node_put(prev);
1123 read_unlock(&devtree_lock);
1124 return np;
1125 }
1126 EXPORT_SYMBOL(of_find_all_nodes);
1127
1128 /**
1129 * of_node_get - Increment refcount of a node
1130 * @node: Node to inc refcount, NULL is supported to
1131 * simplify writing of callers
1132 *
1133 * Returns node.
1134 */
1135 struct device_node *of_node_get(struct device_node *node)
1136 {
1137 if (node)
1138 kref_get(&node->kref);
1139 return node;
1140 }
1141 EXPORT_SYMBOL(of_node_get);
1142
1143 static inline struct device_node * kref_to_device_node(struct kref *kref)
1144 {
1145 return container_of(kref, struct device_node, kref);
1146 }
1147
1148 /**
1149 * of_node_release - release a dynamically allocated node
1150 * @kref: kref element of the node to be released
1151 *
1152 * In of_node_put() this function is passed to kref_put()
1153 * as the destructor.
1154 */
1155 static void of_node_release(struct kref *kref)
1156 {
1157 struct device_node *node = kref_to_device_node(kref);
1158 struct property *prop = node->properties;
1159
1160 /* We should never be releasing nodes that haven't been detached. */
1161 if (!of_node_check_flag(node, OF_DETACHED)) {
1162 printk("WARNING: Bad of_node_put() on %s\n", node->full_name);
1163 dump_stack();
1164 kref_init(&node->kref);
1165 return;
1166 }
1167
1168 if (!of_node_check_flag(node, OF_DYNAMIC))
1169 return;
1170
1171 while (prop) {
1172 struct property *next = prop->next;
1173 kfree(prop->name);
1174 kfree(prop->value);
1175 kfree(prop);
1176 prop = next;
1177
1178 if (!prop) {
1179 prop = node->deadprops;
1180 node->deadprops = NULL;
1181 }
1182 }
1183 kfree(node->full_name);
1184 kfree(node->data);
1185 kfree(node);
1186 }
1187
1188 /**
1189 * of_node_put - Decrement refcount of a node
1190 * @node: Node to dec refcount, NULL is supported to
1191 * simplify writing of callers
1192 *
1193 */
1194 void of_node_put(struct device_node *node)
1195 {
1196 if (node)
1197 kref_put(&node->kref, of_node_release);
1198 }
1199 EXPORT_SYMBOL(of_node_put);
1200
1201 /*
1202 * Plug a device node into the tree and global list.
1203 */
1204 void of_attach_node(struct device_node *np)
1205 {
1206 write_lock(&devtree_lock);
1207 np->sibling = np->parent->child;
1208 np->allnext = allnodes;
1209 np->parent->child = np;
1210 allnodes = np;
1211 write_unlock(&devtree_lock);
1212 }
1213
1214 /*
1215 * "Unplug" a node from the device tree. The caller must hold
1216 * a reference to the node. The memory associated with the node
1217 * is not freed until its refcount goes to zero.
1218 */
1219 void of_detach_node(struct device_node *np)
1220 {
1221 struct device_node *parent;
1222
1223 write_lock(&devtree_lock);
1224
1225 parent = np->parent;
1226 if (!parent)
1227 goto out_unlock;
1228
1229 if (allnodes == np)
1230 allnodes = np->allnext;
1231 else {
1232 struct device_node *prev;
1233 for (prev = allnodes;
1234 prev->allnext != np;
1235 prev = prev->allnext)
1236 ;
1237 prev->allnext = np->allnext;
1238 }
1239
1240 if (parent->child == np)
1241 parent->child = np->sibling;
1242 else {
1243 struct device_node *prevsib;
1244 for (prevsib = np->parent->child;
1245 prevsib->sibling != np;
1246 prevsib = prevsib->sibling)
1247 ;
1248 prevsib->sibling = np->sibling;
1249 }
1250
1251 of_node_set_flag(np, OF_DETACHED);
1252
1253 out_unlock:
1254 write_unlock(&devtree_lock);
1255 }
1256
1257 #ifdef CONFIG_PPC_PSERIES
1258 /*
1259 * Fix up the uninitialized fields in a new device node:
1260 * name, type and pci-specific fields
1261 */
1262
1263 static int of_finish_dynamic_node(struct device_node *node)
1264 {
1265 struct device_node *parent = of_get_parent(node);
1266 int err = 0;
1267 const phandle *ibm_phandle;
1268
1269 node->name = of_get_property(node, "name", NULL);
1270 node->type = of_get_property(node, "device_type", NULL);
1271
1272 if (!node->name)
1273 node->name = "<NULL>";
1274 if (!node->type)
1275 node->type = "<NULL>";
1276
1277 if (!parent) {
1278 err = -ENODEV;
1279 goto out;
1280 }
1281
1282 /* We don't support that function on PowerMac, at least
1283 * not yet
1284 */
1285 if (machine_is(powermac))
1286 return -ENODEV;
1287
1288 /* fix up new node's linux_phandle field */
1289 if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL)))
1290 node->linux_phandle = *ibm_phandle;
1291
1292 out:
1293 of_node_put(parent);
1294 return err;
1295 }
1296
1297 static int prom_reconfig_notifier(struct notifier_block *nb,
1298 unsigned long action, void *node)
1299 {
1300 int err;
1301
1302 switch (action) {
1303 case PSERIES_RECONFIG_ADD:
1304 err = of_finish_dynamic_node(node);
1305 if (err < 0) {
1306 printk(KERN_ERR "finish_node returned %d\n", err);
1307 err = NOTIFY_BAD;
1308 }
1309 break;
1310 default:
1311 err = NOTIFY_DONE;
1312 break;
1313 }
1314 return err;
1315 }
1316
1317 static struct notifier_block prom_reconfig_nb = {
1318 .notifier_call = prom_reconfig_notifier,
1319 .priority = 10, /* This one needs to run first */
1320 };
1321
1322 static int __init prom_reconfig_setup(void)
1323 {
1324 return pSeries_reconfig_notifier_register(&prom_reconfig_nb);
1325 }
1326 __initcall(prom_reconfig_setup);
1327 #endif
1328
1329 /*
1330 * Add a property to a node
1331 */
1332 int prom_add_property(struct device_node* np, struct property* prop)
1333 {
1334 struct property **next;
1335
1336 prop->next = NULL;
1337 write_lock(&devtree_lock);
1338 next = &np->properties;
1339 while (*next) {
1340 if (strcmp(prop->name, (*next)->name) == 0) {
1341 /* duplicate ! don't insert it */
1342 write_unlock(&devtree_lock);
1343 return -1;
1344 }
1345 next = &(*next)->next;
1346 }
1347 *next = prop;
1348 write_unlock(&devtree_lock);
1349
1350 #ifdef CONFIG_PROC_DEVICETREE
1351 /* try to add to proc as well if it was initialized */
1352 if (np->pde)
1353 proc_device_tree_add_prop(np->pde, prop);
1354 #endif /* CONFIG_PROC_DEVICETREE */
1355
1356 return 0;
1357 }
1358
1359 /*
1360 * Remove a property from a node. Note that we don't actually
1361 * remove it, since we have given out who-knows-how-many pointers
1362 * to the data using get-property. Instead we just move the property
1363 * to the "dead properties" list, so it won't be found any more.
1364 */
1365 int prom_remove_property(struct device_node *np, struct property *prop)
1366 {
1367 struct property **next;
1368 int found = 0;
1369
1370 write_lock(&devtree_lock);
1371 next = &np->properties;
1372 while (*next) {
1373 if (*next == prop) {
1374 /* found the node */
1375 *next = prop->next;
1376 prop->next = np->deadprops;
1377 np->deadprops = prop;
1378 found = 1;
1379 break;
1380 }
1381 next = &(*next)->next;
1382 }
1383 write_unlock(&devtree_lock);
1384
1385 if (!found)
1386 return -ENODEV;
1387
1388 #ifdef CONFIG_PROC_DEVICETREE
1389 /* try to remove the proc node as well */
1390 if (np->pde)
1391 proc_device_tree_remove_prop(np->pde, prop);
1392 #endif /* CONFIG_PROC_DEVICETREE */
1393
1394 return 0;
1395 }
1396
1397 /*
1398 * Update a property in a node. Note that we don't actually
1399 * remove it, since we have given out who-knows-how-many pointers
1400 * to the data using get-property. Instead we just move the property
1401 * to the "dead properties" list, and add the new property to the
1402 * property list
1403 */
1404 int prom_update_property(struct device_node *np,
1405 struct property *newprop,
1406 struct property *oldprop)
1407 {
1408 struct property **next;
1409 int found = 0;
1410
1411 write_lock(&devtree_lock);
1412 next = &np->properties;
1413 while (*next) {
1414 if (*next == oldprop) {
1415 /* found the node */
1416 newprop->next = oldprop->next;
1417 *next = newprop;
1418 oldprop->next = np->deadprops;
1419 np->deadprops = oldprop;
1420 found = 1;
1421 break;
1422 }
1423 next = &(*next)->next;
1424 }
1425 write_unlock(&devtree_lock);
1426
1427 if (!found)
1428 return -ENODEV;
1429
1430 #ifdef CONFIG_PROC_DEVICETREE
1431 /* try to add to proc as well if it was initialized */
1432 if (np->pde)
1433 proc_device_tree_update_prop(np->pde, newprop, oldprop);
1434 #endif /* CONFIG_PROC_DEVICETREE */
1435
1436 return 0;
1437 }
1438
1439
1440 /* Find the device node for a given logical cpu number, also returns the cpu
1441 * local thread number (index in ibm,interrupt-server#s) if relevant and
1442 * asked for (non NULL)
1443 */
1444 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
1445 {
1446 int hardid;
1447 struct device_node *np;
1448
1449 hardid = get_hard_smp_processor_id(cpu);
1450
1451 for_each_node_by_type(np, "cpu") {
1452 const u32 *intserv;
1453 unsigned int plen, t;
1454
1455 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist
1456 * fallback to "reg" property and assume no threads
1457 */
1458 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s",
1459 &plen);
1460 if (intserv == NULL) {
1461 const u32 *reg = of_get_property(np, "reg", NULL);
1462 if (reg == NULL)
1463 continue;
1464 if (*reg == hardid) {
1465 if (thread)
1466 *thread = 0;
1467 return np;
1468 }
1469 } else {
1470 plen /= sizeof(u32);
1471 for (t = 0; t < plen; t++) {
1472 if (hardid == intserv[t]) {
1473 if (thread)
1474 *thread = t;
1475 return np;
1476 }
1477 }
1478 }
1479 }
1480 return NULL;
1481 }
1482 EXPORT_SYMBOL(of_get_cpu_node);
1483
1484 #if defined(CONFIG_DEBUG_FS) && defined(DEBUG)
1485 static struct debugfs_blob_wrapper flat_dt_blob;
1486
1487 static int __init export_flat_device_tree(void)
1488 {
1489 struct dentry *d;
1490
1491 flat_dt_blob.data = initial_boot_params;
1492 flat_dt_blob.size = initial_boot_params->totalsize;
1493
1494 d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR,
1495 powerpc_debugfs_root, &flat_dt_blob);
1496 if (!d)
1497 return 1;
1498
1499 return 0;
1500 }
1501 __initcall(export_flat_device_tree);
1502 #endif
WRT350N Kernel Patches