1
2
3
4
5
6
7
8
9
10
11
12
13#undef DEBUG
14
15#include <linux/module.h>
16#include <linux/string.h>
17#include <linux/sched.h>
18#include <linux/init.h>
19#include <linux/kernel.h>
20#include <linux/reboot.h>
21#include <linux/delay.h>
22#include <linux/initrd.h>
23#include <linux/seq_file.h>
24#include <linux/ioport.h>
25#include <linux/console.h>
26#include <linux/utsname.h>
27#include <linux/tty.h>
28#include <linux/root_dev.h>
29#include <linux/notifier.h>
30#include <linux/cpu.h>
31#include <linux/unistd.h>
32#include <linux/serial.h>
33#include <linux/serial_8250.h>
34#include <linux/bootmem.h>
35#include <linux/pci.h>
36#include <linux/lockdep.h>
37#include <linux/lmb.h>
38#include <asm/io.h>
39#include <asm/kdump.h>
40#include <asm/prom.h>
41#include <asm/processor.h>
42#include <asm/pgtable.h>
43#include <asm/smp.h>
44#include <asm/elf.h>
45#include <asm/machdep.h>
46#include <asm/paca.h>
47#include <asm/time.h>
48#include <asm/cputable.h>
49#include <asm/sections.h>
50#include <asm/btext.h>
51#include <asm/nvram.h>
52#include <asm/setup.h>
53#include <asm/system.h>
54#include <asm/rtas.h>
55#include <asm/iommu.h>
56#include <asm/serial.h>
57#include <asm/cache.h>
58#include <asm/page.h>
59#include <asm/mmu.h>
60#include <asm/firmware.h>
61#include <asm/xmon.h>
62#include <asm/udbg.h>
63#include <asm/kexec.h>
64#include <asm/swiotlb.h>
65#include <asm/mmu_context.h>
66
67#include "setup.h"
68
69#ifdef DEBUG
70#define DBG(fmt...) udbg_printf(fmt)
71#else
72#define DBG(fmt...)
73#endif
74
75int boot_cpuid = 0;
76u64 ppc64_pft_size;
77
78
79
80
81struct ppc64_caches ppc64_caches = {
82 .dline_size = 0x40,
83 .log_dline_size = 6,
84 .iline_size = 0x40,
85 .log_iline_size = 6
86};
87EXPORT_SYMBOL_GPL(ppc64_caches);
88
89
90
91
92
93int dcache_bsize;
94int icache_bsize;
95int ucache_bsize;
96
97#ifdef CONFIG_SMP
98
99static int smt_enabled_cmdline;
100
101
102static void check_smt_enabled(void)
103{
104 struct device_node *dn;
105 const char *smt_option;
106
107
108 if (smt_enabled_cmdline)
109 return;
110
111 dn = of_find_node_by_path("/options");
112
113 if (dn) {
114 smt_option = of_get_property(dn, "ibm,smt-enabled", NULL);
115
116 if (smt_option) {
117 if (!strcmp(smt_option, "on"))
118 smt_enabled_at_boot = 1;
119 else if (!strcmp(smt_option, "off"))
120 smt_enabled_at_boot = 0;
121 }
122 }
123}
124
125
126static int __init early_smt_enabled(char *p)
127{
128 smt_enabled_cmdline = 1;
129
130 if (!p)
131 return 0;
132
133 if (!strcmp(p, "on") || !strcmp(p, "1"))
134 smt_enabled_at_boot = 1;
135 else if (!strcmp(p, "off") || !strcmp(p, "0"))
136 smt_enabled_at_boot = 0;
137
138 return 0;
139}
140early_param("smt-enabled", early_smt_enabled);
141
142#else
143#define check_smt_enabled()
144#endif
145
146
147void __init setup_paca(int cpu)
148{
149 local_paca = &paca[cpu];
150 mtspr(SPRN_SPRG_PACA, local_paca);
151#ifdef CONFIG_PPC_BOOK3E
152 mtspr(SPRN_SPRG_TLB_EXFRAME, local_paca->extlb);
153#endif
154}
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175void __init early_setup(unsigned long dt_ptr)
176{
177
178
179
180 initialise_pacas();
181
182
183 identify_cpu(0, mfspr(SPRN_PVR));
184
185
186 setup_paca(0);
187
188
189 lockdep_init();
190
191
192
193
194 udbg_early_init();
195
196 DBG(" -> early_setup(), dt_ptr: 0x%lx\n", dt_ptr);
197
198
199
200
201
202
203 early_init_devtree(__va(dt_ptr));
204
205
206 setup_paca(boot_cpuid);
207
208
209 get_paca()->cpu_start = 1;
210
211
212 probe_machine();
213
214 setup_kdump_trampoline();
215
216 DBG("Found, Initializing memory management...\n");
217
218
219 early_init_mmu();
220
221 DBG(" <- early_setup()\n");
222}
223
224#ifdef CONFIG_SMP
225void early_setup_secondary(void)
226{
227
228 get_paca()->soft_enabled = 0;
229
230
231 early_init_mmu_secondary();
232}
233
234#endif
235
236#if defined(CONFIG_SMP) || defined(CONFIG_KEXEC)
237void smp_release_cpus(void)
238{
239 unsigned long *ptr;
240
241 DBG(" -> smp_release_cpus()\n");
242
243
244
245
246
247
248
249 ptr = (unsigned long *)((unsigned long)&__secondary_hold_spinloop
250 - PHYSICAL_START);
251 *ptr = __pa(generic_secondary_smp_init);
252 mb();
253
254 DBG(" <- smp_release_cpus()\n");
255}
256#endif
257
258
259
260
261
262
263
264
265static void __init initialize_cache_info(void)
266{
267 struct device_node *np;
268 unsigned long num_cpus = 0;
269
270 DBG(" -> initialize_cache_info()\n");
271
272 for (np = NULL; (np = of_find_node_by_type(np, "cpu"));) {
273 num_cpus += 1;
274
275
276
277
278
279 if ( num_cpus == 1 ) {
280 const u32 *sizep, *lsizep;
281 u32 size, lsize;
282
283 size = 0;
284 lsize = cur_cpu_spec->dcache_bsize;
285 sizep = of_get_property(np, "d-cache-size", NULL);
286 if (sizep != NULL)
287 size = *sizep;
288 lsizep = of_get_property(np, "d-cache-block-size", NULL);
289
290 if (lsizep == NULL)
291 lsizep = of_get_property(np, "d-cache-line-size", NULL);
292 if (lsizep != NULL)
293 lsize = *lsizep;
294 if (sizep == 0 || lsizep == 0)
295 DBG("Argh, can't find dcache properties ! "
296 "sizep: %p, lsizep: %p\n", sizep, lsizep);
297
298 ppc64_caches.dsize = size;
299 ppc64_caches.dline_size = lsize;
300 ppc64_caches.log_dline_size = __ilog2(lsize);
301 ppc64_caches.dlines_per_page = PAGE_SIZE / lsize;
302
303 size = 0;
304 lsize = cur_cpu_spec->icache_bsize;
305 sizep = of_get_property(np, "i-cache-size", NULL);
306 if (sizep != NULL)
307 size = *sizep;
308 lsizep = of_get_property(np, "i-cache-block-size", NULL);
309 if (lsizep == NULL)
310 lsizep = of_get_property(np, "i-cache-line-size", NULL);
311 if (lsizep != NULL)
312 lsize = *lsizep;
313 if (sizep == 0 || lsizep == 0)
314 DBG("Argh, can't find icache properties ! "
315 "sizep: %p, lsizep: %p\n", sizep, lsizep);
316
317 ppc64_caches.isize = size;
318 ppc64_caches.iline_size = lsize;
319 ppc64_caches.log_iline_size = __ilog2(lsize);
320 ppc64_caches.ilines_per_page = PAGE_SIZE / lsize;
321 }
322 }
323
324 DBG(" <- initialize_cache_info()\n");
325}
326
327
328
329
330
331
332void __init setup_system(void)
333{
334 DBG(" -> setup_system()\n");
335
336
337
338
339 do_feature_fixups(cur_cpu_spec->cpu_features,
340 &__start___ftr_fixup, &__stop___ftr_fixup);
341 do_feature_fixups(cur_cpu_spec->mmu_features,
342 &__start___mmu_ftr_fixup, &__stop___mmu_ftr_fixup);
343 do_feature_fixups(powerpc_firmware_features,
344 &__start___fw_ftr_fixup, &__stop___fw_ftr_fixup);
345 do_lwsync_fixups(cur_cpu_spec->cpu_features,
346 &__start___lwsync_fixup, &__stop___lwsync_fixup);
347
348
349
350
351 unflatten_device_tree();
352
353
354
355
356
357 initialize_cache_info();
358
359
360
361
362 irq_early_init();
363
364#ifdef CONFIG_PPC_RTAS
365
366
367
368 rtas_initialize();
369#endif
370
371
372
373
374 check_for_initrd();
375
376
377
378
379
380
381 if (ppc_md.init_early)
382 ppc_md.init_early();
383
384
385
386
387
388
389 find_legacy_serial_ports();
390
391
392
393
394 register_early_udbg_console();
395
396
397
398
399 xmon_setup();
400
401 check_smt_enabled();
402 smp_setup_cpu_maps();
403
404#ifdef CONFIG_SMP
405
406
407
408 smp_release_cpus();
409#endif
410
411 printk("Starting Linux PPC64 %s\n", init_utsname()->version);
412
413 printk("-----------------------------------------------------\n");
414 printk("ppc64_pft_size = 0x%llx\n", ppc64_pft_size);
415 printk("physicalMemorySize = 0x%llx\n", lmb_phys_mem_size());
416 if (ppc64_caches.dline_size != 0x80)
417 printk("ppc64_caches.dcache_line_size = 0x%x\n",
418 ppc64_caches.dline_size);
419 if (ppc64_caches.iline_size != 0x80)
420 printk("ppc64_caches.icache_line_size = 0x%x\n",
421 ppc64_caches.iline_size);
422#ifdef CONFIG_PPC_STD_MMU_64
423 if (htab_address)
424 printk("htab_address = 0x%p\n", htab_address);
425 printk("htab_hash_mask = 0x%lx\n", htab_hash_mask);
426#endif
427 if (PHYSICAL_START > 0)
428 printk("physical_start = 0x%llx\n",
429 (unsigned long long)PHYSICAL_START);
430 printk("-----------------------------------------------------\n");
431
432 DBG(" <- setup_system()\n");
433}
434
435#ifdef CONFIG_IRQSTACKS
436static void __init irqstack_early_init(void)
437{
438 unsigned int i;
439
440
441
442
443
444 for_each_possible_cpu(i) {
445 softirq_ctx[i] = (struct thread_info *)
446 __va(lmb_alloc_base(THREAD_SIZE,
447 THREAD_SIZE, 0x10000000));
448 hardirq_ctx[i] = (struct thread_info *)
449 __va(lmb_alloc_base(THREAD_SIZE,
450 THREAD_SIZE, 0x10000000));
451 }
452}
453#else
454#define irqstack_early_init()
455#endif
456
457#ifdef CONFIG_PPC_BOOK3E
458static void __init exc_lvl_early_init(void)
459{
460 unsigned int i;
461
462 for_each_possible_cpu(i) {
463 critirq_ctx[i] = (struct thread_info *)
464 __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
465 dbgirq_ctx[i] = (struct thread_info *)
466 __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
467 mcheckirq_ctx[i] = (struct thread_info *)
468 __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
469 }
470}
471#else
472#define exc_lvl_early_init()
473#endif
474
475
476
477
478
479static void __init emergency_stack_init(void)
480{
481 unsigned long limit;
482 unsigned int i;
483
484
485
486
487
488
489
490
491
492
493 limit = min(0x10000000ULL, lmb.rmo_size);
494
495 for_each_possible_cpu(i) {
496 unsigned long sp;
497 sp = lmb_alloc_base(THREAD_SIZE, THREAD_SIZE, limit);
498 sp += THREAD_SIZE;
499 paca[i].emergency_sp = __va(sp);
500 }
501}
502
503
504
505
506
507
508void __init setup_arch(char **cmdline_p)
509{
510 ppc64_boot_msg(0x12, "Setup Arch");
511
512 *cmdline_p = cmd_line;
513
514
515
516
517
518
519 dcache_bsize = ppc64_caches.dline_size;
520 icache_bsize = ppc64_caches.iline_size;
521
522
523 panic_timeout = 180;
524
525 if (ppc_md.panic)
526 setup_panic();
527
528 init_mm.start_code = (unsigned long)_stext;
529 init_mm.end_code = (unsigned long) _etext;
530 init_mm.end_data = (unsigned long) _edata;
531 init_mm.brk = klimit;
532
533 irqstack_early_init();
534 exc_lvl_early_init();
535 emergency_stack_init();
536
537#ifdef CONFIG_PPC_STD_MMU_64
538 stabs_alloc();
539#endif
540
541 do_init_bootmem();
542 sparse_init();
543
544#ifdef CONFIG_DUMMY_CONSOLE
545 conswitchp = &dummy_con;
546#endif
547
548 if (ppc_md.setup_arch)
549 ppc_md.setup_arch();
550
551#ifdef CONFIG_SWIOTLB
552 if (ppc_swiotlb_enable)
553 swiotlb_init();
554#endif
555
556 paging_init();
557
558
559 mmu_context_init();
560
561 ppc64_boot_msg(0x15, "Setup Done");
562}
563
564
565
566#define PPC64_LINUX_FUNCTION 0x0f000000
567#define PPC64_IPL_MESSAGE 0xc0000000
568#define PPC64_TERM_MESSAGE 0xb0000000
569
570static void ppc64_do_msg(unsigned int src, const char *msg)
571{
572 if (ppc_md.progress) {
573 char buf[128];
574
575 sprintf(buf, "%08X\n", src);
576 ppc_md.progress(buf, 0);
577 snprintf(buf, 128, "%s", msg);
578 ppc_md.progress(buf, 0);
579 }
580}
581
582
583void ppc64_boot_msg(unsigned int src, const char *msg)
584{
585 ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_IPL_MESSAGE|src, msg);
586 printk("[boot]%04x %s\n", src, msg);
587}
588
589void cpu_die(void)
590{
591 if (ppc_md.cpu_die)
592 ppc_md.cpu_die();
593}
594
595#ifdef CONFIG_SMP
596#define PCPU_DYN_SIZE ()
597
598static void * __init pcpu_fc_alloc(unsigned int cpu, size_t size, size_t align)
599{
600 return __alloc_bootmem_node(NODE_DATA(cpu_to_node(cpu)), size, align,
601 __pa(MAX_DMA_ADDRESS));
602}
603
604static void __init pcpu_fc_free(void *ptr, size_t size)
605{
606 free_bootmem(__pa(ptr), size);
607}
608
609static int pcpu_cpu_distance(unsigned int from, unsigned int to)
610{
611 if (cpu_to_node(from) == cpu_to_node(to))
612 return LOCAL_DISTANCE;
613 else
614 return REMOTE_DISTANCE;
615}
616
617void __init setup_per_cpu_areas(void)
618{
619 const size_t dyn_size = PERCPU_MODULE_RESERVE + PERCPU_DYNAMIC_RESERVE;
620 size_t atom_size;
621 unsigned long delta;
622 unsigned int cpu;
623 int rc;
624
625
626
627
628
629
630 if (mmu_linear_psize == MMU_PAGE_4K)
631 atom_size = PAGE_SIZE;
632 else
633 atom_size = 1 << 20;
634
635 rc = pcpu_embed_first_chunk(0, dyn_size, atom_size, pcpu_cpu_distance,
636 pcpu_fc_alloc, pcpu_fc_free);
637 if (rc < 0)
638 panic("cannot initialize percpu area (err=%d)", rc);
639
640 delta = (unsigned long)pcpu_base_addr - (unsigned long)__per_cpu_start;
641 for_each_possible_cpu(cpu)
642 paca[cpu].data_offset = delta + pcpu_unit_offsets[cpu];
643}
644#endif
645
646
647#ifdef CONFIG_PPC_INDIRECT_IO
648struct ppc_pci_io ppc_pci_io;
649EXPORT_SYMBOL(ppc_pci_io);
650#endif
651
652