?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
atmel_serial: fix bugs in probe() error path and remove()
[pv_ops_mirror.git] / arch / powerpc / kernel / prom.c
blob8b5efbce8d90ecf556088f26b0fe0e3b0b782737
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 unsigned long __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_ulong(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;
887 unsigned long base, size, lmb_size, flags;
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 unsigned long 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(" - %lx , %lx\n", base, size);
970 #ifdef CONFIG_PPC64
971 if (iommu_is_off) {
972 if (base >= 0x80000000ul)
973 continue;
974 if ((base + size) > 0x80000000ul)
975 size = 0x80000000ul - base;
976 }
977 #endif
978 lmb_add(base, size);
979 }
980 return 0;
981 }
982
983 static void __init early_reserve_mem(void)
984 {
985 u64 base, size;
986 u64 *reserve_map;
987 unsigned long self_base;
988 unsigned long self_size;
989
990 reserve_map = (u64 *)(((unsigned long)initial_boot_params) +
991 initial_boot_params->off_mem_rsvmap);
992
993 /* before we do anything, lets reserve the dt blob */
994 self_base = __pa((unsigned long)initial_boot_params);
995 self_size = initial_boot_params->totalsize;
996 lmb_reserve(self_base, self_size);
997
998 #ifdef CONFIG_BLK_DEV_INITRD
999 /* then reserve the initrd, if any */
1000 if (initrd_start && (initrd_end > initrd_start))
1001 lmb_reserve(__pa(initrd_start), initrd_end - initrd_start);
1002 #endif /* CONFIG_BLK_DEV_INITRD */
1003
1004 #ifdef CONFIG_PPC32
1005 /*
1006 * Handle the case where we might be booting from an old kexec
1007 * image that setup the mem_rsvmap as pairs of 32-bit values
1008 */
1009 if (*reserve_map > 0xffffffffull) {
1010 u32 base_32, size_32;
1011 u32 *reserve_map_32 = (u32 *)reserve_map;
1012
1013 while (1) {
1014 base_32 = *(reserve_map_32++);
1015 size_32 = *(reserve_map_32++);
1016 if (size_32 == 0)
1017 break;
1018 /* skip if the reservation is for the blob */
1019 if (base_32 == self_base && size_32 == self_size)
1020 continue;
1021 DBG("reserving: %x -> %x\n", base_32, size_32);
1022 lmb_reserve(base_32, size_32);
1023 }
1024 return;
1025 }
1026 #endif
1027 while (1) {
1028 base = *(reserve_map++);
1029 size = *(reserve_map++);
1030 if (size == 0)
1031 break;
1032 DBG("reserving: %llx -> %llx\n", base, size);
1033 lmb_reserve(base, size);
1034 }
1035
1036 #if 0
1037 DBG("memory reserved, lmbs :\n");
1038 lmb_dump_all();
1039 #endif
1040 }
1041
1042 void __init early_init_devtree(void *params)
1043 {
1044 DBG(" -> early_init_devtree(%p)\n", params);
1045
1046 /* Setup flat device-tree pointer */
1047 initial_boot_params = params;
1048
1049 #ifdef CONFIG_PPC_RTAS
1050 /* Some machines might need RTAS info for debugging, grab it now. */
1051 of_scan_flat_dt(early_init_dt_scan_rtas, NULL);
1052 #endif
1053
1054 /* Retrieve various informations from the /chosen node of the
1055 * device-tree, including the platform type, initrd location and
1056 * size, TCE reserve, and more ...
1057 */
1058 of_scan_flat_dt(early_init_dt_scan_chosen, NULL);
1059
1060 /* Scan memory nodes and rebuild LMBs */
1061 lmb_init();
1062 of_scan_flat_dt(early_init_dt_scan_root, NULL);
1063 of_scan_flat_dt(early_init_dt_scan_memory, NULL);
1064
1065 /* Save command line for /proc/cmdline and then parse parameters */
1066 strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE);
1067 parse_early_param();
1068
1069 /* Reserve LMB regions used by kernel, initrd, dt, etc... */
1070 lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
1071 reserve_kdump_trampoline();
1072 reserve_crashkernel();
1073 early_reserve_mem();
1074
1075 lmb_enforce_memory_limit(memory_limit);
1076 lmb_analyze();
1077
1078 DBG("Phys. mem: %lx\n", lmb_phys_mem_size());
1079
1080 /* We may need to relocate the flat tree, do it now.
1081 * FIXME .. and the initrd too? */
1082 move_device_tree();
1083
1084 DBG("Scanning CPUs ...\n");
1085
1086 /* Retreive CPU related informations from the flat tree
1087 * (altivec support, boot CPU ID, ...)
1088 */
1089 of_scan_flat_dt(early_init_dt_scan_cpus, NULL);
1090
1091 DBG(" <- early_init_devtree()\n");
1092 }
1093
1094
1095 /**
1096 * Indicates whether the root node has a given value in its
1097 * compatible property.
1098 */
1099 int machine_is_compatible(const char *compat)
1100 {
1101 struct device_node *root;
1102 int rc = 0;
1103
1104 root = of_find_node_by_path("/");
1105 if (root) {
1106 rc = of_device_is_compatible(root, compat);
1107 of_node_put(root);
1108 }
1109 return rc;
1110 }
1111 EXPORT_SYMBOL(machine_is_compatible);
1112
1113 /*******
1114 *
1115 * New implementation of the OF "find" APIs, return a refcounted
1116 * object, call of_node_put() when done. The device tree and list
1117 * are protected by a rw_lock.
1118 *
1119 * Note that property management will need some locking as well,
1120 * this isn't dealt with yet.
1121 *
1122 *******/
1123
1124 /**
1125 * of_find_node_by_phandle - Find a node given a phandle
1126 * @handle: phandle of the node to find
1127 *
1128 * Returns a node pointer with refcount incremented, use
1129 * of_node_put() on it when done.
1130 */
1131 struct device_node *of_find_node_by_phandle(phandle handle)
1132 {
1133 struct device_node *np;
1134
1135 read_lock(&devtree_lock);
1136 for (np = allnodes; np != 0; np = np->allnext)
1137 if (np->linux_phandle == handle)
1138 break;
1139 of_node_get(np);
1140 read_unlock(&devtree_lock);
1141 return np;
1142 }
1143 EXPORT_SYMBOL(of_find_node_by_phandle);
1144
1145 /**
1146 * of_find_all_nodes - Get next node in global list
1147 * @prev: Previous node or NULL to start iteration
1148 * of_node_put() will be called on it
1149 *
1150 * Returns a node pointer with refcount incremented, use
1151 * of_node_put() on it when done.
1152 */
1153 struct device_node *of_find_all_nodes(struct device_node *prev)
1154 {
1155 struct device_node *np;
1156
1157 read_lock(&devtree_lock);
1158 np = prev ? prev->allnext : allnodes;
1159 for (; np != 0; np = np->allnext)
1160 if (of_node_get(np))
1161 break;
1162 of_node_put(prev);
1163 read_unlock(&devtree_lock);
1164 return np;
1165 }
1166 EXPORT_SYMBOL(of_find_all_nodes);
1167
1168 /**
1169 * of_node_get - Increment refcount of a node
1170 * @node: Node to inc refcount, NULL is supported to
1171 * simplify writing of callers
1172 *
1173 * Returns node.
1174 */
1175 struct device_node *of_node_get(struct device_node *node)
1176 {
1177 if (node)
1178 kref_get(&node->kref);
1179 return node;
1180 }
1181 EXPORT_SYMBOL(of_node_get);
1182
1183 static inline struct device_node * kref_to_device_node(struct kref *kref)
1184 {
1185 return container_of(kref, struct device_node, kref);
1186 }
1187
1188 /**
1189 * of_node_release - release a dynamically allocated node
1190 * @kref: kref element of the node to be released
1191 *
1192 * In of_node_put() this function is passed to kref_put()
1193 * as the destructor.
1194 */
1195 static void of_node_release(struct kref *kref)
1196 {
1197 struct device_node *node = kref_to_device_node(kref);
1198 struct property *prop = node->properties;
1199
1200 /* We should never be releasing nodes that haven't been detached. */
1201 if (!of_node_check_flag(node, OF_DETACHED)) {
1202 printk("WARNING: Bad of_node_put() on %s\n", node->full_name);
1203 dump_stack();
1204 kref_init(&node->kref);
1205 return;
1206 }
1207
1208 if (!of_node_check_flag(node, OF_DYNAMIC))
1209 return;
1210
1211 while (prop) {
1212 struct property *next = prop->next;
1213 kfree(prop->name);
1214 kfree(prop->value);
1215 kfree(prop);
1216 prop = next;
1217
1218 if (!prop) {
1219 prop = node->deadprops;
1220 node->deadprops = NULL;
1221 }
1222 }
1223 kfree(node->full_name);
1224 kfree(node->data);
1225 kfree(node);
1226 }
1227
1228 /**
1229 * of_node_put - Decrement refcount of a node
1230 * @node: Node to dec refcount, NULL is supported to
1231 * simplify writing of callers
1232 *
1233 */
1234 void of_node_put(struct device_node *node)
1235 {
1236 if (node)
1237 kref_put(&node->kref, of_node_release);
1238 }
1239 EXPORT_SYMBOL(of_node_put);
1240
1241 /*
1242 * Plug a device node into the tree and global list.
1243 */
1244 void of_attach_node(struct device_node *np)
1245 {
1246 write_lock(&devtree_lock);
1247 np->sibling = np->parent->child;
1248 np->allnext = allnodes;
1249 np->parent->child = np;
1250 allnodes = np;
1251 write_unlock(&devtree_lock);
1252 }
1253
1254 /*
1255 * "Unplug" a node from the device tree. The caller must hold
1256 * a reference to the node. The memory associated with the node
1257 * is not freed until its refcount goes to zero.
1258 */
1259 void of_detach_node(struct device_node *np)
1260 {
1261 struct device_node *parent;
1262
1263 write_lock(&devtree_lock);
1264
1265 parent = np->parent;
1266 if (!parent)
1267 goto out_unlock;
1268
1269 if (allnodes == np)
1270 allnodes = np->allnext;
1271 else {
1272 struct device_node *prev;
1273 for (prev = allnodes;
1274 prev->allnext != np;
1275 prev = prev->allnext)
1276 ;
1277 prev->allnext = np->allnext;
1278 }
1279
1280 if (parent->child == np)
1281 parent->child = np->sibling;
1282 else {
1283 struct device_node *prevsib;
1284 for (prevsib = np->parent->child;
1285 prevsib->sibling != np;
1286 prevsib = prevsib->sibling)
1287 ;
1288 prevsib->sibling = np->sibling;
1289 }
1290
1291 of_node_set_flag(np, OF_DETACHED);
1292
1293 out_unlock:
1294 write_unlock(&devtree_lock);
1295 }
1296
1297 #ifdef CONFIG_PPC_PSERIES
1298 /*
1299 * Fix up the uninitialized fields in a new device node:
1300 * name, type and pci-specific fields
1301 */
1302
1303 static int of_finish_dynamic_node(struct device_node *node)
1304 {
1305 struct device_node *parent = of_get_parent(node);
1306 int err = 0;
1307 const phandle *ibm_phandle;
1308
1309 node->name = of_get_property(node, "name", NULL);
1310 node->type = of_get_property(node, "device_type", NULL);
1311
1312 if (!node->name)
1313 node->name = "<NULL>";
1314 if (!node->type)
1315 node->type = "<NULL>";
1316
1317 if (!parent) {
1318 err = -ENODEV;
1319 goto out;
1320 }
1321
1322 /* We don't support that function on PowerMac, at least
1323 * not yet
1324 */
1325 if (machine_is(powermac))
1326 return -ENODEV;
1327
1328 /* fix up new node's linux_phandle field */
1329 if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL)))
1330 node->linux_phandle = *ibm_phandle;
1331
1332 out:
1333 of_node_put(parent);
1334 return err;
1335 }
1336
1337 static int prom_reconfig_notifier(struct notifier_block *nb,
1338 unsigned long action, void *node)
1339 {
1340 int err;
1341
1342 switch (action) {
1343 case PSERIES_RECONFIG_ADD:
1344 err = of_finish_dynamic_node(node);
1345 if (err < 0) {
1346 printk(KERN_ERR "finish_node returned %d\n", err);
1347 err = NOTIFY_BAD;
1348 }
1349 break;
1350 default:
1351 err = NOTIFY_DONE;
1352 break;
1353 }
1354 return err;
1355 }
1356
1357 static struct notifier_block prom_reconfig_nb = {
1358 .notifier_call = prom_reconfig_notifier,
1359 .priority = 10, /* This one needs to run first */
1360 };
1361
1362 static int __init prom_reconfig_setup(void)
1363 {
1364 return pSeries_reconfig_notifier_register(&prom_reconfig_nb);
1365 }
1366 __initcall(prom_reconfig_setup);
1367 #endif
1368
1369 /*
1370 * Add a property to a node
1371 */
1372 int prom_add_property(struct device_node* np, struct property* prop)
1373 {
1374 struct property **next;
1375
1376 prop->next = NULL;
1377 write_lock(&devtree_lock);
1378 next = &np->properties;
1379 while (*next) {
1380 if (strcmp(prop->name, (*next)->name) == 0) {
1381 /* duplicate ! don't insert it */
1382 write_unlock(&devtree_lock);
1383 return -1;
1384 }
1385 next = &(*next)->next;
1386 }
1387 *next = prop;
1388 write_unlock(&devtree_lock);
1389
1390 #ifdef CONFIG_PROC_DEVICETREE
1391 /* try to add to proc as well if it was initialized */
1392 if (np->pde)
1393 proc_device_tree_add_prop(np->pde, prop);
1394 #endif /* CONFIG_PROC_DEVICETREE */
1395
1396 return 0;
1397 }
1398
1399 /*
1400 * Remove a property from a node. Note that we don't actually
1401 * remove it, since we have given out who-knows-how-many pointers
1402 * to the data using get-property. Instead we just move the property
1403 * to the "dead properties" list, so it won't be found any more.
1404 */
1405 int prom_remove_property(struct device_node *np, struct property *prop)
1406 {
1407 struct property **next;
1408 int found = 0;
1409
1410 write_lock(&devtree_lock);
1411 next = &np->properties;
1412 while (*next) {
1413 if (*next == prop) {
1414 /* found the node */
1415 *next = prop->next;
1416 prop->next = np->deadprops;
1417 np->deadprops = prop;
1418 found = 1;
1419 break;
1420 }
1421 next = &(*next)->next;
1422 }
1423 write_unlock(&devtree_lock);
1424
1425 if (!found)
1426 return -ENODEV;
1427
1428 #ifdef CONFIG_PROC_DEVICETREE
1429 /* try to remove the proc node as well */
1430 if (np->pde)
1431 proc_device_tree_remove_prop(np->pde, prop);
1432 #endif /* CONFIG_PROC_DEVICETREE */
1433
1434 return 0;
1435 }
1436
1437 /*
1438 * Update a property in a node. Note that we don't actually
1439 * remove it, since we have given out who-knows-how-many pointers
1440 * to the data using get-property. Instead we just move the property
1441 * to the "dead properties" list, and add the new property to the
1442 * property list
1443 */
1444 int prom_update_property(struct device_node *np,
1445 struct property *newprop,
1446 struct property *oldprop)
1447 {
1448 struct property **next;
1449 int found = 0;
1450
1451 write_lock(&devtree_lock);
1452 next = &np->properties;
1453 while (*next) {
1454 if (*next == oldprop) {
1455 /* found the node */
1456 newprop->next = oldprop->next;
1457 *next = newprop;
1458 oldprop->next = np->deadprops;
1459 np->deadprops = oldprop;
1460 found = 1;
1461 break;
1462 }
1463 next = &(*next)->next;
1464 }
1465 write_unlock(&devtree_lock);
1466
1467 if (!found)
1468 return -ENODEV;
1469
1470 #ifdef CONFIG_PROC_DEVICETREE
1471 /* try to add to proc as well if it was initialized */
1472 if (np->pde)
1473 proc_device_tree_update_prop(np->pde, newprop, oldprop);
1474 #endif /* CONFIG_PROC_DEVICETREE */
1475
1476 return 0;
1477 }
1478
1479
1480 /* Find the device node for a given logical cpu number, also returns the cpu
1481 * local thread number (index in ibm,interrupt-server#s) if relevant and
1482 * asked for (non NULL)
1483 */
1484 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
1485 {
1486 int hardid;
1487 struct device_node *np;
1488
1489 hardid = get_hard_smp_processor_id(cpu);
1490
1491 for_each_node_by_type(np, "cpu") {
1492 const u32 *intserv;
1493 unsigned int plen, t;
1494
1495 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist
1496 * fallback to "reg" property and assume no threads
1497 */
1498 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s",
1499 &plen);
1500 if (intserv == NULL) {
1501 const u32 *reg = of_get_property(np, "reg", NULL);
1502 if (reg == NULL)
1503 continue;
1504 if (*reg == hardid) {
1505 if (thread)
1506 *thread = 0;
1507 return np;
1508 }
1509 } else {
1510 plen /= sizeof(u32);
1511 for (t = 0; t < plen; t++) {
1512 if (hardid == intserv[t]) {
1513 if (thread)
1514 *thread = t;
1515 return np;
1516 }
1517 }
1518 }
1519 }
1520 return NULL;
1521 }
1522 EXPORT_SYMBOL(of_get_cpu_node);
1523
1524 #if defined(CONFIG_DEBUG_FS) && defined(DEBUG)
1525 static struct debugfs_blob_wrapper flat_dt_blob;
1526
1527 static int __init export_flat_device_tree(void)
1528 {
1529 struct dentry *d;
1530
1531 flat_dt_blob.data = initial_boot_params;
1532 flat_dt_blob.size = initial_boot_params->totalsize;
1533
1534 d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR,
1535 powerpc_debugfs_root, &flat_dt_blob);
1536 if (!d)
1537 return 1;
1538
1539 return 0;
1540 }
1541 __initcall(export_flat_device_tree);
1542 #endif
Mirror for ia64_pv_ops.git