of: unify phandle name in struct device_node
[linux-2.6.git] / arch / powerpc / kernel / prom.c
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 #ifdef CONFIG_PPC64
65 int __initdata iommu_is_off;
66 int __initdata iommu_force_on;
67 unsigned long tce_alloc_start, tce_alloc_end;
68 #endif
69
70 extern rwlock_t devtree_lock;   /* temporary while merging */
71
72 /* export that to outside world */
73 struct device_node *of_chosen;
74
75 static int __init early_parse_mem(char *p)
76 {
77         if (!p)
78                 return 1;
79
80         memory_limit = PAGE_ALIGN(memparse(p, &p));
81         DBG("memory limit = 0x%llx\n", (unsigned long long)memory_limit);
82
83         return 0;
84 }
85 early_param("mem", early_parse_mem);
86
87 /**
88  * move_device_tree - move tree to an unused area, if needed.
89  *
90  * The device tree may be allocated beyond our memory limit, or inside the
91  * crash kernel region for kdump. If so, move it out of the way.
92  */
93 static void __init move_device_tree(void)
94 {
95         unsigned long start, size;
96         void *p;
97
98         DBG("-> move_device_tree\n");
99
100         start = __pa(initial_boot_params);
101         size = initial_boot_params->totalsize;
102
103         if ((memory_limit && (start + size) > memory_limit) ||
104                         overlaps_crashkernel(start, size)) {
105                 p = __va(lmb_alloc_base(size, PAGE_SIZE, lmb.rmo_size));
106                 memcpy(p, initial_boot_params, size);
107                 initial_boot_params = (struct boot_param_header *)p;
108                 DBG("Moved device tree to 0x%p\n", p);
109         }
110
111         DBG("<- move_device_tree\n");
112 }
113
114 /*
115  * ibm,pa-features is a per-cpu property that contains a string of
116  * attribute descriptors, each of which has a 2 byte header plus up
117  * to 254 bytes worth of processor attribute bits.  First header
118  * byte specifies the number of bytes following the header.
119  * Second header byte is an "attribute-specifier" type, of which
120  * zero is the only currently-defined value.
121  * Implementation:  Pass in the byte and bit offset for the feature
122  * that we are interested in.  The function will return -1 if the
123  * pa-features property is missing, or a 1/0 to indicate if the feature
124  * is supported/not supported.  Note that the bit numbers are
125  * big-endian to match the definition in PAPR.
126  */
127 static struct ibm_pa_feature {
128         unsigned long   cpu_features;   /* CPU_FTR_xxx bit */
129         unsigned int    cpu_user_ftrs;  /* PPC_FEATURE_xxx bit */
130         unsigned char   pabyte;         /* byte number in ibm,pa-features */
131         unsigned char   pabit;          /* bit number (big-endian) */
132         unsigned char   invert;         /* if 1, pa bit set => clear feature */
133 } ibm_pa_features[] __initdata = {
134         {0, PPC_FEATURE_HAS_MMU,        0, 0, 0},
135         {0, PPC_FEATURE_HAS_FPU,        0, 1, 0},
136         {CPU_FTR_SLB, 0,                0, 2, 0},
137         {CPU_FTR_CTRL, 0,               0, 3, 0},
138         {CPU_FTR_NOEXECUTE, 0,          0, 6, 0},
139         {CPU_FTR_NODSISRALIGN, 0,       1, 1, 1},
140         {CPU_FTR_CI_LARGE_PAGE, 0,      1, 2, 0},
141         {CPU_FTR_REAL_LE, PPC_FEATURE_TRUE_LE, 5, 0, 0},
142 };
143
144 static void __init scan_features(unsigned long node, unsigned char *ftrs,
145                                  unsigned long tablelen,
146                                  struct ibm_pa_feature *fp,
147                                  unsigned long ft_size)
148 {
149         unsigned long i, len, bit;
150
151         /* find descriptor with type == 0 */
152         for (;;) {
153                 if (tablelen < 3)
154                         return;
155                 len = 2 + ftrs[0];
156                 if (tablelen < len)
157                         return;         /* descriptor 0 not found */
158                 if (ftrs[1] == 0)
159                         break;
160                 tablelen -= len;
161                 ftrs += len;
162         }
163
164         /* loop over bits we know about */
165         for (i = 0; i < ft_size; ++i, ++fp) {
166                 if (fp->pabyte >= ftrs[0])
167                         continue;
168                 bit = (ftrs[2 + fp->pabyte] >> (7 - fp->pabit)) & 1;
169                 if (bit ^ fp->invert) {
170                         cur_cpu_spec->cpu_features |= fp->cpu_features;
171                         cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftrs;
172                 } else {
173                         cur_cpu_spec->cpu_features &= ~fp->cpu_features;
174                         cur_cpu_spec->cpu_user_features &= ~fp->cpu_user_ftrs;
175                 }
176         }
177 }
178
179 static void __init check_cpu_pa_features(unsigned long node)
180 {
181         unsigned char *pa_ftrs;
182         unsigned long tablelen;
183
184         pa_ftrs = of_get_flat_dt_prop(node, "ibm,pa-features", &tablelen);
185         if (pa_ftrs == NULL)
186                 return;
187
188         scan_features(node, pa_ftrs, tablelen,
189                       ibm_pa_features, ARRAY_SIZE(ibm_pa_features));
190 }
191
192 #ifdef CONFIG_PPC_STD_MMU_64
193 static void __init check_cpu_slb_size(unsigned long node)
194 {
195         u32 *slb_size_ptr;
196
197         slb_size_ptr = of_get_flat_dt_prop(node, "slb-size", NULL);
198         if (slb_size_ptr != NULL) {
199                 mmu_slb_size = *slb_size_ptr;
200                 return;
201         }
202         slb_size_ptr = of_get_flat_dt_prop(node, "ibm,slb-size", NULL);
203         if (slb_size_ptr != NULL) {
204                 mmu_slb_size = *slb_size_ptr;
205         }
206 }
207 #else
208 #define check_cpu_slb_size(node) do { } while(0)
209 #endif
210
211 static struct feature_property {
212         const char *name;
213         u32 min_value;
214         unsigned long cpu_feature;
215         unsigned long cpu_user_ftr;
216 } feature_properties[] __initdata = {
217 #ifdef CONFIG_ALTIVEC
218         {"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
219         {"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
220 #endif /* CONFIG_ALTIVEC */
221 #ifdef CONFIG_VSX
222         /* Yes, this _really_ is ibm,vmx == 2 to enable VSX */
223         {"ibm,vmx", 2, CPU_FTR_VSX, PPC_FEATURE_HAS_VSX},
224 #endif /* CONFIG_VSX */
225 #ifdef CONFIG_PPC64
226         {"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP},
227         {"ibm,purr", 1, CPU_FTR_PURR, 0},
228         {"ibm,spurr", 1, CPU_FTR_SPURR, 0},
229 #endif /* CONFIG_PPC64 */
230 };
231
232 #if defined(CONFIG_44x) && defined(CONFIG_PPC_FPU)
233 static inline void identical_pvr_fixup(unsigned long node)
234 {
235         unsigned int pvr;
236         char *model = of_get_flat_dt_prop(node, "model", NULL);
237
238         /*
239          * Since 440GR(x)/440EP(x) processors have the same pvr,
240          * we check the node path and set bit 28 in the cur_cpu_spec
241          * pvr for EP(x) processor version. This bit is always 0 in
242          * the "real" pvr. Then we call identify_cpu again with
243          * the new logical pvr to enable FPU support.
244          */
245         if (model && strstr(model, "440EP")) {
246                 pvr = cur_cpu_spec->pvr_value | 0x8;
247                 identify_cpu(0, pvr);
248                 DBG("Using logical pvr %x for %s\n", pvr, model);
249         }
250 }
251 #else
252 #define identical_pvr_fixup(node) do { } while(0)
253 #endif
254
255 static void __init check_cpu_feature_properties(unsigned long node)
256 {
257         unsigned long i;
258         struct feature_property *fp = feature_properties;
259         const u32 *prop;
260
261         for (i = 0; i < ARRAY_SIZE(feature_properties); ++i, ++fp) {
262                 prop = of_get_flat_dt_prop(node, fp->name, NULL);
263                 if (prop && *prop >= fp->min_value) {
264                         cur_cpu_spec->cpu_features |= fp->cpu_feature;
265                         cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr;
266                 }
267         }
268 }
269
270 static int __init early_init_dt_scan_cpus(unsigned long node,
271                                           const char *uname, int depth,
272                                           void *data)
273 {
274         static int logical_cpuid = 0;
275         char *type = of_get_flat_dt_prop(node, "device_type", NULL);
276         const u32 *prop;
277         const u32 *intserv;
278         int i, nthreads;
279         unsigned long len;
280         int found = 0;
281
282         /* We are scanning "cpu" nodes only */
283         if (type == NULL || strcmp(type, "cpu") != 0)
284                 return 0;
285
286         /* Get physical cpuid */
287         intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len);
288         if (intserv) {
289                 nthreads = len / sizeof(int);
290         } else {
291                 intserv = of_get_flat_dt_prop(node, "reg", NULL);
292                 nthreads = 1;
293         }
294
295         /*
296          * Now see if any of these threads match our boot cpu.
297          * NOTE: This must match the parsing done in smp_setup_cpu_maps.
298          */
299         for (i = 0; i < nthreads; i++) {
300                 /*
301                  * version 2 of the kexec param format adds the phys cpuid of
302                  * booted proc.
303                  */
304                 if (initial_boot_params && initial_boot_params->version >= 2) {
305                         if (intserv[i] ==
306                                         initial_boot_params->boot_cpuid_phys) {
307                                 found = 1;
308                                 break;
309                         }
310                 } else {
311                         /*
312                          * Check if it's the boot-cpu, set it's hw index now,
313                          * unfortunately this format did not support booting
314                          * off secondary threads.
315                          */
316                         if (of_get_flat_dt_prop(node,
317                                         "linux,boot-cpu", NULL) != NULL) {
318                                 found = 1;
319                                 break;
320                         }
321                 }
322
323 #ifdef CONFIG_SMP
324                 /* logical cpu id is always 0 on UP kernels */
325                 logical_cpuid++;
326 #endif
327         }
328
329         if (found) {
330                 DBG("boot cpu: logical %d physical %d\n", logical_cpuid,
331                         intserv[i]);
332                 boot_cpuid = logical_cpuid;
333                 set_hard_smp_processor_id(boot_cpuid, intserv[i]);
334
335                 /*
336                  * PAPR defines "logical" PVR values for cpus that
337                  * meet various levels of the architecture:
338                  * 0x0f000001   Architecture version 2.04
339                  * 0x0f000002   Architecture version 2.05
340                  * If the cpu-version property in the cpu node contains
341                  * such a value, we call identify_cpu again with the
342                  * logical PVR value in order to use the cpu feature
343                  * bits appropriate for the architecture level.
344                  *
345                  * A POWER6 partition in "POWER6 architected" mode
346                  * uses the 0x0f000002 PVR value; in POWER5+ mode
347                  * it uses 0x0f000001.
348                  */
349                 prop = of_get_flat_dt_prop(node, "cpu-version", NULL);
350                 if (prop && (*prop & 0xff000000) == 0x0f000000)
351                         identify_cpu(0, *prop);
352
353                 identical_pvr_fixup(node);
354         }
355
356         check_cpu_feature_properties(node);
357         check_cpu_pa_features(node);
358         check_cpu_slb_size(node);
359
360 #ifdef CONFIG_PPC_PSERIES
361         if (nthreads > 1)
362                 cur_cpu_spec->cpu_features |= CPU_FTR_SMT;
363         else
364                 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT;
365 #endif
366
367         return 0;
368 }
369
370 void __init early_init_dt_scan_chosen_arch(unsigned long node)
371 {
372         unsigned long *lprop;
373
374 #ifdef CONFIG_PPC64
375         /* check if iommu is forced on or off */
376         if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL)
377                 iommu_is_off = 1;
378         if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL)
379                 iommu_force_on = 1;
380 #endif
381
382         /* mem=x on the command line is the preferred mechanism */
383         lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL);
384         if (lprop)
385                 memory_limit = *lprop;
386
387 #ifdef CONFIG_PPC64
388         lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL);
389         if (lprop)
390                 tce_alloc_start = *lprop;
391         lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL);
392         if (lprop)
393                 tce_alloc_end = *lprop;
394 #endif
395
396 #ifdef CONFIG_KEXEC
397         lprop = of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL);
398         if (lprop)
399                 crashk_res.start = *lprop;
400
401         lprop = of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL);
402         if (lprop)
403                 crashk_res.end = crashk_res.start + *lprop - 1;
404 #endif
405 }
406
407 #ifdef CONFIG_PPC_PSERIES
408 /*
409  * Interpret the ibm,dynamic-memory property in the
410  * /ibm,dynamic-reconfiguration-memory node.
411  * This contains a list of memory blocks along with NUMA affinity
412  * information.
413  */
414 static int __init early_init_dt_scan_drconf_memory(unsigned long node)
415 {
416         __be32 *dm, *ls, *usm;
417         unsigned long l, n, flags;
418         u64 base, size, lmb_size;
419         unsigned int is_kexec_kdump = 0, rngs;
420
421         ls = of_get_flat_dt_prop(node, "ibm,lmb-size", &l);
422         if (ls == NULL || l < dt_root_size_cells * sizeof(__be32))
423                 return 0;
424         lmb_size = dt_mem_next_cell(dt_root_size_cells, &ls);
425
426         dm = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l);
427         if (dm == NULL || l < sizeof(__be32))
428                 return 0;
429
430         n = *dm++;      /* number of entries */
431         if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(__be32))
432                 return 0;
433
434         /* check if this is a kexec/kdump kernel. */
435         usm = of_get_flat_dt_prop(node, "linux,drconf-usable-memory",
436                                                  &l);
437         if (usm != NULL)
438                 is_kexec_kdump = 1;
439
440         for (; n != 0; --n) {
441                 base = dt_mem_next_cell(dt_root_addr_cells, &dm);
442                 flags = dm[3];
443                 /* skip DRC index, pad, assoc. list index, flags */
444                 dm += 4;
445                 /* skip this block if the reserved bit is set in flags (0x80)
446                    or if the block is not assigned to this partition (0x8) */
447                 if ((flags & 0x80) || !(flags & 0x8))
448                         continue;
449                 size = lmb_size;
450                 rngs = 1;
451                 if (is_kexec_kdump) {
452                         /*
453                          * For each lmb in ibm,dynamic-memory, a corresponding
454                          * entry in linux,drconf-usable-memory property contains
455                          * a counter 'p' followed by 'p' (base, size) duple.
456                          * Now read the counter from
457                          * linux,drconf-usable-memory property
458                          */
459                         rngs = dt_mem_next_cell(dt_root_size_cells, &usm);
460                         if (!rngs) /* there are no (base, size) duple */
461                                 continue;
462                 }
463                 do {
464                         if (is_kexec_kdump) {
465                                 base = dt_mem_next_cell(dt_root_addr_cells,
466                                                          &usm);
467                                 size = dt_mem_next_cell(dt_root_size_cells,
468                                                          &usm);
469                         }
470                         if (iommu_is_off) {
471                                 if (base >= 0x80000000ul)
472                                         continue;
473                                 if ((base + size) > 0x80000000ul)
474                                         size = 0x80000000ul - base;
475                         }
476                         lmb_add(base, size);
477                 } while (--rngs);
478         }
479         lmb_dump_all();
480         return 0;
481 }
482 #else
483 #define early_init_dt_scan_drconf_memory(node)  0
484 #endif /* CONFIG_PPC_PSERIES */
485
486 static int __init early_init_dt_scan_memory(unsigned long node,
487                                             const char *uname, int depth, void *data)
488 {
489         char *type = of_get_flat_dt_prop(node, "device_type", NULL);
490         __be32 *reg, *endp;
491         unsigned long l;
492
493         /* Look for the ibm,dynamic-reconfiguration-memory node */
494         if (depth == 1 &&
495             strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0)
496                 return early_init_dt_scan_drconf_memory(node);
497
498         /* We are scanning "memory" nodes only */
499         if (type == NULL) {
500                 /*
501                  * The longtrail doesn't have a device_type on the
502                  * /memory node, so look for the node called /memory@0.
503                  */
504                 if (depth != 1 || strcmp(uname, "memory@0") != 0)
505                         return 0;
506         } else if (strcmp(type, "memory") != 0)
507                 return 0;
508
509         reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
510         if (reg == NULL)
511                 reg = of_get_flat_dt_prop(node, "reg", &l);
512         if (reg == NULL)
513                 return 0;
514
515         endp = reg + (l / sizeof(__be32));
516
517         DBG("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
518             uname, l, reg[0], reg[1], reg[2], reg[3]);
519
520         while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
521                 u64 base, size;
522
523                 base = dt_mem_next_cell(dt_root_addr_cells, &reg);
524                 size = dt_mem_next_cell(dt_root_size_cells, &reg);
525
526                 if (size == 0)
527                         continue;
528                 DBG(" - %llx ,  %llx\n", (unsigned long long)base,
529                     (unsigned long long)size);
530 #ifdef CONFIG_PPC64
531                 if (iommu_is_off) {
532                         if (base >= 0x80000000ul)
533                                 continue;
534                         if ((base + size) > 0x80000000ul)
535                                 size = 0x80000000ul - base;
536                 }
537 #endif
538                 lmb_add(base, size);
539
540                 memstart_addr = min((u64)memstart_addr, base);
541         }
542
543         return 0;
544 }
545
546 static void __init early_reserve_mem(void)
547 {
548         u64 base, size;
549         u64 *reserve_map;
550         unsigned long self_base;
551         unsigned long self_size;
552
553         reserve_map = (u64 *)(((unsigned long)initial_boot_params) +
554                                         initial_boot_params->off_mem_rsvmap);
555
556         /* before we do anything, lets reserve the dt blob */
557         self_base = __pa((unsigned long)initial_boot_params);
558         self_size = initial_boot_params->totalsize;
559         lmb_reserve(self_base, self_size);
560
561 #ifdef CONFIG_BLK_DEV_INITRD
562         /* then reserve the initrd, if any */
563         if (initrd_start && (initrd_end > initrd_start))
564                 lmb_reserve(__pa(initrd_start), initrd_end - initrd_start);
565 #endif /* CONFIG_BLK_DEV_INITRD */
566
567 #ifdef CONFIG_PPC32
568         /* 
569          * Handle the case where we might be booting from an old kexec
570          * image that setup the mem_rsvmap as pairs of 32-bit values
571          */
572         if (*reserve_map > 0xffffffffull) {
573                 u32 base_32, size_32;
574                 u32 *reserve_map_32 = (u32 *)reserve_map;
575
576                 while (1) {
577                         base_32 = *(reserve_map_32++);
578                         size_32 = *(reserve_map_32++);
579                         if (size_32 == 0)
580                                 break;
581                         /* skip if the reservation is for the blob */
582                         if (base_32 == self_base && size_32 == self_size)
583                                 continue;
584                         DBG("reserving: %x -> %x\n", base_32, size_32);
585                         lmb_reserve(base_32, size_32);
586                 }
587                 return;
588         }
589 #endif
590         while (1) {
591                 base = *(reserve_map++);
592                 size = *(reserve_map++);
593                 if (size == 0)
594                         break;
595                 DBG("reserving: %llx -> %llx\n", base, size);
596                 lmb_reserve(base, size);
597         }
598 }
599
600 #ifdef CONFIG_PHYP_DUMP
601 /**
602  * phyp_dump_calculate_reserve_size() - reserve variable boot area 5% or arg
603  *
604  * Function to find the largest size we need to reserve
605  * during early boot process.
606  *
607  * It either looks for boot param and returns that OR
608  * returns larger of 256 or 5% rounded down to multiples of 256MB.
609  *
610  */
611 static inline unsigned long phyp_dump_calculate_reserve_size(void)
612 {
613         unsigned long tmp;
614
615         if (phyp_dump_info->reserve_bootvar)
616                 return phyp_dump_info->reserve_bootvar;
617
618         /* divide by 20 to get 5% of value */
619         tmp = lmb_end_of_DRAM();
620         do_div(tmp, 20);
621
622         /* round it down in multiples of 256 */
623         tmp = tmp & ~0x0FFFFFFFUL;
624
625         return (tmp > PHYP_DUMP_RMR_END ? tmp : PHYP_DUMP_RMR_END);
626 }
627
628 /**
629  * phyp_dump_reserve_mem() - reserve all not-yet-dumped mmemory
630  *
631  * This routine may reserve memory regions in the kernel only
632  * if the system is supported and a dump was taken in last
633  * boot instance or if the hardware is supported and the
634  * scratch area needs to be setup. In other instances it returns
635  * without reserving anything. The memory in case of dump being
636  * active is freed when the dump is collected (by userland tools).
637  */
638 static void __init phyp_dump_reserve_mem(void)
639 {
640         unsigned long base, size;
641         unsigned long variable_reserve_size;
642
643         if (!phyp_dump_info->phyp_dump_configured) {
644                 printk(KERN_ERR "Phyp-dump not supported on this hardware\n");
645                 return;
646         }
647
648         if (!phyp_dump_info->phyp_dump_at_boot) {
649                 printk(KERN_INFO "Phyp-dump disabled at boot time\n");
650                 return;
651         }
652
653         variable_reserve_size = phyp_dump_calculate_reserve_size();
654
655         if (phyp_dump_info->phyp_dump_is_active) {
656                 /* Reserve *everything* above RMR.Area freed by userland tools*/
657                 base = variable_reserve_size;
658                 size = lmb_end_of_DRAM() - base;
659
660                 /* XXX crashed_ram_end is wrong, since it may be beyond
661                  * the memory_limit, it will need to be adjusted. */
662                 lmb_reserve(base, size);
663
664                 phyp_dump_info->init_reserve_start = base;
665                 phyp_dump_info->init_reserve_size = size;
666         } else {
667                 size = phyp_dump_info->cpu_state_size +
668                         phyp_dump_info->hpte_region_size +
669                         variable_reserve_size;
670                 base = lmb_end_of_DRAM() - size;
671                 lmb_reserve(base, size);
672                 phyp_dump_info->init_reserve_start = base;
673                 phyp_dump_info->init_reserve_size = size;
674         }
675 }
676 #else
677 static inline void __init phyp_dump_reserve_mem(void) {}
678 #endif /* CONFIG_PHYP_DUMP  && CONFIG_PPC_RTAS */
679
680
681 void __init early_init_devtree(void *params)
682 {
683         phys_addr_t limit;
684
685         DBG(" -> early_init_devtree(%p)\n", params);
686
687         /* Setup flat device-tree pointer */
688         initial_boot_params = params;
689
690 #ifdef CONFIG_PPC_RTAS
691         /* Some machines might need RTAS info for debugging, grab it now. */
692         of_scan_flat_dt(early_init_dt_scan_rtas, NULL);
693 #endif
694
695 #ifdef CONFIG_PHYP_DUMP
696         /* scan tree to see if dump occured during last boot */
697         of_scan_flat_dt(early_init_dt_scan_phyp_dump, NULL);
698 #endif
699
700         /* Retrieve various informations from the /chosen node of the
701          * device-tree, including the platform type, initrd location and
702          * size, TCE reserve, and more ...
703          */
704         of_scan_flat_dt(early_init_dt_scan_chosen, NULL);
705
706         /* Scan memory nodes and rebuild LMBs */
707         lmb_init();
708         of_scan_flat_dt(early_init_dt_scan_root, NULL);
709         of_scan_flat_dt(early_init_dt_scan_memory, NULL);
710
711         /* Save command line for /proc/cmdline and then parse parameters */
712         strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE);
713         parse_early_param();
714
715         /* Reserve LMB regions used by kernel, initrd, dt, etc... */
716         lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
717         /* If relocatable, reserve first 32k for interrupt vectors etc. */
718         if (PHYSICAL_START > MEMORY_START)
719                 lmb_reserve(MEMORY_START, 0x8000);
720         reserve_kdump_trampoline();
721         reserve_crashkernel();
722         early_reserve_mem();
723         phyp_dump_reserve_mem();
724
725         limit = memory_limit;
726         if (! limit) {
727                 phys_addr_t memsize;
728
729                 /* Ensure that total memory size is page-aligned, because
730                  * otherwise mark_bootmem() gets upset. */
731                 lmb_analyze();
732                 memsize = lmb_phys_mem_size();
733                 if ((memsize & PAGE_MASK) != memsize)
734                         limit = memsize & PAGE_MASK;
735         }
736         lmb_enforce_memory_limit(limit);
737
738         lmb_analyze();
739         lmb_dump_all();
740
741         DBG("Phys. mem: %llx\n", lmb_phys_mem_size());
742
743         /* We may need to relocate the flat tree, do it now.
744          * FIXME .. and the initrd too? */
745         move_device_tree();
746
747         DBG("Scanning CPUs ...\n");
748
749         /* Retreive CPU related informations from the flat tree
750          * (altivec support, boot CPU ID, ...)
751          */
752         of_scan_flat_dt(early_init_dt_scan_cpus, NULL);
753
754         DBG(" <- early_init_devtree()\n");
755 }
756
757 /*******
758  *
759  * New implementation of the OF "find" APIs, return a refcounted
760  * object, call of_node_put() when done.  The device tree and list
761  * are protected by a rw_lock.
762  *
763  * Note that property management will need some locking as well,
764  * this isn't dealt with yet.
765  *
766  *******/
767
768 /**
769  *      of_find_node_by_phandle - Find a node given a phandle
770  *      @handle:        phandle of the node to find
771  *
772  *      Returns a node pointer with refcount incremented, use
773  *      of_node_put() on it when done.
774  */
775 struct device_node *of_find_node_by_phandle(phandle handle)
776 {
777         struct device_node *np;
778
779         read_lock(&devtree_lock);
780         for (np = allnodes; np != 0; np = np->allnext)
781                 if (np->phandle == handle)
782                         break;
783         of_node_get(np);
784         read_unlock(&devtree_lock);
785         return np;
786 }
787 EXPORT_SYMBOL(of_find_node_by_phandle);
788
789 /**
790  *      of_find_next_cache_node - Find a node's subsidiary cache
791  *      @np:    node of type "cpu" or "cache"
792  *
793  *      Returns a node pointer with refcount incremented, use
794  *      of_node_put() on it when done.  Caller should hold a reference
795  *      to np.
796  */
797 struct device_node *of_find_next_cache_node(struct device_node *np)
798 {
799         struct device_node *child;
800         const phandle *handle;
801
802         handle = of_get_property(np, "l2-cache", NULL);
803         if (!handle)
804                 handle = of_get_property(np, "next-level-cache", NULL);
805
806         if (handle)
807                 return of_find_node_by_phandle(*handle);
808
809         /* OF on pmac has nodes instead of properties named "l2-cache"
810          * beneath CPU nodes.
811          */
812         if (!strcmp(np->type, "cpu"))
813                 for_each_child_of_node(np, child)
814                         if (!strcmp(child->type, "cache"))
815                                 return child;
816
817         return NULL;
818 }
819
820 /*
821  * Plug a device node into the tree and global list.
822  */
823 void of_attach_node(struct device_node *np)
824 {
825         unsigned long flags;
826
827         write_lock_irqsave(&devtree_lock, flags);
828         np->sibling = np->parent->child;
829         np->allnext = allnodes;
830         np->parent->child = np;
831         allnodes = np;
832         write_unlock_irqrestore(&devtree_lock, flags);
833 }
834
835 /*
836  * "Unplug" a node from the device tree.  The caller must hold
837  * a reference to the node.  The memory associated with the node
838  * is not freed until its refcount goes to zero.
839  */
840 void of_detach_node(struct device_node *np)
841 {
842         struct device_node *parent;
843         unsigned long flags;
844
845         write_lock_irqsave(&devtree_lock, flags);
846
847         parent = np->parent;
848         if (!parent)
849                 goto out_unlock;
850
851         if (allnodes == np)
852                 allnodes = np->allnext;
853         else {
854                 struct device_node *prev;
855                 for (prev = allnodes;
856                      prev->allnext != np;
857                      prev = prev->allnext)
858                         ;
859                 prev->allnext = np->allnext;
860         }
861
862         if (parent->child == np)
863                 parent->child = np->sibling;
864         else {
865                 struct device_node *prevsib;
866                 for (prevsib = np->parent->child;
867                      prevsib->sibling != np;
868                      prevsib = prevsib->sibling)
869                         ;
870                 prevsib->sibling = np->sibling;
871         }
872
873         of_node_set_flag(np, OF_DETACHED);
874
875 out_unlock:
876         write_unlock_irqrestore(&devtree_lock, flags);
877 }
878
879 #ifdef CONFIG_PPC_PSERIES
880 /*
881  * Fix up the uninitialized fields in a new device node:
882  * name, type and pci-specific fields
883  */
884
885 static int of_finish_dynamic_node(struct device_node *node)
886 {
887         struct device_node *parent = of_get_parent(node);
888         int err = 0;
889         const phandle *ibm_phandle;
890
891         node->name = of_get_property(node, "name", NULL);
892         node->type = of_get_property(node, "device_type", NULL);
893
894         if (!node->name)
895                 node->name = "<NULL>";
896         if (!node->type)
897                 node->type = "<NULL>";
898
899         if (!parent) {
900                 err = -ENODEV;
901                 goto out;
902         }
903
904         /* We don't support that function on PowerMac, at least
905          * not yet
906          */
907         if (machine_is(powermac))
908                 return -ENODEV;
909
910         /* fix up new node's phandle field */
911         if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL)))
912                 node->phandle = *ibm_phandle;
913
914 out:
915         of_node_put(parent);
916         return err;
917 }
918
919 static int prom_reconfig_notifier(struct notifier_block *nb,
920                                   unsigned long action, void *node)
921 {
922         int err;
923
924         switch (action) {
925         case PSERIES_RECONFIG_ADD:
926                 err = of_finish_dynamic_node(node);
927                 if (err < 0) {
928                         printk(KERN_ERR "finish_node returned %d\n", err);
929                         err = NOTIFY_BAD;
930                 }
931                 break;
932         default:
933                 err = NOTIFY_DONE;
934                 break;
935         }
936         return err;
937 }
938
939 static struct notifier_block prom_reconfig_nb = {
940         .notifier_call = prom_reconfig_notifier,
941         .priority = 10, /* This one needs to run first */
942 };
943
944 static int __init prom_reconfig_setup(void)
945 {
946         return pSeries_reconfig_notifier_register(&prom_reconfig_nb);
947 }
948 __initcall(prom_reconfig_setup);
949 #endif
950
951 /* Find the device node for a given logical cpu number, also returns the cpu
952  * local thread number (index in ibm,interrupt-server#s) if relevant and
953  * asked for (non NULL)
954  */
955 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
956 {
957         int hardid;
958         struct device_node *np;
959
960         hardid = get_hard_smp_processor_id(cpu);
961
962         for_each_node_by_type(np, "cpu") {
963                 const u32 *intserv;
964                 unsigned int plen, t;
965
966                 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist
967                  * fallback to "reg" property and assume no threads
968                  */
969                 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s",
970                                 &plen);
971                 if (intserv == NULL) {
972                         const u32 *reg = of_get_property(np, "reg", NULL);
973                         if (reg == NULL)
974                                 continue;
975                         if (*reg == hardid) {
976                                 if (thread)
977                                         *thread = 0;
978                                 return np;
979                         }
980                 } else {
981                         plen /= sizeof(u32);
982                         for (t = 0; t < plen; t++) {
983                                 if (hardid == intserv[t]) {
984                                         if (thread)
985                                                 *thread = t;
986                                         return np;
987                                 }
988                         }
989                 }
990         }
991         return NULL;
992 }
993 EXPORT_SYMBOL(of_get_cpu_node);
994
995 #if defined(CONFIG_DEBUG_FS) && defined(DEBUG)
996 static struct debugfs_blob_wrapper flat_dt_blob;
997
998 static int __init export_flat_device_tree(void)
999 {
1000         struct dentry *d;
1001
1002         flat_dt_blob.data = initial_boot_params;
1003         flat_dt_blob.size = initial_boot_params->totalsize;
1004
1005         d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR,
1006                                 powerpc_debugfs_root, &flat_dt_blob);
1007         if (!d)
1008                 return 1;
1009
1010         return 0;
1011 }
1012 __initcall(export_flat_device_tree);
1013 #endif