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