1
2
3
4
5
6
7
8
9
10
11
12#undef DEBUG
13
14#include <linux/kernel.h>
15#include <linux/string.h>
16#include <linux/init.h>
17#include <linux/threads.h>
18#include <linux/spinlock.h>
19#include <linux/types.h>
20#include <linux/pci.h>
21#include <linux/delay.h>
22#include <linux/initrd.h>
23#include <linux/bitops.h>
24#include <linux/export.h>
25#include <linux/kexec.h>
26#include <linux/irq.h>
27#include <linux/memblock.h>
28#include <linux/of.h>
29#include <linux/of_fdt.h>
30#include <linux/libfdt.h>
31#include <linux/cpu.h>
32#include <linux/pgtable.h>
33
34#include <asm/prom.h>
35#include <asm/rtas.h>
36#include <asm/page.h>
37#include <asm/processor.h>
38#include <asm/irq.h>
39#include <asm/io.h>
40#include <asm/kdump.h>
41#include <asm/smp.h>
42#include <asm/mmu.h>
43#include <asm/paca.h>
44#include <asm/powernv.h>
45#include <asm/iommu.h>
46#include <asm/btext.h>
47#include <asm/sections.h>
48#include <asm/machdep.h>
49#include <asm/pci-bridge.h>
50#include <asm/kexec.h>
51#include <asm/opal.h>
52#include <asm/fadump.h>
53#include <asm/epapr_hcalls.h>
54#include <asm/firmware.h>
55#include <asm/dt_cpu_ftrs.h>
56#include <asm/drmem.h>
57#include <asm/ultravisor.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
67int *chip_id_lookup_table;
68
69#ifdef CONFIG_PPC64
70int __initdata iommu_is_off;
71int __initdata iommu_force_on;
72unsigned long tce_alloc_start, tce_alloc_end;
73u64 ppc64_rma_size;
74#endif
75static phys_addr_t first_memblock_size;
76static int __initdata boot_cpu_count;
77
78static int __init early_parse_mem(char *p)
79{
80 if (!p)
81 return 1;
82
83 memory_limit = PAGE_ALIGN(memparse(p, &p));
84 DBG("memory limit = 0x%llx\n", memory_limit);
85
86 return 0;
87}
88early_param("mem", early_parse_mem);
89
90
91
92
93
94static inline int overlaps_initrd(unsigned long start, unsigned long size)
95{
96#ifdef CONFIG_BLK_DEV_INITRD
97 if (!initrd_start)
98 return 0;
99
100 return (start + size) > ALIGN_DOWN(initrd_start, PAGE_SIZE) &&
101 start <= ALIGN(initrd_end, PAGE_SIZE);
102#else
103 return 0;
104#endif
105}
106
107
108
109
110
111
112
113
114static void __init move_device_tree(void)
115{
116 unsigned long start, size;
117 void *p;
118
119 DBG("-> move_device_tree\n");
120
121 start = __pa(initial_boot_params);
122 size = fdt_totalsize(initial_boot_params);
123
124 if ((memory_limit && (start + size) > PHYSICAL_START + memory_limit) ||
125 !memblock_is_memory(start + size - 1) ||
126 overlaps_crashkernel(start, size) || overlaps_initrd(start, size)) {
127 p = memblock_alloc_raw(size, PAGE_SIZE);
128 if (!p)
129 panic("Failed to allocate %lu bytes to move device tree\n",
130 size);
131 memcpy(p, initial_boot_params, size);
132 initial_boot_params = p;
133 DBG("Moved device tree to 0x%px\n", p);
134 }
135
136 DBG("<- move_device_tree\n");
137}
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152static struct ibm_pa_feature {
153 unsigned long cpu_features;
154 unsigned long mmu_features;
155 unsigned int cpu_user_ftrs;
156 unsigned int cpu_user_ftrs2;
157 unsigned char pabyte;
158 unsigned char pabit;
159 unsigned char invert;
160} ibm_pa_features[] __initdata = {
161 { .pabyte = 0, .pabit = 0, .cpu_user_ftrs = PPC_FEATURE_HAS_MMU },
162 { .pabyte = 0, .pabit = 1, .cpu_user_ftrs = PPC_FEATURE_HAS_FPU },
163 { .pabyte = 0, .pabit = 3, .cpu_features = CPU_FTR_CTRL },
164 { .pabyte = 0, .pabit = 6, .cpu_features = CPU_FTR_NOEXECUTE },
165 { .pabyte = 1, .pabit = 2, .mmu_features = MMU_FTR_CI_LARGE_PAGE },
166#ifdef CONFIG_PPC_RADIX_MMU
167 { .pabyte = 40, .pabit = 0, .mmu_features = MMU_FTR_TYPE_RADIX | MMU_FTR_GTSE },
168#endif
169 { .pabyte = 5, .pabit = 0, .cpu_features = CPU_FTR_REAL_LE,
170 .cpu_user_ftrs = PPC_FEATURE_TRUE_LE },
171
172
173
174
175
176 { .pabyte = 22, .pabit = 0, .cpu_features = CPU_FTR_TM_COMP,
177 .cpu_user_ftrs2 = PPC_FEATURE2_HTM_COMP | PPC_FEATURE2_HTM_NOSC_COMP },
178
179 { .pabyte = 64, .pabit = 0, .cpu_features = CPU_FTR_DAWR1 },
180};
181
182static void __init scan_features(unsigned long node, const unsigned char *ftrs,
183 unsigned long tablelen,
184 struct ibm_pa_feature *fp,
185 unsigned long ft_size)
186{
187 unsigned long i, len, bit;
188
189
190 for (;;) {
191 if (tablelen < 3)
192 return;
193 len = 2 + ftrs[0];
194 if (tablelen < len)
195 return;
196 if (ftrs[1] == 0)
197 break;
198 tablelen -= len;
199 ftrs += len;
200 }
201
202
203 for (i = 0; i < ft_size; ++i, ++fp) {
204 if (fp->pabyte >= ftrs[0])
205 continue;
206 bit = (ftrs[2 + fp->pabyte] >> (7 - fp->pabit)) & 1;
207 if (bit ^ fp->invert) {
208 cur_cpu_spec->cpu_features |= fp->cpu_features;
209 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftrs;
210 cur_cpu_spec->cpu_user_features2 |= fp->cpu_user_ftrs2;
211 cur_cpu_spec->mmu_features |= fp->mmu_features;
212 } else {
213 cur_cpu_spec->cpu_features &= ~fp->cpu_features;
214 cur_cpu_spec->cpu_user_features &= ~fp->cpu_user_ftrs;
215 cur_cpu_spec->cpu_user_features2 &= ~fp->cpu_user_ftrs2;
216 cur_cpu_spec->mmu_features &= ~fp->mmu_features;
217 }
218 }
219}
220
221static void __init check_cpu_pa_features(unsigned long node)
222{
223 const unsigned char *pa_ftrs;
224 int tablelen;
225
226 pa_ftrs = of_get_flat_dt_prop(node, "ibm,pa-features", &tablelen);
227 if (pa_ftrs == NULL)
228 return;
229
230 scan_features(node, pa_ftrs, tablelen,
231 ibm_pa_features, ARRAY_SIZE(ibm_pa_features));
232}
233
234#ifdef CONFIG_PPC_BOOK3S_64
235static void __init init_mmu_slb_size(unsigned long node)
236{
237 const __be32 *slb_size_ptr;
238
239 slb_size_ptr = of_get_flat_dt_prop(node, "slb-size", NULL) ? :
240 of_get_flat_dt_prop(node, "ibm,slb-size", NULL);
241
242 if (slb_size_ptr)
243 mmu_slb_size = be32_to_cpup(slb_size_ptr);
244}
245#else
246#define init_mmu_slb_size(node) do { } while(0)
247#endif
248
249static struct feature_property {
250 const char *name;
251 u32 min_value;
252 unsigned long cpu_feature;
253 unsigned long cpu_user_ftr;
254} feature_properties[] __initdata = {
255#ifdef CONFIG_ALTIVEC
256 {"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
257 {"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
258#endif
259#ifdef CONFIG_VSX
260
261 {"ibm,vmx", 2, CPU_FTR_VSX, PPC_FEATURE_HAS_VSX},
262#endif
263#ifdef CONFIG_PPC64
264 {"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP},
265 {"ibm,purr", 1, CPU_FTR_PURR, 0},
266 {"ibm,spurr", 1, CPU_FTR_SPURR, 0},
267#endif
268};
269
270#if defined(CONFIG_44x) && defined(CONFIG_PPC_FPU)
271static __init void identical_pvr_fixup(unsigned long node)
272{
273 unsigned int pvr;
274 const char *model = of_get_flat_dt_prop(node, "model", NULL);
275
276
277
278
279
280
281
282
283 if (model && strstr(model, "440EP")) {
284 pvr = cur_cpu_spec->pvr_value | 0x8;
285 identify_cpu(0, pvr);
286 DBG("Using logical pvr %x for %s\n", pvr, model);
287 }
288}
289#else
290#define identical_pvr_fixup(node) do { } while(0)
291#endif
292
293static void __init check_cpu_feature_properties(unsigned long node)
294{
295 int i;
296 struct feature_property *fp = feature_properties;
297 const __be32 *prop;
298
299 for (i = 0; i < (int)ARRAY_SIZE(feature_properties); ++i, ++fp) {
300 prop = of_get_flat_dt_prop(node, fp->name, NULL);
301 if (prop && be32_to_cpup(prop) >= fp->min_value) {
302 cur_cpu_spec->cpu_features |= fp->cpu_feature;
303 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr;
304 }
305 }
306}
307
308static int __init early_init_dt_scan_cpus(unsigned long node,
309 const char *uname, int depth,
310 void *data)
311{
312 const char *type = of_get_flat_dt_prop(node, "device_type", NULL);
313 const __be32 *prop;
314 const __be32 *intserv;
315 int i, nthreads;
316 int len;
317 int found = -1;
318 int found_thread = 0;
319
320
321 if (type == NULL || strcmp(type, "cpu") != 0)
322 return 0;
323
324
325 intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len);
326 if (!intserv)
327 intserv = of_get_flat_dt_prop(node, "reg", &len);
328
329 nthreads = len / sizeof(int);
330
331
332
333
334
335 for (i = 0; i < nthreads; i++) {
336 if (be32_to_cpu(intserv[i]) ==
337 fdt_boot_cpuid_phys(initial_boot_params)) {
338 found = boot_cpu_count;
339 found_thread = i;
340 }
341#ifdef CONFIG_SMP
342
343 boot_cpu_count++;
344#endif
345 }
346
347
348 if (found < 0)
349 return 0;
350
351 DBG("boot cpu: logical %d physical %d\n", found,
352 be32_to_cpu(intserv[found_thread]));
353 boot_cpuid = found;
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374 if (!dt_cpu_ftrs_in_use()) {
375 prop = of_get_flat_dt_prop(node, "cpu-version", NULL);
376 if (prop && (be32_to_cpup(prop) & 0xff000000) == 0x0f000000)
377 identify_cpu(0, be32_to_cpup(prop));
378
379 check_cpu_feature_properties(node);
380 check_cpu_pa_features(node);
381 }
382
383 identical_pvr_fixup(node);
384 init_mmu_slb_size(node);
385
386#ifdef CONFIG_PPC64
387 if (nthreads == 1)
388 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT;
389 else if (!dt_cpu_ftrs_in_use())
390 cur_cpu_spec->cpu_features |= CPU_FTR_SMT;
391 allocate_paca(boot_cpuid);
392#endif
393 set_hard_smp_processor_id(found, be32_to_cpu(intserv[found_thread]));
394
395 return 0;
396}
397
398static int __init early_init_dt_scan_chosen_ppc(unsigned long node,
399 const char *uname,
400 int depth, void *data)
401{
402 const unsigned long *lprop;
403
404
405 if (early_init_dt_scan_chosen(node, uname, depth, data) == 0)
406 return 0;
407
408#ifdef CONFIG_PPC64
409
410 if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL)
411 iommu_is_off = 1;
412 if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL)
413 iommu_force_on = 1;
414#endif
415
416
417 lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL);
418 if (lprop)
419 memory_limit = *lprop;
420
421#ifdef CONFIG_PPC64
422 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL);
423 if (lprop)
424 tce_alloc_start = *lprop;
425 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL);
426 if (lprop)
427 tce_alloc_end = *lprop;
428#endif
429
430#ifdef CONFIG_KEXEC_CORE
431 lprop = of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL);
432 if (lprop)
433 crashk_res.start = *lprop;
434
435 lprop = of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL);
436 if (lprop)
437 crashk_res.end = crashk_res.start + *lprop - 1;
438#endif
439
440
441 return 1;
442}
443
444
445
446
447
448
449#ifdef CONFIG_SPARSEMEM
450static bool validate_mem_limit(u64 base, u64 *size)
451{
452 u64 max_mem = 1UL << (MAX_PHYSMEM_BITS);
453
454 if (base >= max_mem)
455 return false;
456 if ((base + *size) > max_mem)
457 *size = max_mem - base;
458 return true;
459}
460#else
461static bool validate_mem_limit(u64 base, u64 *size)
462{
463 return true;
464}
465#endif
466
467#ifdef CONFIG_PPC_PSERIES
468
469
470
471
472
473static int __init early_init_drmem_lmb(struct drmem_lmb *lmb,
474 const __be32 **usm,
475 void *data)
476{
477 u64 base, size;
478 int is_kexec_kdump = 0, rngs;
479
480 base = lmb->base_addr;
481 size = drmem_lmb_size();
482 rngs = 1;
483
484
485
486
487
488 if ((lmb->flags & DRCONF_MEM_RESERVED) ||
489 !(lmb->flags & DRCONF_MEM_ASSIGNED))
490 return 0;
491
492 if (*usm)
493 is_kexec_kdump = 1;
494
495 if (is_kexec_kdump) {
496
497
498
499
500
501
502
503 rngs = dt_mem_next_cell(dt_root_size_cells, usm);
504 if (!rngs)
505 return 0;
506 }
507
508 do {
509 if (is_kexec_kdump) {
510 base = dt_mem_next_cell(dt_root_addr_cells, usm);
511 size = dt_mem_next_cell(dt_root_size_cells, usm);
512 }
513
514 if (iommu_is_off) {
515 if (base >= 0x80000000ul)
516 continue;
517 if ((base + size) > 0x80000000ul)
518 size = 0x80000000ul - base;
519 }
520
521 if (!validate_mem_limit(base, &size))
522 continue;
523
524 DBG("Adding: %llx -> %llx\n", base, size);
525 memblock_add(base, size);
526
527 if (lmb->flags & DRCONF_MEM_HOTREMOVABLE)
528 memblock_mark_hotplug(base, size);
529 } while (--rngs);
530
531 return 0;
532}
533#endif
534
535static int __init early_init_dt_scan_memory_ppc(unsigned long node,
536 const char *uname,
537 int depth, void *data)
538{
539#ifdef CONFIG_PPC_PSERIES
540 if (depth == 1 &&
541 strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0) {
542 walk_drmem_lmbs_early(node, NULL, early_init_drmem_lmb);
543 return 0;
544 }
545#endif
546
547 return early_init_dt_scan_memory(node, uname, depth, data);
548}
549
550
551
552
553
554
555
556
557
558#ifdef CONFIG_RELOCATABLE
559static int add_mem_to_memblock = 1;
560#else
561#define add_mem_to_memblock 1
562#endif
563
564void __init early_init_dt_add_memory_arch(u64 base, u64 size)
565{
566#ifdef CONFIG_PPC64
567 if (iommu_is_off) {
568 if (base >= 0x80000000ul)
569 return;
570 if ((base + size) > 0x80000000ul)
571 size = 0x80000000ul - base;
572 }
573#endif
574
575
576
577
578 if (base < memstart_addr) {
579 memstart_addr = base;
580 first_memblock_size = size;
581 }
582
583
584 if (add_mem_to_memblock) {
585 if (validate_mem_limit(base, &size))
586 memblock_add(base, size);
587 }
588}
589
590static void __init early_reserve_mem_dt(void)
591{
592 unsigned long i, dt_root;
593 int len;
594 const __be32 *prop;
595
596 early_init_fdt_reserve_self();
597 early_init_fdt_scan_reserved_mem();
598
599 dt_root = of_get_flat_dt_root();
600
601 prop = of_get_flat_dt_prop(dt_root, "reserved-ranges", &len);
602
603 if (!prop)
604 return;
605
606 DBG("Found new-style reserved-ranges\n");
607
608
609
610 for (i = 0; i < len / (sizeof(*prop) * 4); i++) {
611 u64 base, size;
612
613 base = of_read_number(prop + (i * 4) + 0, 2);
614 size = of_read_number(prop + (i * 4) + 2, 2);
615
616 if (size) {
617 DBG("reserving: %llx -> %llx\n", base, size);
618 memblock_reserve(base, size);
619 }
620 }
621}
622
623static void __init early_reserve_mem(void)
624{
625 __be64 *reserve_map;
626
627 reserve_map = (__be64 *)(((unsigned long)initial_boot_params) +
628 fdt_off_mem_rsvmap(initial_boot_params));
629
630
631 early_reserve_mem_dt();
632
633#ifdef CONFIG_BLK_DEV_INITRD
634
635 if (initrd_start && (initrd_end > initrd_start)) {
636 memblock_reserve(ALIGN_DOWN(__pa(initrd_start), PAGE_SIZE),
637 ALIGN(initrd_end, PAGE_SIZE) -
638 ALIGN_DOWN(initrd_start, PAGE_SIZE));
639 }
640#endif
641
642 if (!IS_ENABLED(CONFIG_PPC32))
643 return;
644
645
646
647
648
649 if (be64_to_cpup(reserve_map) > 0xffffffffull) {
650 u32 base_32, size_32;
651 __be32 *reserve_map_32 = (__be32 *)reserve_map;
652
653 DBG("Found old 32-bit reserve map\n");
654
655 while (1) {
656 base_32 = be32_to_cpup(reserve_map_32++);
657 size_32 = be32_to_cpup(reserve_map_32++);
658 if (size_32 == 0)
659 break;
660 DBG("reserving: %x -> %x\n", base_32, size_32);
661 memblock_reserve(base_32, size_32);
662 }
663 return;
664 }
665}
666
667#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
668static bool tm_disabled __initdata;
669
670static int __init parse_ppc_tm(char *str)
671{
672 bool res;
673
674 if (kstrtobool(str, &res))
675 return -EINVAL;
676
677 tm_disabled = !res;
678
679 return 0;
680}
681early_param("ppc_tm", parse_ppc_tm);
682
683static void __init tm_init(void)
684{
685 if (tm_disabled) {
686 pr_info("Disabling hardware transactional memory (HTM)\n");
687 cur_cpu_spec->cpu_user_features2 &=
688 ~(PPC_FEATURE2_HTM_NOSC | PPC_FEATURE2_HTM);
689 cur_cpu_spec->cpu_features &= ~CPU_FTR_TM;
690 return;
691 }
692
693 pnv_tm_init();
694}
695#else
696static void tm_init(void) { }
697#endif
698
699#ifdef CONFIG_PPC64
700static void __init save_fscr_to_task(void)
701{
702
703
704
705
706
707
708 if (early_cpu_has_feature(CPU_FTR_ARCH_207S))
709 init_task.thread.fscr = mfspr(SPRN_FSCR);
710}
711#else
712static inline void save_fscr_to_task(void) {}
713#endif
714
715
716void __init early_init_devtree(void *params)
717{
718 phys_addr_t limit;
719
720 DBG(" -> early_init_devtree(%px)\n", params);
721
722
723 if (!early_init_dt_verify(params))
724 panic("BUG: Failed verifying flat device tree, bad version?");
725
726#ifdef CONFIG_PPC_RTAS
727
728 of_scan_flat_dt(early_init_dt_scan_rtas, NULL);
729#endif
730
731#ifdef CONFIG_PPC_POWERNV
732
733 of_scan_flat_dt(early_init_dt_scan_opal, NULL);
734
735
736 of_scan_flat_dt(early_init_dt_scan_ultravisor, NULL);
737#endif
738
739#if defined(CONFIG_FA_DUMP) || defined(CONFIG_PRESERVE_FA_DUMP)
740
741 of_scan_flat_dt(early_init_dt_scan_fw_dump, NULL);
742#endif
743
744
745
746
747
748 of_scan_flat_dt(early_init_dt_scan_chosen_ppc, boot_command_line);
749
750
751 of_scan_flat_dt(early_init_dt_scan_root, NULL);
752 of_scan_flat_dt(early_init_dt_scan_memory_ppc, NULL);
753
754 parse_early_param();
755
756
757 if (memory_limit)
758 first_memblock_size = min_t(u64, first_memblock_size, memory_limit);
759 setup_initial_memory_limit(memstart_addr, first_memblock_size);
760
761 memblock_reserve(PHYSICAL_START, __pa(_end) - PHYSICAL_START);
762
763 if (PHYSICAL_START > MEMORY_START)
764 memblock_reserve(MEMORY_START, 0x8000);
765 reserve_kdump_trampoline();
766#if defined(CONFIG_FA_DUMP) || defined(CONFIG_PRESERVE_FA_DUMP)
767
768
769
770
771 if (fadump_reserve_mem() == 0)
772#endif
773 reserve_crashkernel();
774 early_reserve_mem();
775
776
777 limit = ALIGN(memory_limit ?: memblock_phys_mem_size(), PAGE_SIZE);
778 memblock_enforce_memory_limit(limit);
779
780#if defined(CONFIG_PPC_BOOK3S_64) && defined(CONFIG_PPC_4K_PAGES)
781 if (!early_radix_enabled())
782 memblock_cap_memory_range(0, 1UL << (H_MAX_PHYSMEM_BITS));
783#endif
784
785 memblock_allow_resize();
786 memblock_dump_all();
787
788 DBG("Phys. mem: %llx\n", (unsigned long long)memblock_phys_mem_size());
789
790
791
792 move_device_tree();
793
794 allocate_paca_ptrs();
795
796 DBG("Scanning CPUs ...\n");
797
798 dt_cpu_ftrs_scan();
799
800
801
802
803 of_scan_flat_dt(early_init_dt_scan_cpus, NULL);
804 if (boot_cpuid < 0) {
805 printk("Failed to identify boot CPU !\n");
806 BUG();
807 }
808
809 save_fscr_to_task();
810
811#if defined(CONFIG_SMP) && defined(CONFIG_PPC64)
812
813
814
815 spinning_secondaries = boot_cpu_count - 1;
816#endif
817
818 mmu_early_init_devtree();
819
820#ifdef CONFIG_PPC_POWERNV
821
822 of_scan_flat_dt(early_init_dt_scan_recoverable_ranges, NULL);
823#endif
824 epapr_paravirt_early_init();
825
826
827 pseries_probe_fw_features();
828
829
830
831
832 pkey_early_init_devtree();
833
834#ifdef CONFIG_PPC_PS3
835
836 if (of_flat_dt_is_compatible(of_get_flat_dt_root(), "sony,ps3"))
837 powerpc_firmware_features |= FW_FEATURE_PS3_POSSIBLE;
838#endif
839
840 tm_init();
841
842 DBG(" <- early_init_devtree()\n");
843}
844
845#ifdef CONFIG_RELOCATABLE
846
847
848
849
850void __init early_get_first_memblock_info(void *params, phys_addr_t *size)
851{
852
853 initial_boot_params = params;
854
855
856
857
858
859 add_mem_to_memblock = 0;
860 of_scan_flat_dt(early_init_dt_scan_root, NULL);
861 of_scan_flat_dt(early_init_dt_scan_memory_ppc, NULL);
862 add_mem_to_memblock = 1;
863
864 if (size)
865 *size = first_memblock_size;
866}
867#endif
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888int of_get_ibm_chip_id(struct device_node *np)
889{
890 of_node_get(np);
891 while (np) {
892 u32 chip_id;
893
894
895
896
897
898 if (!of_property_read_u32(np, "ibm,chip-id", &chip_id)) {
899 of_node_put(np);
900 return chip_id;
901 }
902
903 np = of_get_next_parent(np);
904 }
905 return -1;
906}
907EXPORT_SYMBOL(of_get_ibm_chip_id);
908
909
910
911
912
913
914
915
916int cpu_to_chip_id(int cpu)
917{
918 struct device_node *np;
919 int ret = -1, idx;
920
921 idx = cpu / threads_per_core;
922 if (chip_id_lookup_table && chip_id_lookup_table[idx] != -1)
923 return chip_id_lookup_table[idx];
924
925 np = of_get_cpu_node(cpu, NULL);
926 if (np) {
927 ret = of_get_ibm_chip_id(np);
928 of_node_put(np);
929
930 if (chip_id_lookup_table)
931 chip_id_lookup_table[idx] = ret;
932 }
933
934 return ret;
935}
936EXPORT_SYMBOL(cpu_to_chip_id);
937
938bool arch_match_cpu_phys_id(int cpu, u64 phys_id)
939{
940#ifdef CONFIG_SMP
941
942
943
944
945
946 if (cpu_to_phys_id != NULL)
947 return (int)phys_id == cpu_to_phys_id[cpu];
948#endif
949
950 return (int)phys_id == get_hard_smp_processor_id(cpu);
951}
952