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