?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: a P4 is a P6 not an i486
[wrt350n-kernel.git] / arch / powerpc / kernel / prom.c
blobeac97f48b9b8df29171e59476a95b50f01a6ef67
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 #ifdef CONFIG_PPC64
587 static void __init check_cpu_slb_size(unsigned long node)
588 {
589 u32 *slb_size_ptr;
590
591 slb_size_ptr = of_get_flat_dt_prop(node, "ibm,slb-size", NULL);
592 if (slb_size_ptr != NULL) {
593 mmu_slb_size = *slb_size_ptr;
594 }
595 }
596 #else
597 #define check_cpu_slb_size(node) do { } while(0)
598 #endif
599
600 static struct feature_property {
601 const char *name;
602 u32 min_value;
603 unsigned long cpu_feature;
604 unsigned long cpu_user_ftr;
605 } feature_properties[] __initdata = {
606 #ifdef CONFIG_ALTIVEC
607 {"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
608 {"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
609 #endif /* CONFIG_ALTIVEC */
610 #ifdef CONFIG_PPC64
611 {"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP},
612 {"ibm,purr", 1, CPU_FTR_PURR, 0},
613 {"ibm,spurr", 1, CPU_FTR_SPURR, 0},
614 #endif /* CONFIG_PPC64 */
615 };
616
617 #if defined(CONFIG_44x) && defined(CONFIG_PPC_FPU)
618 static inline void identical_pvr_fixup(unsigned long node)
619 {
620 unsigned int pvr;
621 char *model = of_get_flat_dt_prop(node, "model", NULL);
622
623 /*
624 * Since 440GR(x)/440EP(x) processors have the same pvr,
625 * we check the node path and set bit 28 in the cur_cpu_spec
626 * pvr for EP(x) processor version. This bit is always 0 in
627 * the "real" pvr. Then we call identify_cpu again with
628 * the new logical pvr to enable FPU support.
629 */
630 if (model && strstr(model, "440EP")) {
631 pvr = cur_cpu_spec->pvr_value | 0x8;
632 identify_cpu(0, pvr);
633 DBG("Using logical pvr %x for %s\n", pvr, model);
634 }
635 }
636 #else
637 #define identical_pvr_fixup(node) do { } while(0)
638 #endif
639
640 static void __init check_cpu_feature_properties(unsigned long node)
641 {
642 unsigned long i;
643 struct feature_property *fp = feature_properties;
644 const u32 *prop;
645
646 for (i = 0; i < ARRAY_SIZE(feature_properties); ++i, ++fp) {
647 prop = of_get_flat_dt_prop(node, fp->name, NULL);
648 if (prop && *prop >= fp->min_value) {
649 cur_cpu_spec->cpu_features |= fp->cpu_feature;
650 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr;
651 }
652 }
653 }
654
655 static int __init early_init_dt_scan_cpus(unsigned long node,
656 const char *uname, int depth,
657 void *data)
658 {
659 static int logical_cpuid = 0;
660 char *type = of_get_flat_dt_prop(node, "device_type", NULL);
661 const u32 *prop;
662 const u32 *intserv;
663 int i, nthreads;
664 unsigned long len;
665 int found = 0;
666
667 /* We are scanning "cpu" nodes only */
668 if (type == NULL || strcmp(type, "cpu") != 0)
669 return 0;
670
671 /* Get physical cpuid */
672 intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len);
673 if (intserv) {
674 nthreads = len / sizeof(int);
675 } else {
676 intserv = of_get_flat_dt_prop(node, "reg", NULL);
677 nthreads = 1;
678 }
679
680 /*
681 * Now see if any of these threads match our boot cpu.
682 * NOTE: This must match the parsing done in smp_setup_cpu_maps.
683 */
684 for (i = 0; i < nthreads; i++) {
685 /*
686 * version 2 of the kexec param format adds the phys cpuid of
687 * booted proc.
688 */
689 if (initial_boot_params && initial_boot_params->version >= 2) {
690 if (intserv[i] ==
691 initial_boot_params->boot_cpuid_phys) {
692 found = 1;
693 break;
694 }
695 } else {
696 /*
697 * Check if it's the boot-cpu, set it's hw index now,
698 * unfortunately this format did not support booting
699 * off secondary threads.
700 */
701 if (of_get_flat_dt_prop(node,
702 "linux,boot-cpu", NULL) != NULL) {
703 found = 1;
704 break;
705 }
706 }
707
708 #ifdef CONFIG_SMP
709 /* logical cpu id is always 0 on UP kernels */
710 logical_cpuid++;
711 #endif
712 }
713
714 if (found) {
715 DBG("boot cpu: logical %d physical %d\n", logical_cpuid,
716 intserv[i]);
717 boot_cpuid = logical_cpuid;
718 set_hard_smp_processor_id(boot_cpuid, intserv[i]);
719
720 /*
721 * PAPR defines "logical" PVR values for cpus that
722 * meet various levels of the architecture:
723 * 0x0f000001 Architecture version 2.04
724 * 0x0f000002 Architecture version 2.05
725 * If the cpu-version property in the cpu node contains
726 * such a value, we call identify_cpu again with the
727 * logical PVR value in order to use the cpu feature
728 * bits appropriate for the architecture level.
729 *
730 * A POWER6 partition in "POWER6 architected" mode
731 * uses the 0x0f000002 PVR value; in POWER5+ mode
732 * it uses 0x0f000001.
733 */
734 prop = of_get_flat_dt_prop(node, "cpu-version", NULL);
735 if (prop && (*prop & 0xff000000) == 0x0f000000)
736 identify_cpu(0, *prop);
737
738 identical_pvr_fixup(node);
739 }
740
741 check_cpu_feature_properties(node);
742 check_cpu_pa_features(node);
743 check_cpu_slb_size(node);
744
745 #ifdef CONFIG_PPC_PSERIES
746 if (nthreads > 1)
747 cur_cpu_spec->cpu_features |= CPU_FTR_SMT;
748 else
749 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT;
750 #endif
751
752 return 0;
753 }
754
755 #ifdef CONFIG_BLK_DEV_INITRD
756 static void __init early_init_dt_check_for_initrd(unsigned long node)
757 {
758 unsigned long l;
759 u32 *prop;
760
761 DBG("Looking for initrd properties... ");
762
763 prop = of_get_flat_dt_prop(node, "linux,initrd-start", &l);
764 if (prop) {
765 initrd_start = (unsigned long)__va(of_read_ulong(prop, l/4));
766
767 prop = of_get_flat_dt_prop(node, "linux,initrd-end", &l);
768 if (prop) {
769 initrd_end = (unsigned long)
770 __va(of_read_ulong(prop, l/4));
771 initrd_below_start_ok = 1;
772 } else {
773 initrd_start = 0;
774 }
775 }
776
777 DBG("initrd_start=0x%lx initrd_end=0x%lx\n", initrd_start, initrd_end);
778 }
779 #else
780 static inline void early_init_dt_check_for_initrd(unsigned long node)
781 {
782 }
783 #endif /* CONFIG_BLK_DEV_INITRD */
784
785 static int __init early_init_dt_scan_chosen(unsigned long node,
786 const char *uname, int depth, void *data)
787 {
788 unsigned long *lprop;
789 unsigned long l;
790 char *p;
791
792 DBG("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
793
794 if (depth != 1 ||
795 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
796 return 0;
797
798 #ifdef CONFIG_PPC64
799 /* check if iommu is forced on or off */
800 if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL)
801 iommu_is_off = 1;
802 if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL)
803 iommu_force_on = 1;
804 #endif
805
806 /* mem=x on the command line is the preferred mechanism */
807 lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL);
808 if (lprop)
809 memory_limit = *lprop;
810
811 #ifdef CONFIG_PPC64
812 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL);
813 if (lprop)
814 tce_alloc_start = *lprop;
815 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL);
816 if (lprop)
817 tce_alloc_end = *lprop;
818 #endif
819
820 #ifdef CONFIG_KEXEC
821 lprop = (u64*)of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL);
822 if (lprop)
823 crashk_res.start = *lprop;
824
825 lprop = (u64*)of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL);
826 if (lprop)
827 crashk_res.end = crashk_res.start + *lprop - 1;
828 #endif
829
830 early_init_dt_check_for_initrd(node);
831
832 /* Retreive command line */
833 p = of_get_flat_dt_prop(node, "bootargs", &l);
834 if (p != NULL && l > 0)
835 strlcpy(cmd_line, p, min((int)l, COMMAND_LINE_SIZE));
836
837 #ifdef CONFIG_CMDLINE
838 if (p == NULL || l == 0 || (l == 1 && (*p) == 0))
839 strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
840 #endif /* CONFIG_CMDLINE */
841
842 DBG("Command line is: %s\n", cmd_line);
843
844 /* break now */
845 return 1;
846 }
847
848 static int __init early_init_dt_scan_root(unsigned long node,
849 const char *uname, int depth, void *data)
850 {
851 u32 *prop;
852
853 if (depth != 0)
854 return 0;
855
856 prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
857 dt_root_size_cells = (prop == NULL) ? 1 : *prop;
858 DBG("dt_root_size_cells = %x\n", dt_root_size_cells);
859
860 prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
861 dt_root_addr_cells = (prop == NULL) ? 2 : *prop;
862 DBG("dt_root_addr_cells = %x\n", dt_root_addr_cells);
863
864 /* break now */
865 return 1;
866 }
867
868 static u64 __init dt_mem_next_cell(int s, cell_t **cellp)
869 {
870 cell_t *p = *cellp;
871
872 *cellp = p + s;
873 return of_read_number(p, s);
874 }
875
876 #ifdef CONFIG_PPC_PSERIES
877 /*
878 * Interpret the ibm,dynamic-memory property in the
879 * /ibm,dynamic-reconfiguration-memory node.
880 * This contains a list of memory blocks along with NUMA affinity
881 * information.
882 */
883 static int __init early_init_dt_scan_drconf_memory(unsigned long node)
884 {
885 cell_t *dm, *ls;
886 unsigned long l, n, flags;
887 u64 base, size, lmb_size;
888
889 ls = (cell_t *)of_get_flat_dt_prop(node, "ibm,lmb-size", &l);
890 if (ls == NULL || l < dt_root_size_cells * sizeof(cell_t))
891 return 0;
892 lmb_size = dt_mem_next_cell(dt_root_size_cells, &ls);
893
894 dm = (cell_t *)of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l);
895 if (dm == NULL || l < sizeof(cell_t))
896 return 0;
897
898 n = *dm++; /* number of entries */
899 if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(cell_t))
900 return 0;
901
902 for (; n != 0; --n) {
903 base = dt_mem_next_cell(dt_root_addr_cells, &dm);
904 flags = dm[3];
905 /* skip DRC index, pad, assoc. list index, flags */
906 dm += 4;
907 /* skip this block if the reserved bit is set in flags (0x80)
908 or if the block is not assigned to this partition (0x8) */
909 if ((flags & 0x80) || !(flags & 0x8))
910 continue;
911 size = lmb_size;
912 if (iommu_is_off) {
913 if (base >= 0x80000000ul)
914 continue;
915 if ((base + size) > 0x80000000ul)
916 size = 0x80000000ul - base;
917 }
918 lmb_add(base, size);
919 }
920 lmb_dump_all();
921 return 0;
922 }
923 #else
924 #define early_init_dt_scan_drconf_memory(node) 0
925 #endif /* CONFIG_PPC_PSERIES */
926
927 static int __init early_init_dt_scan_memory(unsigned long node,
928 const char *uname, int depth, void *data)
929 {
930 char *type = of_get_flat_dt_prop(node, "device_type", NULL);
931 cell_t *reg, *endp;
932 unsigned long l;
933
934 /* Look for the ibm,dynamic-reconfiguration-memory node */
935 if (depth == 1 &&
936 strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0)
937 return early_init_dt_scan_drconf_memory(node);
938
939 /* We are scanning "memory" nodes only */
940 if (type == NULL) {
941 /*
942 * The longtrail doesn't have a device_type on the
943 * /memory node, so look for the node called /memory@0.
944 */
945 if (depth != 1 || strcmp(uname, "memory@0") != 0)
946 return 0;
947 } else if (strcmp(type, "memory") != 0)
948 return 0;
949
950 reg = (cell_t *)of_get_flat_dt_prop(node, "linux,usable-memory", &l);
951 if (reg == NULL)
952 reg = (cell_t *)of_get_flat_dt_prop(node, "reg", &l);
953 if (reg == NULL)
954 return 0;
955
956 endp = reg + (l / sizeof(cell_t));
957
958 DBG("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
959 uname, l, reg[0], reg[1], reg[2], reg[3]);
960
961 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
962 u64 base, size;
963
964 base = dt_mem_next_cell(dt_root_addr_cells, &reg);
965 size = dt_mem_next_cell(dt_root_size_cells, &reg);
966
967 if (size == 0)
968 continue;
969 DBG(" - %llx , %llx\n", (unsigned long long)base,
970 (unsigned long long)size);
971 #ifdef CONFIG_PPC64
972 if (iommu_is_off) {
973 if (base >= 0x80000000ul)
974 continue;
975 if ((base + size) > 0x80000000ul)
976 size = 0x80000000ul - base;
977 }
978 #endif
979 lmb_add(base, size);
980 }
981 return 0;
982 }
983
984 static void __init early_reserve_mem(void)
985 {
986 u64 base, size;
987 u64 *reserve_map;
988 unsigned long self_base;
989 unsigned long self_size;
990
991 reserve_map = (u64 *)(((unsigned long)initial_boot_params) +
992 initial_boot_params->off_mem_rsvmap);
993
994 /* before we do anything, lets reserve the dt blob */
995 self_base = __pa((unsigned long)initial_boot_params);
996 self_size = initial_boot_params->totalsize;
997 lmb_reserve(self_base, self_size);
998
999 #ifdef CONFIG_BLK_DEV_INITRD
1000 /* then reserve the initrd, if any */
1001 if (initrd_start && (initrd_end > initrd_start))
1002 lmb_reserve(__pa(initrd_start), initrd_end - initrd_start);
1003 #endif /* CONFIG_BLK_DEV_INITRD */
1004
1005 #ifdef CONFIG_PPC32
1006 /*
1007 * Handle the case where we might be booting from an old kexec
1008 * image that setup the mem_rsvmap as pairs of 32-bit values
1009 */
1010 if (*reserve_map > 0xffffffffull) {
1011 u32 base_32, size_32;
1012 u32 *reserve_map_32 = (u32 *)reserve_map;
1013
1014 while (1) {
1015 base_32 = *(reserve_map_32++);
1016 size_32 = *(reserve_map_32++);
1017 if (size_32 == 0)
1018 break;
1019 /* skip if the reservation is for the blob */
1020 if (base_32 == self_base && size_32 == self_size)
1021 continue;
1022 DBG("reserving: %x -> %x\n", base_32, size_32);
1023 lmb_reserve(base_32, size_32);
1024 }
1025 return;
1026 }
1027 #endif
1028 while (1) {
1029 base = *(reserve_map++);
1030 size = *(reserve_map++);
1031 if (size == 0)
1032 break;
1033 DBG("reserving: %llx -> %llx\n", base, size);
1034 lmb_reserve(base, size);
1035 }
1036
1037 #if 0
1038 DBG("memory reserved, lmbs :\n");
1039 lmb_dump_all();
1040 #endif
1041 }
1042
1043 void __init early_init_devtree(void *params)
1044 {
1045 DBG(" -> early_init_devtree(%p)\n", params);
1046
1047 /* Setup flat device-tree pointer */
1048 initial_boot_params = params;
1049
1050 #ifdef CONFIG_PPC_RTAS
1051 /* Some machines might need RTAS info for debugging, grab it now. */
1052 of_scan_flat_dt(early_init_dt_scan_rtas, NULL);
1053 #endif
1054
1055 /* Retrieve various informations from the /chosen node of the
1056 * device-tree, including the platform type, initrd location and
1057 * size, TCE reserve, and more ...
1058 */
1059 of_scan_flat_dt(early_init_dt_scan_chosen, NULL);
1060
1061 /* Scan memory nodes and rebuild LMBs */
1062 lmb_init();
1063 of_scan_flat_dt(early_init_dt_scan_root, NULL);
1064 of_scan_flat_dt(early_init_dt_scan_memory, NULL);
1065
1066 /* Save command line for /proc/cmdline and then parse parameters */
1067 strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE);
1068 parse_early_param();
1069
1070 /* Reserve LMB regions used by kernel, initrd, dt, etc... */
1071 lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
1072 reserve_kdump_trampoline();
1073 reserve_crashkernel();
1074 early_reserve_mem();
1075
1076 lmb_enforce_memory_limit(memory_limit);
1077 lmb_analyze();
1078
1079 DBG("Phys. mem: %lx\n", lmb_phys_mem_size());
1080
1081 /* We may need to relocate the flat tree, do it now.
1082 * FIXME .. and the initrd too? */
1083 move_device_tree();
1084
1085 DBG("Scanning CPUs ...\n");
1086
1087 /* Retreive CPU related informations from the flat tree
1088 * (altivec support, boot CPU ID, ...)
1089 */
1090 of_scan_flat_dt(early_init_dt_scan_cpus, NULL);
1091
1092 DBG(" <- early_init_devtree()\n");
1093 }
1094
1095
1096 /**
1097 * Indicates whether the root node has a given value in its
1098 * compatible property.
1099 */
1100 int machine_is_compatible(const char *compat)
1101 {
1102 struct device_node *root;
1103 int rc = 0;
1104
1105 root = of_find_node_by_path("/");
1106 if (root) {
1107 rc = of_device_is_compatible(root, compat);
1108 of_node_put(root);
1109 }
1110 return rc;
1111 }
1112 EXPORT_SYMBOL(machine_is_compatible);
1113
1114 /*******
1115 *
1116 * New implementation of the OF "find" APIs, return a refcounted
1117 * object, call of_node_put() when done. The device tree and list
1118 * are protected by a rw_lock.
1119 *
1120 * Note that property management will need some locking as well,
1121 * this isn't dealt with yet.
1122 *
1123 *******/
1124
1125 /**
1126 * of_find_node_by_phandle - Find a node given a phandle
1127 * @handle: phandle of the node to find
1128 *
1129 * Returns a node pointer with refcount incremented, use
1130 * of_node_put() on it when done.
1131 */
1132 struct device_node *of_find_node_by_phandle(phandle handle)
1133 {
1134 struct device_node *np;
1135
1136 read_lock(&devtree_lock);
1137 for (np = allnodes; np != 0; np = np->allnext)
1138 if (np->linux_phandle == handle)
1139 break;
1140 of_node_get(np);
1141 read_unlock(&devtree_lock);
1142 return np;
1143 }
1144 EXPORT_SYMBOL(of_find_node_by_phandle);
1145
1146 /**
1147 * of_find_all_nodes - Get next node in global list
1148 * @prev: Previous node or NULL to start iteration
1149 * of_node_put() will be called on it
1150 *
1151 * Returns a node pointer with refcount incremented, use
1152 * of_node_put() on it when done.
1153 */
1154 struct device_node *of_find_all_nodes(struct device_node *prev)
1155 {
1156 struct device_node *np;
1157
1158 read_lock(&devtree_lock);
1159 np = prev ? prev->allnext : allnodes;
1160 for (; np != 0; np = np->allnext)
1161 if (of_node_get(np))
1162 break;
1163 of_node_put(prev);
1164 read_unlock(&devtree_lock);
1165 return np;
1166 }
1167 EXPORT_SYMBOL(of_find_all_nodes);
1168
1169 /**
1170 * of_node_get - Increment refcount of a node
1171 * @node: Node to inc refcount, NULL is supported to
1172 * simplify writing of callers
1173 *
1174 * Returns node.
1175 */
1176 struct device_node *of_node_get(struct device_node *node)
1177 {
1178 if (node)
1179 kref_get(&node->kref);
1180 return node;
1181 }
1182 EXPORT_SYMBOL(of_node_get);
1183
1184 static inline struct device_node * kref_to_device_node(struct kref *kref)
1185 {
1186 return container_of(kref, struct device_node, kref);
1187 }
1188
1189 /**
1190 * of_node_release - release a dynamically allocated node
1191 * @kref: kref element of the node to be released
1192 *
1193 * In of_node_put() this function is passed to kref_put()
1194 * as the destructor.
1195 */
1196 static void of_node_release(struct kref *kref)
1197 {
1198 struct device_node *node = kref_to_device_node(kref);
1199 struct property *prop = node->properties;
1200
1201 /* We should never be releasing nodes that haven't been detached. */
1202 if (!of_node_check_flag(node, OF_DETACHED)) {
1203 printk("WARNING: Bad of_node_put() on %s\n", node->full_name);
1204 dump_stack();
1205 kref_init(&node->kref);
1206 return;
1207 }
1208
1209 if (!of_node_check_flag(node, OF_DYNAMIC))
1210 return;
1211
1212 while (prop) {
1213 struct property *next = prop->next;
1214 kfree(prop->name);
1215 kfree(prop->value);
1216 kfree(prop);
1217 prop = next;
1218
1219 if (!prop) {
1220 prop = node->deadprops;
1221 node->deadprops = NULL;
1222 }
1223 }
1224 kfree(node->full_name);
1225 kfree(node->data);
1226 kfree(node);
1227 }
1228
1229 /**
1230 * of_node_put - Decrement refcount of a node
1231 * @node: Node to dec refcount, NULL is supported to
1232 * simplify writing of callers
1233 *
1234 */
1235 void of_node_put(struct device_node *node)
1236 {
1237 if (node)
1238 kref_put(&node->kref, of_node_release);
1239 }
1240 EXPORT_SYMBOL(of_node_put);
1241
1242 /*
1243 * Plug a device node into the tree and global list.
1244 */
1245 void of_attach_node(struct device_node *np)
1246 {
1247 write_lock(&devtree_lock);
1248 np->sibling = np->parent->child;
1249 np->allnext = allnodes;
1250 np->parent->child = np;
1251 allnodes = np;
1252 write_unlock(&devtree_lock);
1253 }
1254
1255 /*
1256 * "Unplug" a node from the device tree. The caller must hold
1257 * a reference to the node. The memory associated with the node
1258 * is not freed until its refcount goes to zero.
1259 */
1260 void of_detach_node(struct device_node *np)
1261 {
1262 struct device_node *parent;
1263
1264 write_lock(&devtree_lock);
1265
1266 parent = np->parent;
1267 if (!parent)
1268 goto out_unlock;
1269
1270 if (allnodes == np)
1271 allnodes = np->allnext;
1272 else {
1273 struct device_node *prev;
1274 for (prev = allnodes;
1275 prev->allnext != np;
1276 prev = prev->allnext)
1277 ;
1278 prev->allnext = np->allnext;
1279 }
1280
1281 if (parent->child == np)
1282 parent->child = np->sibling;
1283 else {
1284 struct device_node *prevsib;
1285 for (prevsib = np->parent->child;
1286 prevsib->sibling != np;
1287 prevsib = prevsib->sibling)
1288 ;
1289 prevsib->sibling = np->sibling;
1290 }
1291
1292 of_node_set_flag(np, OF_DETACHED);
1293
1294 out_unlock:
1295 write_unlock(&devtree_lock);
1296 }
1297
1298 #ifdef CONFIG_PPC_PSERIES
1299 /*
1300 * Fix up the uninitialized fields in a new device node:
1301 * name, type and pci-specific fields
1302 */
1303
1304 static int of_finish_dynamic_node(struct device_node *node)
1305 {
1306 struct device_node *parent = of_get_parent(node);
1307 int err = 0;
1308 const phandle *ibm_phandle;
1309
1310 node->name = of_get_property(node, "name", NULL);
1311 node->type = of_get_property(node, "device_type", NULL);
1312
1313 if (!node->name)
1314 node->name = "<NULL>";
1315 if (!node->type)
1316 node->type = "<NULL>";
1317
1318 if (!parent) {
1319 err = -ENODEV;
1320 goto out;
1321 }
1322
1323 /* We don't support that function on PowerMac, at least
1324 * not yet
1325 */
1326 if (machine_is(powermac))
1327 return -ENODEV;
1328
1329 /* fix up new node's linux_phandle field */
1330 if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL)))
1331 node->linux_phandle = *ibm_phandle;
1332
1333 out:
1334 of_node_put(parent);
1335 return err;
1336 }
1337
1338 static int prom_reconfig_notifier(struct notifier_block *nb,
1339 unsigned long action, void *node)
1340 {
1341 int err;
1342
1343 switch (action) {
1344 case PSERIES_RECONFIG_ADD:
1345 err = of_finish_dynamic_node(node);
1346 if (err < 0) {
1347 printk(KERN_ERR "finish_node returned %d\n", err);
1348 err = NOTIFY_BAD;
1349 }
1350 break;
1351 default:
1352 err = NOTIFY_DONE;
1353 break;
1354 }
1355 return err;
1356 }
1357
1358 static struct notifier_block prom_reconfig_nb = {
1359 .notifier_call = prom_reconfig_notifier,
1360 .priority = 10, /* This one needs to run first */
1361 };
1362
1363 static int __init prom_reconfig_setup(void)
1364 {
1365 return pSeries_reconfig_notifier_register(&prom_reconfig_nb);
1366 }
1367 __initcall(prom_reconfig_setup);
1368 #endif
1369
1370 /*
1371 * Add a property to a node
1372 */
1373 int prom_add_property(struct device_node* np, struct property* prop)
1374 {
1375 struct property **next;
1376
1377 prop->next = NULL;
1378 write_lock(&devtree_lock);
1379 next = &np->properties;
1380 while (*next) {
1381 if (strcmp(prop->name, (*next)->name) == 0) {
1382 /* duplicate ! don't insert it */
1383 write_unlock(&devtree_lock);
1384 return -1;
1385 }
1386 next = &(*next)->next;
1387 }
1388 *next = prop;
1389 write_unlock(&devtree_lock);
1390
1391 #ifdef CONFIG_PROC_DEVICETREE
1392 /* try to add to proc as well if it was initialized */
1393 if (np->pde)
1394 proc_device_tree_add_prop(np->pde, prop);
1395 #endif /* CONFIG_PROC_DEVICETREE */
1396
1397 return 0;
1398 }
1399
1400 /*
1401 * Remove a property from a node. Note that we don't actually
1402 * remove it, since we have given out who-knows-how-many pointers
1403 * to the data using get-property. Instead we just move the property
1404 * to the "dead properties" list, so it won't be found any more.
1405 */
1406 int prom_remove_property(struct device_node *np, struct property *prop)
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 == prop) {
1415 /* found the node */
1416 *next = prop->next;
1417 prop->next = np->deadprops;
1418 np->deadprops = prop;
1419 found = 1;
1420 break;
1421 }
1422 next = &(*next)->next;
1423 }
1424 write_unlock(&devtree_lock);
1425
1426 if (!found)
1427 return -ENODEV;
1428
1429 #ifdef CONFIG_PROC_DEVICETREE
1430 /* try to remove the proc node as well */
1431 if (np->pde)
1432 proc_device_tree_remove_prop(np->pde, prop);
1433 #endif /* CONFIG_PROC_DEVICETREE */
1434
1435 return 0;
1436 }
1437
1438 /*
1439 * Update a property in a node. Note that we don't actually
1440 * remove it, since we have given out who-knows-how-many pointers
1441 * to the data using get-property. Instead we just move the property
1442 * to the "dead properties" list, and add the new property to the
1443 * property list
1444 */
1445 int prom_update_property(struct device_node *np,
1446 struct property *newprop,
1447 struct property *oldprop)
1448 {
1449 struct property **next;
1450 int found = 0;
1451
1452 write_lock(&devtree_lock);
1453 next = &np->properties;
1454 while (*next) {
1455 if (*next == oldprop) {
1456 /* found the node */
1457 newprop->next = oldprop->next;
1458 *next = newprop;
1459 oldprop->next = np->deadprops;
1460 np->deadprops = oldprop;
1461 found = 1;
1462 break;
1463 }
1464 next = &(*next)->next;
1465 }
1466 write_unlock(&devtree_lock);
1467
1468 if (!found)
1469 return -ENODEV;
1470
1471 #ifdef CONFIG_PROC_DEVICETREE
1472 /* try to add to proc as well if it was initialized */
1473 if (np->pde)
1474 proc_device_tree_update_prop(np->pde, newprop, oldprop);
1475 #endif /* CONFIG_PROC_DEVICETREE */
1476
1477 return 0;
1478 }
1479
1480
1481 /* Find the device node for a given logical cpu number, also returns the cpu
1482 * local thread number (index in ibm,interrupt-server#s) if relevant and
1483 * asked for (non NULL)
1484 */
1485 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
1486 {
1487 int hardid;
1488 struct device_node *np;
1489
1490 hardid = get_hard_smp_processor_id(cpu);
1491
1492 for_each_node_by_type(np, "cpu") {
1493 const u32 *intserv;
1494 unsigned int plen, t;
1495
1496 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist
1497 * fallback to "reg" property and assume no threads
1498 */
1499 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s",
1500 &plen);
1501 if (intserv == NULL) {
1502 const u32 *reg = of_get_property(np, "reg", NULL);
1503 if (reg == NULL)
1504 continue;
1505 if (*reg == hardid) {
1506 if (thread)
1507 *thread = 0;
1508 return np;
1509 }
1510 } else {
1511 plen /= sizeof(u32);
1512 for (t = 0; t < plen; t++) {
1513 if (hardid == intserv[t]) {
1514 if (thread)
1515 *thread = t;
1516 return np;
1517 }
1518 }
1519 }
1520 }
1521 return NULL;
1522 }
1523 EXPORT_SYMBOL(of_get_cpu_node);
1524
1525 #if defined(CONFIG_DEBUG_FS) && defined(DEBUG)
1526 static struct debugfs_blob_wrapper flat_dt_blob;
1527
1528 static int __init export_flat_device_tree(void)
1529 {
1530 struct dentry *d;
1531
1532 flat_dt_blob.data = initial_boot_params;
1533 flat_dt_blob.size = initial_boot_params->totalsize;
1534
1535 d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR,
1536 powerpc_debugfs_root, &flat_dt_blob);
1537 if (!d)
1538 return 1;
1539
1540 return 0;
1541 }
1542 __initcall(export_flat_device_tree);
1543 #endif
WRT350N Kernel Patches