diff options
Diffstat (limited to 'arch/ppc64/kernel/setup.c')
-rw-r--r-- | arch/ppc64/kernel/setup.c | 1307 |
1 files changed, 0 insertions, 1307 deletions
diff --git a/arch/ppc64/kernel/setup.c b/arch/ppc64/kernel/setup.c deleted file mode 100644 index 44ee6ebe9a60..000000000000 --- a/arch/ppc64/kernel/setup.c +++ /dev/null | |||
@@ -1,1307 +0,0 @@ | |||
1 | /* | ||
2 | * | ||
3 | * Common boot and setup code. | ||
4 | * | ||
5 | * Copyright (C) 2001 PPC64 Team, IBM Corp | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU General Public License | ||
9 | * as published by the Free Software Foundation; either version | ||
10 | * 2 of the License, or (at your option) any later version. | ||
11 | */ | ||
12 | |||
13 | #undef DEBUG | ||
14 | |||
15 | #include <linux/config.h> | ||
16 | #include <linux/module.h> | ||
17 | #include <linux/string.h> | ||
18 | #include <linux/sched.h> | ||
19 | #include <linux/init.h> | ||
20 | #include <linux/kernel.h> | ||
21 | #include <linux/reboot.h> | ||
22 | #include <linux/delay.h> | ||
23 | #include <linux/initrd.h> | ||
24 | #include <linux/ide.h> | ||
25 | #include <linux/seq_file.h> | ||
26 | #include <linux/ioport.h> | ||
27 | #include <linux/console.h> | ||
28 | #include <linux/utsname.h> | ||
29 | #include <linux/tty.h> | ||
30 | #include <linux/root_dev.h> | ||
31 | #include <linux/notifier.h> | ||
32 | #include <linux/cpu.h> | ||
33 | #include <linux/unistd.h> | ||
34 | #include <linux/serial.h> | ||
35 | #include <linux/serial_8250.h> | ||
36 | #include <asm/io.h> | ||
37 | #include <asm/prom.h> | ||
38 | #include <asm/processor.h> | ||
39 | #include <asm/pgtable.h> | ||
40 | #include <asm/bootinfo.h> | ||
41 | #include <asm/smp.h> | ||
42 | #include <asm/elf.h> | ||
43 | #include <asm/machdep.h> | ||
44 | #include <asm/paca.h> | ||
45 | #include <asm/ppcdebug.h> | ||
46 | #include <asm/time.h> | ||
47 | #include <asm/cputable.h> | ||
48 | #include <asm/sections.h> | ||
49 | #include <asm/btext.h> | ||
50 | #include <asm/nvram.h> | ||
51 | #include <asm/setup.h> | ||
52 | #include <asm/system.h> | ||
53 | #include <asm/rtas.h> | ||
54 | #include <asm/iommu.h> | ||
55 | #include <asm/serial.h> | ||
56 | #include <asm/cache.h> | ||
57 | #include <asm/page.h> | ||
58 | #include <asm/mmu.h> | ||
59 | #include <asm/lmb.h> | ||
60 | #include <asm/iSeries/ItLpNaca.h> | ||
61 | #include <asm/firmware.h> | ||
62 | |||
63 | #ifdef DEBUG | ||
64 | #define DBG(fmt...) udbg_printf(fmt) | ||
65 | #else | ||
66 | #define DBG(fmt...) | ||
67 | #endif | ||
68 | |||
69 | /* | ||
70 | * Here are some early debugging facilities. You can enable one | ||
71 | * but your kernel will not boot on anything else if you do so | ||
72 | */ | ||
73 | |||
74 | /* This one is for use on LPAR machines that support an HVC console | ||
75 | * on vterm 0 | ||
76 | */ | ||
77 | extern void udbg_init_debug_lpar(void); | ||
78 | /* This one is for use on Apple G5 machines | ||
79 | */ | ||
80 | extern void udbg_init_pmac_realmode(void); | ||
81 | /* That's RTAS panel debug */ | ||
82 | extern void call_rtas_display_status_delay(unsigned char c); | ||
83 | /* Here's maple real mode debug */ | ||
84 | extern void udbg_init_maple_realmode(void); | ||
85 | |||
86 | #define EARLY_DEBUG_INIT() do {} while(0) | ||
87 | |||
88 | #if 0 | ||
89 | #define EARLY_DEBUG_INIT() udbg_init_debug_lpar() | ||
90 | #define EARLY_DEBUG_INIT() udbg_init_maple_realmode() | ||
91 | #define EARLY_DEBUG_INIT() udbg_init_pmac_realmode() | ||
92 | #define EARLY_DEBUG_INIT() \ | ||
93 | do { udbg_putc = call_rtas_display_status_delay; } while(0) | ||
94 | #endif | ||
95 | |||
96 | /* extern void *stab; */ | ||
97 | extern unsigned long klimit; | ||
98 | |||
99 | extern void mm_init_ppc64(void); | ||
100 | extern void stab_initialize(unsigned long stab); | ||
101 | extern void htab_initialize(void); | ||
102 | extern void early_init_devtree(void *flat_dt); | ||
103 | extern void unflatten_device_tree(void); | ||
104 | |||
105 | extern void smp_release_cpus(void); | ||
106 | |||
107 | int have_of = 1; | ||
108 | int boot_cpuid = 0; | ||
109 | int boot_cpuid_phys = 0; | ||
110 | dev_t boot_dev; | ||
111 | u64 ppc64_pft_size; | ||
112 | |||
113 | struct ppc64_caches ppc64_caches; | ||
114 | EXPORT_SYMBOL_GPL(ppc64_caches); | ||
115 | |||
116 | /* | ||
117 | * These are used in binfmt_elf.c to put aux entries on the stack | ||
118 | * for each elf executable being started. | ||
119 | */ | ||
120 | int dcache_bsize; | ||
121 | int icache_bsize; | ||
122 | int ucache_bsize; | ||
123 | |||
124 | /* The main machine-dep calls structure | ||
125 | */ | ||
126 | struct machdep_calls ppc_md; | ||
127 | EXPORT_SYMBOL(ppc_md); | ||
128 | |||
129 | #ifdef CONFIG_MAGIC_SYSRQ | ||
130 | unsigned long SYSRQ_KEY; | ||
131 | #endif /* CONFIG_MAGIC_SYSRQ */ | ||
132 | |||
133 | |||
134 | static int ppc64_panic_event(struct notifier_block *, unsigned long, void *); | ||
135 | static struct notifier_block ppc64_panic_block = { | ||
136 | .notifier_call = ppc64_panic_event, | ||
137 | .priority = INT_MIN /* may not return; must be done last */ | ||
138 | }; | ||
139 | |||
140 | /* | ||
141 | * Perhaps we can put the pmac screen_info[] here | ||
142 | * on pmac as well so we don't need the ifdef's. | ||
143 | * Until we get multiple-console support in here | ||
144 | * that is. -- Cort | ||
145 | * Maybe tie it to serial consoles, since this is really what | ||
146 | * these processors use on existing boards. -- Dan | ||
147 | */ | ||
148 | struct screen_info screen_info = { | ||
149 | .orig_x = 0, | ||
150 | .orig_y = 25, | ||
151 | .orig_video_cols = 80, | ||
152 | .orig_video_lines = 25, | ||
153 | .orig_video_isVGA = 1, | ||
154 | .orig_video_points = 16 | ||
155 | }; | ||
156 | |||
157 | #ifdef CONFIG_SMP | ||
158 | |||
159 | static int smt_enabled_cmdline; | ||
160 | |||
161 | /* Look for ibm,smt-enabled OF option */ | ||
162 | static void check_smt_enabled(void) | ||
163 | { | ||
164 | struct device_node *dn; | ||
165 | char *smt_option; | ||
166 | |||
167 | /* Allow the command line to overrule the OF option */ | ||
168 | if (smt_enabled_cmdline) | ||
169 | return; | ||
170 | |||
171 | dn = of_find_node_by_path("/options"); | ||
172 | |||
173 | if (dn) { | ||
174 | smt_option = (char *)get_property(dn, "ibm,smt-enabled", NULL); | ||
175 | |||
176 | if (smt_option) { | ||
177 | if (!strcmp(smt_option, "on")) | ||
178 | smt_enabled_at_boot = 1; | ||
179 | else if (!strcmp(smt_option, "off")) | ||
180 | smt_enabled_at_boot = 0; | ||
181 | } | ||
182 | } | ||
183 | } | ||
184 | |||
185 | /* Look for smt-enabled= cmdline option */ | ||
186 | static int __init early_smt_enabled(char *p) | ||
187 | { | ||
188 | smt_enabled_cmdline = 1; | ||
189 | |||
190 | if (!p) | ||
191 | return 0; | ||
192 | |||
193 | if (!strcmp(p, "on") || !strcmp(p, "1")) | ||
194 | smt_enabled_at_boot = 1; | ||
195 | else if (!strcmp(p, "off") || !strcmp(p, "0")) | ||
196 | smt_enabled_at_boot = 0; | ||
197 | |||
198 | return 0; | ||
199 | } | ||
200 | early_param("smt-enabled", early_smt_enabled); | ||
201 | |||
202 | /** | ||
203 | * setup_cpu_maps - initialize the following cpu maps: | ||
204 | * cpu_possible_map | ||
205 | * cpu_present_map | ||
206 | * cpu_sibling_map | ||
207 | * | ||
208 | * Having the possible map set up early allows us to restrict allocations | ||
209 | * of things like irqstacks to num_possible_cpus() rather than NR_CPUS. | ||
210 | * | ||
211 | * We do not initialize the online map here; cpus set their own bits in | ||
212 | * cpu_online_map as they come up. | ||
213 | * | ||
214 | * This function is valid only for Open Firmware systems. finish_device_tree | ||
215 | * must be called before using this. | ||
216 | * | ||
217 | * While we're here, we may as well set the "physical" cpu ids in the paca. | ||
218 | */ | ||
219 | static void __init setup_cpu_maps(void) | ||
220 | { | ||
221 | struct device_node *dn = NULL; | ||
222 | int cpu = 0; | ||
223 | int swap_cpuid = 0; | ||
224 | |||
225 | check_smt_enabled(); | ||
226 | |||
227 | while ((dn = of_find_node_by_type(dn, "cpu")) && cpu < NR_CPUS) { | ||
228 | u32 *intserv; | ||
229 | int j, len = sizeof(u32), nthreads; | ||
230 | |||
231 | intserv = (u32 *)get_property(dn, "ibm,ppc-interrupt-server#s", | ||
232 | &len); | ||
233 | if (!intserv) | ||
234 | intserv = (u32 *)get_property(dn, "reg", NULL); | ||
235 | |||
236 | nthreads = len / sizeof(u32); | ||
237 | |||
238 | for (j = 0; j < nthreads && cpu < NR_CPUS; j++) { | ||
239 | cpu_set(cpu, cpu_present_map); | ||
240 | set_hard_smp_processor_id(cpu, intserv[j]); | ||
241 | |||
242 | if (intserv[j] == boot_cpuid_phys) | ||
243 | swap_cpuid = cpu; | ||
244 | cpu_set(cpu, cpu_possible_map); | ||
245 | cpu++; | ||
246 | } | ||
247 | } | ||
248 | |||
249 | /* Swap CPU id 0 with boot_cpuid_phys, so we can always assume that | ||
250 | * boot cpu is logical 0. | ||
251 | */ | ||
252 | if (boot_cpuid_phys != get_hard_smp_processor_id(0)) { | ||
253 | u32 tmp; | ||
254 | tmp = get_hard_smp_processor_id(0); | ||
255 | set_hard_smp_processor_id(0, boot_cpuid_phys); | ||
256 | set_hard_smp_processor_id(swap_cpuid, tmp); | ||
257 | } | ||
258 | |||
259 | /* | ||
260 | * On pSeries LPAR, we need to know how many cpus | ||
261 | * could possibly be added to this partition. | ||
262 | */ | ||
263 | if (systemcfg->platform == PLATFORM_PSERIES_LPAR && | ||
264 | (dn = of_find_node_by_path("/rtas"))) { | ||
265 | int num_addr_cell, num_size_cell, maxcpus; | ||
266 | unsigned int *ireg; | ||
267 | |||
268 | num_addr_cell = prom_n_addr_cells(dn); | ||
269 | num_size_cell = prom_n_size_cells(dn); | ||
270 | |||
271 | ireg = (unsigned int *) | ||
272 | get_property(dn, "ibm,lrdr-capacity", NULL); | ||
273 | |||
274 | if (!ireg) | ||
275 | goto out; | ||
276 | |||
277 | maxcpus = ireg[num_addr_cell + num_size_cell]; | ||
278 | |||
279 | /* Double maxcpus for processors which have SMT capability */ | ||
280 | if (cpu_has_feature(CPU_FTR_SMT)) | ||
281 | maxcpus *= 2; | ||
282 | |||
283 | if (maxcpus > NR_CPUS) { | ||
284 | printk(KERN_WARNING | ||
285 | "Partition configured for %d cpus, " | ||
286 | "operating system maximum is %d.\n", | ||
287 | maxcpus, NR_CPUS); | ||
288 | maxcpus = NR_CPUS; | ||
289 | } else | ||
290 | printk(KERN_INFO "Partition configured for %d cpus.\n", | ||
291 | maxcpus); | ||
292 | |||
293 | for (cpu = 0; cpu < maxcpus; cpu++) | ||
294 | cpu_set(cpu, cpu_possible_map); | ||
295 | out: | ||
296 | of_node_put(dn); | ||
297 | } | ||
298 | |||
299 | /* | ||
300 | * Do the sibling map; assume only two threads per processor. | ||
301 | */ | ||
302 | for_each_cpu(cpu) { | ||
303 | cpu_set(cpu, cpu_sibling_map[cpu]); | ||
304 | if (cpu_has_feature(CPU_FTR_SMT)) | ||
305 | cpu_set(cpu ^ 0x1, cpu_sibling_map[cpu]); | ||
306 | } | ||
307 | |||
308 | systemcfg->processorCount = num_present_cpus(); | ||
309 | } | ||
310 | #endif /* CONFIG_SMP */ | ||
311 | |||
312 | extern struct machdep_calls pSeries_md; | ||
313 | extern struct machdep_calls pmac_md; | ||
314 | extern struct machdep_calls maple_md; | ||
315 | extern struct machdep_calls bpa_md; | ||
316 | extern struct machdep_calls iseries_md; | ||
317 | |||
318 | /* Ultimately, stuff them in an elf section like initcalls... */ | ||
319 | static struct machdep_calls __initdata *machines[] = { | ||
320 | #ifdef CONFIG_PPC_PSERIES | ||
321 | &pSeries_md, | ||
322 | #endif /* CONFIG_PPC_PSERIES */ | ||
323 | #ifdef CONFIG_PPC_PMAC | ||
324 | &pmac_md, | ||
325 | #endif /* CONFIG_PPC_PMAC */ | ||
326 | #ifdef CONFIG_PPC_MAPLE | ||
327 | &maple_md, | ||
328 | #endif /* CONFIG_PPC_MAPLE */ | ||
329 | #ifdef CONFIG_PPC_BPA | ||
330 | &bpa_md, | ||
331 | #endif | ||
332 | #ifdef CONFIG_PPC_ISERIES | ||
333 | &iseries_md, | ||
334 | #endif | ||
335 | NULL | ||
336 | }; | ||
337 | |||
338 | /* | ||
339 | * Early initialization entry point. This is called by head.S | ||
340 | * with MMU translation disabled. We rely on the "feature" of | ||
341 | * the CPU that ignores the top 2 bits of the address in real | ||
342 | * mode so we can access kernel globals normally provided we | ||
343 | * only toy with things in the RMO region. From here, we do | ||
344 | * some early parsing of the device-tree to setup out LMB | ||
345 | * data structures, and allocate & initialize the hash table | ||
346 | * and segment tables so we can start running with translation | ||
347 | * enabled. | ||
348 | * | ||
349 | * It is this function which will call the probe() callback of | ||
350 | * the various platform types and copy the matching one to the | ||
351 | * global ppc_md structure. Your platform can eventually do | ||
352 | * some very early initializations from the probe() routine, but | ||
353 | * this is not recommended, be very careful as, for example, the | ||
354 | * device-tree is not accessible via normal means at this point. | ||
355 | */ | ||
356 | |||
357 | void __init early_setup(unsigned long dt_ptr) | ||
358 | { | ||
359 | struct paca_struct *lpaca = get_paca(); | ||
360 | static struct machdep_calls **mach; | ||
361 | |||
362 | /* | ||
363 | * Enable early debugging if any specified (see top of | ||
364 | * this file) | ||
365 | */ | ||
366 | EARLY_DEBUG_INIT(); | ||
367 | |||
368 | DBG(" -> early_setup()\n"); | ||
369 | |||
370 | /* | ||
371 | * Fill the default DBG level (do we want to keep | ||
372 | * that old mecanism around forever ?) | ||
373 | */ | ||
374 | ppcdbg_initialize(); | ||
375 | |||
376 | /* | ||
377 | * Do early initializations using the flattened device | ||
378 | * tree, like retreiving the physical memory map or | ||
379 | * calculating/retreiving the hash table size | ||
380 | */ | ||
381 | early_init_devtree(__va(dt_ptr)); | ||
382 | |||
383 | /* | ||
384 | * Iterate all ppc_md structures until we find the proper | ||
385 | * one for the current machine type | ||
386 | */ | ||
387 | DBG("Probing machine type for platform %x...\n", | ||
388 | systemcfg->platform); | ||
389 | |||
390 | for (mach = machines; *mach; mach++) { | ||
391 | if ((*mach)->probe(systemcfg->platform)) | ||
392 | break; | ||
393 | } | ||
394 | /* What can we do if we didn't find ? */ | ||
395 | if (*mach == NULL) { | ||
396 | DBG("No suitable machine found !\n"); | ||
397 | for (;;); | ||
398 | } | ||
399 | ppc_md = **mach; | ||
400 | |||
401 | DBG("Found, Initializing memory management...\n"); | ||
402 | |||
403 | /* | ||
404 | * Initialize stab / SLB management | ||
405 | */ | ||
406 | if (!firmware_has_feature(FW_FEATURE_ISERIES)) | ||
407 | stab_initialize(lpaca->stab_real); | ||
408 | |||
409 | /* | ||
410 | * Initialize the MMU Hash table and create the linear mapping | ||
411 | * of memory | ||
412 | */ | ||
413 | htab_initialize(); | ||
414 | |||
415 | DBG(" <- early_setup()\n"); | ||
416 | } | ||
417 | |||
418 | |||
419 | /* | ||
420 | * Initialize some remaining members of the ppc64_caches and systemcfg structures | ||
421 | * (at least until we get rid of them completely). This is mostly some | ||
422 | * cache informations about the CPU that will be used by cache flush | ||
423 | * routines and/or provided to userland | ||
424 | */ | ||
425 | static void __init initialize_cache_info(void) | ||
426 | { | ||
427 | struct device_node *np; | ||
428 | unsigned long num_cpus = 0; | ||
429 | |||
430 | DBG(" -> initialize_cache_info()\n"); | ||
431 | |||
432 | for (np = NULL; (np = of_find_node_by_type(np, "cpu"));) { | ||
433 | num_cpus += 1; | ||
434 | |||
435 | /* We're assuming *all* of the CPUs have the same | ||
436 | * d-cache and i-cache sizes... -Peter | ||
437 | */ | ||
438 | |||
439 | if ( num_cpus == 1 ) { | ||
440 | u32 *sizep, *lsizep; | ||
441 | u32 size, lsize; | ||
442 | const char *dc, *ic; | ||
443 | |||
444 | /* Then read cache informations */ | ||
445 | if (systemcfg->platform == PLATFORM_POWERMAC) { | ||
446 | dc = "d-cache-block-size"; | ||
447 | ic = "i-cache-block-size"; | ||
448 | } else { | ||
449 | dc = "d-cache-line-size"; | ||
450 | ic = "i-cache-line-size"; | ||
451 | } | ||
452 | |||
453 | size = 0; | ||
454 | lsize = cur_cpu_spec->dcache_bsize; | ||
455 | sizep = (u32 *)get_property(np, "d-cache-size", NULL); | ||
456 | if (sizep != NULL) | ||
457 | size = *sizep; | ||
458 | lsizep = (u32 *) get_property(np, dc, NULL); | ||
459 | if (lsizep != NULL) | ||
460 | lsize = *lsizep; | ||
461 | if (sizep == 0 || lsizep == 0) | ||
462 | DBG("Argh, can't find dcache properties ! " | ||
463 | "sizep: %p, lsizep: %p\n", sizep, lsizep); | ||
464 | |||
465 | systemcfg->dcache_size = ppc64_caches.dsize = size; | ||
466 | systemcfg->dcache_line_size = | ||
467 | ppc64_caches.dline_size = lsize; | ||
468 | ppc64_caches.log_dline_size = __ilog2(lsize); | ||
469 | ppc64_caches.dlines_per_page = PAGE_SIZE / lsize; | ||
470 | |||
471 | size = 0; | ||
472 | lsize = cur_cpu_spec->icache_bsize; | ||
473 | sizep = (u32 *)get_property(np, "i-cache-size", NULL); | ||
474 | if (sizep != NULL) | ||
475 | size = *sizep; | ||
476 | lsizep = (u32 *)get_property(np, ic, NULL); | ||
477 | if (lsizep != NULL) | ||
478 | lsize = *lsizep; | ||
479 | if (sizep == 0 || lsizep == 0) | ||
480 | DBG("Argh, can't find icache properties ! " | ||
481 | "sizep: %p, lsizep: %p\n", sizep, lsizep); | ||
482 | |||
483 | systemcfg->icache_size = ppc64_caches.isize = size; | ||
484 | systemcfg->icache_line_size = | ||
485 | ppc64_caches.iline_size = lsize; | ||
486 | ppc64_caches.log_iline_size = __ilog2(lsize); | ||
487 | ppc64_caches.ilines_per_page = PAGE_SIZE / lsize; | ||
488 | } | ||
489 | } | ||
490 | |||
491 | /* Add an eye catcher and the systemcfg layout version number */ | ||
492 | strcpy(systemcfg->eye_catcher, "SYSTEMCFG:PPC64"); | ||
493 | systemcfg->version.major = SYSTEMCFG_MAJOR; | ||
494 | systemcfg->version.minor = SYSTEMCFG_MINOR; | ||
495 | systemcfg->processor = mfspr(SPRN_PVR); | ||
496 | |||
497 | DBG(" <- initialize_cache_info()\n"); | ||
498 | } | ||
499 | |||
500 | static void __init check_for_initrd(void) | ||
501 | { | ||
502 | #ifdef CONFIG_BLK_DEV_INITRD | ||
503 | u64 *prop; | ||
504 | |||
505 | DBG(" -> check_for_initrd()\n"); | ||
506 | |||
507 | if (of_chosen) { | ||
508 | prop = (u64 *)get_property(of_chosen, | ||
509 | "linux,initrd-start", NULL); | ||
510 | if (prop != NULL) { | ||
511 | initrd_start = (unsigned long)__va(*prop); | ||
512 | prop = (u64 *)get_property(of_chosen, | ||
513 | "linux,initrd-end", NULL); | ||
514 | if (prop != NULL) { | ||
515 | initrd_end = (unsigned long)__va(*prop); | ||
516 | initrd_below_start_ok = 1; | ||
517 | } else | ||
518 | initrd_start = 0; | ||
519 | } | ||
520 | } | ||
521 | |||
522 | /* If we were passed an initrd, set the ROOT_DEV properly if the values | ||
523 | * look sensible. If not, clear initrd reference. | ||
524 | */ | ||
525 | if (initrd_start >= KERNELBASE && initrd_end >= KERNELBASE && | ||
526 | initrd_end > initrd_start) | ||
527 | ROOT_DEV = Root_RAM0; | ||
528 | else | ||
529 | initrd_start = initrd_end = 0; | ||
530 | |||
531 | if (initrd_start) | ||
532 | printk("Found initrd at 0x%lx:0x%lx\n", initrd_start, initrd_end); | ||
533 | |||
534 | DBG(" <- check_for_initrd()\n"); | ||
535 | #endif /* CONFIG_BLK_DEV_INITRD */ | ||
536 | } | ||
537 | |||
538 | /* | ||
539 | * Do some initial setup of the system. The parameters are those which | ||
540 | * were passed in from the bootloader. | ||
541 | */ | ||
542 | void __init setup_system(void) | ||
543 | { | ||
544 | DBG(" -> setup_system()\n"); | ||
545 | |||
546 | /* | ||
547 | * Unflatten the device-tree passed by prom_init or kexec | ||
548 | */ | ||
549 | unflatten_device_tree(); | ||
550 | |||
551 | /* | ||
552 | * Fill the ppc64_caches & systemcfg structures with informations | ||
553 | * retreived from the device-tree. Need to be called before | ||
554 | * finish_device_tree() since the later requires some of the | ||
555 | * informations filled up here to properly parse the interrupt | ||
556 | * tree. | ||
557 | * It also sets up the cache line sizes which allows to call | ||
558 | * routines like flush_icache_range (used by the hash init | ||
559 | * later on). | ||
560 | */ | ||
561 | initialize_cache_info(); | ||
562 | |||
563 | #ifdef CONFIG_PPC_RTAS | ||
564 | /* | ||
565 | * Initialize RTAS if available | ||
566 | */ | ||
567 | rtas_initialize(); | ||
568 | #endif /* CONFIG_PPC_RTAS */ | ||
569 | |||
570 | /* | ||
571 | * Check if we have an initrd provided via the device-tree | ||
572 | */ | ||
573 | check_for_initrd(); | ||
574 | |||
575 | /* | ||
576 | * Do some platform specific early initializations, that includes | ||
577 | * setting up the hash table pointers. It also sets up some interrupt-mapping | ||
578 | * related options that will be used by finish_device_tree() | ||
579 | */ | ||
580 | ppc_md.init_early(); | ||
581 | |||
582 | /* | ||
583 | * "Finish" the device-tree, that is do the actual parsing of | ||
584 | * some of the properties like the interrupt map | ||
585 | */ | ||
586 | finish_device_tree(); | ||
587 | |||
588 | #ifdef CONFIG_BOOTX_TEXT | ||
589 | init_boot_display(); | ||
590 | #endif | ||
591 | |||
592 | /* | ||
593 | * Initialize xmon | ||
594 | */ | ||
595 | #ifdef CONFIG_XMON_DEFAULT | ||
596 | xmon_init(1); | ||
597 | #endif | ||
598 | /* | ||
599 | * Register early console | ||
600 | */ | ||
601 | register_early_udbg_console(); | ||
602 | |||
603 | /* Save unparsed command line copy for /proc/cmdline */ | ||
604 | strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE); | ||
605 | |||
606 | parse_early_param(); | ||
607 | |||
608 | #ifdef CONFIG_SMP | ||
609 | /* | ||
610 | * iSeries has already initialized the cpu maps at this point. | ||
611 | */ | ||
612 | setup_cpu_maps(); | ||
613 | |||
614 | /* Release secondary cpus out of their spinloops at 0x60 now that | ||
615 | * we can map physical -> logical CPU ids | ||
616 | */ | ||
617 | smp_release_cpus(); | ||
618 | #endif | ||
619 | |||
620 | printk("Starting Linux PPC64 %s\n", system_utsname.version); | ||
621 | |||
622 | printk("-----------------------------------------------------\n"); | ||
623 | printk("ppc64_pft_size = 0x%lx\n", ppc64_pft_size); | ||
624 | printk("ppc64_debug_switch = 0x%lx\n", ppc64_debug_switch); | ||
625 | printk("ppc64_interrupt_controller = 0x%ld\n", ppc64_interrupt_controller); | ||
626 | printk("systemcfg = 0x%p\n", systemcfg); | ||
627 | printk("systemcfg->platform = 0x%x\n", systemcfg->platform); | ||
628 | printk("systemcfg->processorCount = 0x%lx\n", systemcfg->processorCount); | ||
629 | printk("systemcfg->physicalMemorySize = 0x%lx\n", systemcfg->physicalMemorySize); | ||
630 | printk("ppc64_caches.dcache_line_size = 0x%x\n", | ||
631 | ppc64_caches.dline_size); | ||
632 | printk("ppc64_caches.icache_line_size = 0x%x\n", | ||
633 | ppc64_caches.iline_size); | ||
634 | printk("htab_address = 0x%p\n", htab_address); | ||
635 | printk("htab_hash_mask = 0x%lx\n", htab_hash_mask); | ||
636 | printk("-----------------------------------------------------\n"); | ||
637 | |||
638 | mm_init_ppc64(); | ||
639 | |||
640 | DBG(" <- setup_system()\n"); | ||
641 | } | ||
642 | |||
643 | /* also used by kexec */ | ||
644 | void machine_shutdown(void) | ||
645 | { | ||
646 | if (ppc_md.nvram_sync) | ||
647 | ppc_md.nvram_sync(); | ||
648 | } | ||
649 | |||
650 | void machine_restart(char *cmd) | ||
651 | { | ||
652 | machine_shutdown(); | ||
653 | ppc_md.restart(cmd); | ||
654 | #ifdef CONFIG_SMP | ||
655 | smp_send_stop(); | ||
656 | #endif | ||
657 | printk(KERN_EMERG "System Halted, OK to turn off power\n"); | ||
658 | local_irq_disable(); | ||
659 | while (1) ; | ||
660 | } | ||
661 | |||
662 | void machine_power_off(void) | ||
663 | { | ||
664 | machine_shutdown(); | ||
665 | ppc_md.power_off(); | ||
666 | #ifdef CONFIG_SMP | ||
667 | smp_send_stop(); | ||
668 | #endif | ||
669 | printk(KERN_EMERG "System Halted, OK to turn off power\n"); | ||
670 | local_irq_disable(); | ||
671 | while (1) ; | ||
672 | } | ||
673 | /* Used by the G5 thermal driver */ | ||
674 | EXPORT_SYMBOL_GPL(machine_power_off); | ||
675 | |||
676 | void machine_halt(void) | ||
677 | { | ||
678 | machine_shutdown(); | ||
679 | ppc_md.halt(); | ||
680 | #ifdef CONFIG_SMP | ||
681 | smp_send_stop(); | ||
682 | #endif | ||
683 | printk(KERN_EMERG "System Halted, OK to turn off power\n"); | ||
684 | local_irq_disable(); | ||
685 | while (1) ; | ||
686 | } | ||
687 | |||
688 | static int ppc64_panic_event(struct notifier_block *this, | ||
689 | unsigned long event, void *ptr) | ||
690 | { | ||
691 | ppc_md.panic((char *)ptr); /* May not return */ | ||
692 | return NOTIFY_DONE; | ||
693 | } | ||
694 | |||
695 | |||
696 | #ifdef CONFIG_SMP | ||
697 | DEFINE_PER_CPU(unsigned int, pvr); | ||
698 | #endif | ||
699 | |||
700 | static int show_cpuinfo(struct seq_file *m, void *v) | ||
701 | { | ||
702 | unsigned long cpu_id = (unsigned long)v - 1; | ||
703 | unsigned int pvr; | ||
704 | unsigned short maj; | ||
705 | unsigned short min; | ||
706 | |||
707 | if (cpu_id == NR_CPUS) { | ||
708 | seq_printf(m, "timebase\t: %lu\n", ppc_tb_freq); | ||
709 | |||
710 | if (ppc_md.show_cpuinfo != NULL) | ||
711 | ppc_md.show_cpuinfo(m); | ||
712 | |||
713 | return 0; | ||
714 | } | ||
715 | |||
716 | /* We only show online cpus: disable preempt (overzealous, I | ||
717 | * knew) to prevent cpu going down. */ | ||
718 | preempt_disable(); | ||
719 | if (!cpu_online(cpu_id)) { | ||
720 | preempt_enable(); | ||
721 | return 0; | ||
722 | } | ||
723 | |||
724 | #ifdef CONFIG_SMP | ||
725 | pvr = per_cpu(pvr, cpu_id); | ||
726 | #else | ||
727 | pvr = mfspr(SPRN_PVR); | ||
728 | #endif | ||
729 | maj = (pvr >> 8) & 0xFF; | ||
730 | min = pvr & 0xFF; | ||
731 | |||
732 | seq_printf(m, "processor\t: %lu\n", cpu_id); | ||
733 | seq_printf(m, "cpu\t\t: "); | ||
734 | |||
735 | if (cur_cpu_spec->pvr_mask) | ||
736 | seq_printf(m, "%s", cur_cpu_spec->cpu_name); | ||
737 | else | ||
738 | seq_printf(m, "unknown (%08x)", pvr); | ||
739 | |||
740 | #ifdef CONFIG_ALTIVEC | ||
741 | if (cpu_has_feature(CPU_FTR_ALTIVEC)) | ||
742 | seq_printf(m, ", altivec supported"); | ||
743 | #endif /* CONFIG_ALTIVEC */ | ||
744 | |||
745 | seq_printf(m, "\n"); | ||
746 | |||
747 | /* | ||
748 | * Assume here that all clock rates are the same in a | ||
749 | * smp system. -- Cort | ||
750 | */ | ||
751 | seq_printf(m, "clock\t\t: %lu.%06luMHz\n", ppc_proc_freq / 1000000, | ||
752 | ppc_proc_freq % 1000000); | ||
753 | |||
754 | seq_printf(m, "revision\t: %hd.%hd\n\n", maj, min); | ||
755 | |||
756 | preempt_enable(); | ||
757 | return 0; | ||
758 | } | ||
759 | |||
760 | static void *c_start(struct seq_file *m, loff_t *pos) | ||
761 | { | ||
762 | return *pos <= NR_CPUS ? (void *)((*pos)+1) : NULL; | ||
763 | } | ||
764 | static void *c_next(struct seq_file *m, void *v, loff_t *pos) | ||
765 | { | ||
766 | ++*pos; | ||
767 | return c_start(m, pos); | ||
768 | } | ||
769 | static void c_stop(struct seq_file *m, void *v) | ||
770 | { | ||
771 | } | ||
772 | struct seq_operations cpuinfo_op = { | ||
773 | .start =c_start, | ||
774 | .next = c_next, | ||
775 | .stop = c_stop, | ||
776 | .show = show_cpuinfo, | ||
777 | }; | ||
778 | |||
779 | /* | ||
780 | * These three variables are used to save values passed to us by prom_init() | ||
781 | * via the device tree. The TCE variables are needed because with a memory_limit | ||
782 | * in force we may need to explicitly map the TCE are at the top of RAM. | ||
783 | */ | ||
784 | unsigned long memory_limit; | ||
785 | unsigned long tce_alloc_start; | ||
786 | unsigned long tce_alloc_end; | ||
787 | |||
788 | #ifdef CONFIG_PPC_ISERIES | ||
789 | /* | ||
790 | * On iSeries we just parse the mem=X option from the command line. | ||
791 | * On pSeries it's a bit more complicated, see prom_init_mem() | ||
792 | */ | ||
793 | static int __init early_parsemem(char *p) | ||
794 | { | ||
795 | if (!p) | ||
796 | return 0; | ||
797 | |||
798 | memory_limit = ALIGN(memparse(p, &p), PAGE_SIZE); | ||
799 | |||
800 | return 0; | ||
801 | } | ||
802 | early_param("mem", early_parsemem); | ||
803 | #endif /* CONFIG_PPC_ISERIES */ | ||
804 | |||
805 | #ifdef CONFIG_PPC_MULTIPLATFORM | ||
806 | static int __init set_preferred_console(void) | ||
807 | { | ||
808 | struct device_node *prom_stdout = NULL; | ||
809 | char *name; | ||
810 | u32 *spd; | ||
811 | int offset = 0; | ||
812 | |||
813 | DBG(" -> set_preferred_console()\n"); | ||
814 | |||
815 | /* The user has requested a console so this is already set up. */ | ||
816 | if (strstr(saved_command_line, "console=")) { | ||
817 | DBG(" console was specified !\n"); | ||
818 | return -EBUSY; | ||
819 | } | ||
820 | |||
821 | if (!of_chosen) { | ||
822 | DBG(" of_chosen is NULL !\n"); | ||
823 | return -ENODEV; | ||
824 | } | ||
825 | /* We are getting a weird phandle from OF ... */ | ||
826 | /* ... So use the full path instead */ | ||
827 | name = (char *)get_property(of_chosen, "linux,stdout-path", NULL); | ||
828 | if (name == NULL) { | ||
829 | DBG(" no linux,stdout-path !\n"); | ||
830 | return -ENODEV; | ||
831 | } | ||
832 | prom_stdout = of_find_node_by_path(name); | ||
833 | if (!prom_stdout) { | ||
834 | DBG(" can't find stdout package %s !\n", name); | ||
835 | return -ENODEV; | ||
836 | } | ||
837 | DBG("stdout is %s\n", prom_stdout->full_name); | ||
838 | |||
839 | name = (char *)get_property(prom_stdout, "name", NULL); | ||
840 | if (!name) { | ||
841 | DBG(" stdout package has no name !\n"); | ||
842 | goto not_found; | ||
843 | } | ||
844 | spd = (u32 *)get_property(prom_stdout, "current-speed", NULL); | ||
845 | |||
846 | if (0) | ||
847 | ; | ||
848 | #ifdef CONFIG_SERIAL_8250_CONSOLE | ||
849 | else if (strcmp(name, "serial") == 0) { | ||
850 | int i; | ||
851 | u32 *reg = (u32 *)get_property(prom_stdout, "reg", &i); | ||
852 | if (i > 8) { | ||
853 | switch (reg[1]) { | ||
854 | case 0x3f8: | ||
855 | offset = 0; | ||
856 | break; | ||
857 | case 0x2f8: | ||
858 | offset = 1; | ||
859 | break; | ||
860 | case 0x898: | ||
861 | offset = 2; | ||
862 | break; | ||
863 | case 0x890: | ||
864 | offset = 3; | ||
865 | break; | ||
866 | default: | ||
867 | /* We dont recognise the serial port */ | ||
868 | goto not_found; | ||
869 | } | ||
870 | } | ||
871 | } | ||
872 | #endif /* CONFIG_SERIAL_8250_CONSOLE */ | ||
873 | #ifdef CONFIG_PPC_PSERIES | ||
874 | else if (strcmp(name, "vty") == 0) { | ||
875 | u32 *reg = (u32 *)get_property(prom_stdout, "reg", NULL); | ||
876 | char *compat = (char *)get_property(prom_stdout, "compatible", NULL); | ||
877 | |||
878 | if (reg && compat && (strcmp(compat, "hvterm-protocol") == 0)) { | ||
879 | /* Host Virtual Serial Interface */ | ||
880 | int offset; | ||
881 | switch (reg[0]) { | ||
882 | case 0x30000000: | ||
883 | offset = 0; | ||
884 | break; | ||
885 | case 0x30000001: | ||
886 | offset = 1; | ||
887 | break; | ||
888 | default: | ||
889 | goto not_found; | ||
890 | } | ||
891 | of_node_put(prom_stdout); | ||
892 | DBG("Found hvsi console at offset %d\n", offset); | ||
893 | return add_preferred_console("hvsi", offset, NULL); | ||
894 | } else { | ||
895 | /* pSeries LPAR virtual console */ | ||
896 | of_node_put(prom_stdout); | ||
897 | DBG("Found hvc console\n"); | ||
898 | return add_preferred_console("hvc", 0, NULL); | ||
899 | } | ||
900 | } | ||
901 | #endif /* CONFIG_PPC_PSERIES */ | ||
902 | #ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE | ||
903 | else if (strcmp(name, "ch-a") == 0) | ||
904 | offset = 0; | ||
905 | else if (strcmp(name, "ch-b") == 0) | ||
906 | offset = 1; | ||
907 | #endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */ | ||
908 | else | ||
909 | goto not_found; | ||
910 | of_node_put(prom_stdout); | ||
911 | |||
912 | DBG("Found serial console at ttyS%d\n", offset); | ||
913 | |||
914 | if (spd) { | ||
915 | static char __initdata opt[16]; | ||
916 | sprintf(opt, "%d", *spd); | ||
917 | return add_preferred_console("ttyS", offset, opt); | ||
918 | } else | ||
919 | return add_preferred_console("ttyS", offset, NULL); | ||
920 | |||
921 | not_found: | ||
922 | DBG("No preferred console found !\n"); | ||
923 | of_node_put(prom_stdout); | ||
924 | return -ENODEV; | ||
925 | } | ||
926 | console_initcall(set_preferred_console); | ||
927 | #endif /* CONFIG_PPC_MULTIPLATFORM */ | ||
928 | |||
929 | #ifdef CONFIG_IRQSTACKS | ||
930 | static void __init irqstack_early_init(void) | ||
931 | { | ||
932 | unsigned int i; | ||
933 | |||
934 | /* | ||
935 | * interrupt stacks must be under 256MB, we cannot afford to take | ||
936 | * SLB misses on them. | ||
937 | */ | ||
938 | for_each_cpu(i) { | ||
939 | softirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE, | ||
940 | THREAD_SIZE, 0x10000000)); | ||
941 | hardirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE, | ||
942 | THREAD_SIZE, 0x10000000)); | ||
943 | } | ||
944 | } | ||
945 | #else | ||
946 | #define irqstack_early_init() | ||
947 | #endif | ||
948 | |||
949 | /* | ||
950 | * Stack space used when we detect a bad kernel stack pointer, and | ||
951 | * early in SMP boots before relocation is enabled. | ||
952 | */ | ||
953 | static void __init emergency_stack_init(void) | ||
954 | { | ||
955 | unsigned long limit; | ||
956 | unsigned int i; | ||
957 | |||
958 | /* | ||
959 | * Emergency stacks must be under 256MB, we cannot afford to take | ||
960 | * SLB misses on them. The ABI also requires them to be 128-byte | ||
961 | * aligned. | ||
962 | * | ||
963 | * Since we use these as temporary stacks during secondary CPU | ||
964 | * bringup, we need to get at them in real mode. This means they | ||
965 | * must also be within the RMO region. | ||
966 | */ | ||
967 | limit = min(0x10000000UL, lmb.rmo_size); | ||
968 | |||
969 | for_each_cpu(i) | ||
970 | paca[i].emergency_sp = __va(lmb_alloc_base(PAGE_SIZE, 128, | ||
971 | limit)) + PAGE_SIZE; | ||
972 | } | ||
973 | |||
974 | /* | ||
975 | * Called from setup_arch to initialize the bitmap of available | ||
976 | * syscalls in the systemcfg page | ||
977 | */ | ||
978 | void __init setup_syscall_map(void) | ||
979 | { | ||
980 | unsigned int i, count64 = 0, count32 = 0; | ||
981 | extern unsigned long *sys_call_table; | ||
982 | extern unsigned long *sys_call_table32; | ||
983 | extern unsigned long sys_ni_syscall; | ||
984 | |||
985 | |||
986 | for (i = 0; i < __NR_syscalls; i++) { | ||
987 | if (sys_call_table[i] == sys_ni_syscall) | ||
988 | continue; | ||
989 | count64++; | ||
990 | systemcfg->syscall_map_64[i >> 5] |= 0x80000000UL >> (i & 0x1f); | ||
991 | } | ||
992 | for (i = 0; i < __NR_syscalls; i++) { | ||
993 | if (sys_call_table32[i] == sys_ni_syscall) | ||
994 | continue; | ||
995 | count32++; | ||
996 | systemcfg->syscall_map_32[i >> 5] |= 0x80000000UL >> (i & 0x1f); | ||
997 | } | ||
998 | printk(KERN_INFO "Syscall map setup, %d 32 bits and %d 64 bits syscalls\n", | ||
999 | count32, count64); | ||
1000 | } | ||
1001 | |||
1002 | /* | ||
1003 | * Called into from start_kernel, after lock_kernel has been called. | ||
1004 | * Initializes bootmem, which is unsed to manage page allocation until | ||
1005 | * mem_init is called. | ||
1006 | */ | ||
1007 | void __init setup_arch(char **cmdline_p) | ||
1008 | { | ||
1009 | extern void do_init_bootmem(void); | ||
1010 | |||
1011 | ppc64_boot_msg(0x12, "Setup Arch"); | ||
1012 | |||
1013 | *cmdline_p = cmd_line; | ||
1014 | |||
1015 | /* | ||
1016 | * Set cache line size based on type of cpu as a default. | ||
1017 | * Systems with OF can look in the properties on the cpu node(s) | ||
1018 | * for a possibly more accurate value. | ||
1019 | */ | ||
1020 | dcache_bsize = ppc64_caches.dline_size; | ||
1021 | icache_bsize = ppc64_caches.iline_size; | ||
1022 | |||
1023 | /* reboot on panic */ | ||
1024 | panic_timeout = 180; | ||
1025 | |||
1026 | if (ppc_md.panic) | ||
1027 | notifier_chain_register(&panic_notifier_list, &ppc64_panic_block); | ||
1028 | |||
1029 | init_mm.start_code = PAGE_OFFSET; | ||
1030 | init_mm.end_code = (unsigned long) _etext; | ||
1031 | init_mm.end_data = (unsigned long) _edata; | ||
1032 | init_mm.brk = klimit; | ||
1033 | |||
1034 | irqstack_early_init(); | ||
1035 | emergency_stack_init(); | ||
1036 | |||
1037 | stabs_alloc(); | ||
1038 | |||
1039 | /* set up the bootmem stuff with available memory */ | ||
1040 | do_init_bootmem(); | ||
1041 | sparse_init(); | ||
1042 | |||
1043 | /* initialize the syscall map in systemcfg */ | ||
1044 | setup_syscall_map(); | ||
1045 | |||
1046 | #ifdef CONFIG_DUMMY_CONSOLE | ||
1047 | conswitchp = &dummy_con; | ||
1048 | #endif | ||
1049 | |||
1050 | ppc_md.setup_arch(); | ||
1051 | |||
1052 | /* Use the default idle loop if the platform hasn't provided one. */ | ||
1053 | if (NULL == ppc_md.idle_loop) { | ||
1054 | ppc_md.idle_loop = default_idle; | ||
1055 | printk(KERN_INFO "Using default idle loop\n"); | ||
1056 | } | ||
1057 | |||
1058 | paging_init(); | ||
1059 | ppc64_boot_msg(0x15, "Setup Done"); | ||
1060 | } | ||
1061 | |||
1062 | |||
1063 | /* ToDo: do something useful if ppc_md is not yet setup. */ | ||
1064 | #define PPC64_LINUX_FUNCTION 0x0f000000 | ||
1065 | #define PPC64_IPL_MESSAGE 0xc0000000 | ||
1066 | #define PPC64_TERM_MESSAGE 0xb0000000 | ||
1067 | |||
1068 | static void ppc64_do_msg(unsigned int src, const char *msg) | ||
1069 | { | ||
1070 | if (ppc_md.progress) { | ||
1071 | char buf[128]; | ||
1072 | |||
1073 | sprintf(buf, "%08X\n", src); | ||
1074 | ppc_md.progress(buf, 0); | ||
1075 | snprintf(buf, 128, "%s", msg); | ||
1076 | ppc_md.progress(buf, 0); | ||
1077 | } | ||
1078 | } | ||
1079 | |||
1080 | /* Print a boot progress message. */ | ||
1081 | void ppc64_boot_msg(unsigned int src, const char *msg) | ||
1082 | { | ||
1083 | ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_IPL_MESSAGE|src, msg); | ||
1084 | printk("[boot]%04x %s\n", src, msg); | ||
1085 | } | ||
1086 | |||
1087 | /* Print a termination message (print only -- does not stop the kernel) */ | ||
1088 | void ppc64_terminate_msg(unsigned int src, const char *msg) | ||
1089 | { | ||
1090 | ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_TERM_MESSAGE|src, msg); | ||
1091 | printk("[terminate]%04x %s\n", src, msg); | ||
1092 | } | ||
1093 | |||
1094 | #ifndef CONFIG_PPC_ISERIES | ||
1095 | /* | ||
1096 | * This function can be used by platforms to "find" legacy serial ports. | ||
1097 | * It works for "serial" nodes under an "isa" node, and will try to | ||
1098 | * respect the "ibm,aix-loc" property if any. It works with up to 8 | ||
1099 | * ports. | ||
1100 | */ | ||
1101 | |||
1102 | #define MAX_LEGACY_SERIAL_PORTS 8 | ||
1103 | static struct plat_serial8250_port serial_ports[MAX_LEGACY_SERIAL_PORTS+1]; | ||
1104 | static unsigned int old_serial_count; | ||
1105 | |||
1106 | void __init generic_find_legacy_serial_ports(u64 *physport, | ||
1107 | unsigned int *default_speed) | ||
1108 | { | ||
1109 | struct device_node *np; | ||
1110 | u32 *sizeprop; | ||
1111 | |||
1112 | struct isa_reg_property { | ||
1113 | u32 space; | ||
1114 | u32 address; | ||
1115 | u32 size; | ||
1116 | }; | ||
1117 | struct pci_reg_property { | ||
1118 | struct pci_address addr; | ||
1119 | u32 size_hi; | ||
1120 | u32 size_lo; | ||
1121 | }; | ||
1122 | |||
1123 | DBG(" -> generic_find_legacy_serial_port()\n"); | ||
1124 | |||
1125 | *physport = 0; | ||
1126 | if (default_speed) | ||
1127 | *default_speed = 0; | ||
1128 | |||
1129 | np = of_find_node_by_path("/"); | ||
1130 | if (!np) | ||
1131 | return; | ||
1132 | |||
1133 | /* First fill our array */ | ||
1134 | for (np = NULL; (np = of_find_node_by_type(np, "serial"));) { | ||
1135 | struct device_node *isa, *pci; | ||
1136 | struct isa_reg_property *reg; | ||
1137 | unsigned long phys_size, addr_size, io_base; | ||
1138 | u32 *rangesp; | ||
1139 | u32 *interrupts, *clk, *spd; | ||
1140 | char *typep; | ||
1141 | int index, rlen, rentsize; | ||
1142 | |||
1143 | /* Ok, first check if it's under an "isa" parent */ | ||
1144 | isa = of_get_parent(np); | ||
1145 | if (!isa || strcmp(isa->name, "isa")) { | ||
1146 | DBG("%s: no isa parent found\n", np->full_name); | ||
1147 | continue; | ||
1148 | } | ||
1149 | |||
1150 | /* Now look for an "ibm,aix-loc" property that gives us ordering | ||
1151 | * if any... | ||
1152 | */ | ||
1153 | typep = (char *)get_property(np, "ibm,aix-loc", NULL); | ||
1154 | |||
1155 | /* Get the ISA port number */ | ||
1156 | reg = (struct isa_reg_property *)get_property(np, "reg", NULL); | ||
1157 | if (reg == NULL) | ||
1158 | goto next_port; | ||
1159 | /* We assume the interrupt number isn't translated ... */ | ||
1160 | interrupts = (u32 *)get_property(np, "interrupts", NULL); | ||
1161 | /* get clock freq. if present */ | ||
1162 | clk = (u32 *)get_property(np, "clock-frequency", NULL); | ||
1163 | /* get default speed if present */ | ||
1164 | spd = (u32 *)get_property(np, "current-speed", NULL); | ||
1165 | /* Default to locate at end of array */ | ||
1166 | index = old_serial_count; /* end of the array by default */ | ||
1167 | |||
1168 | /* If we have a location index, then use it */ | ||
1169 | if (typep && *typep == 'S') { | ||
1170 | index = simple_strtol(typep+1, NULL, 0) - 1; | ||
1171 | /* if index is out of range, use end of array instead */ | ||
1172 | if (index >= MAX_LEGACY_SERIAL_PORTS) | ||
1173 | index = old_serial_count; | ||
1174 | /* if our index is still out of range, that mean that | ||
1175 | * array is full, we could scan for a free slot but that | ||
1176 | * make little sense to bother, just skip the port | ||
1177 | */ | ||
1178 | if (index >= MAX_LEGACY_SERIAL_PORTS) | ||
1179 | goto next_port; | ||
1180 | if (index >= old_serial_count) | ||
1181 | old_serial_count = index + 1; | ||
1182 | /* Check if there is a port who already claimed our slot */ | ||
1183 | if (serial_ports[index].iobase != 0) { | ||
1184 | /* if we still have some room, move it, else override */ | ||
1185 | if (old_serial_count < MAX_LEGACY_SERIAL_PORTS) { | ||
1186 | DBG("Moved legacy port %d -> %d\n", index, | ||
1187 | old_serial_count); | ||
1188 | serial_ports[old_serial_count++] = | ||
1189 | serial_ports[index]; | ||
1190 | } else { | ||
1191 | DBG("Replacing legacy port %d\n", index); | ||
1192 | } | ||
1193 | } | ||
1194 | } | ||
1195 | if (index >= MAX_LEGACY_SERIAL_PORTS) | ||
1196 | goto next_port; | ||
1197 | if (index >= old_serial_count) | ||
1198 | old_serial_count = index + 1; | ||
1199 | |||
1200 | /* Now fill the entry */ | ||
1201 | memset(&serial_ports[index], 0, sizeof(struct plat_serial8250_port)); | ||
1202 | serial_ports[index].uartclk = clk ? *clk : BASE_BAUD * 16; | ||
1203 | serial_ports[index].iobase = reg->address; | ||
1204 | serial_ports[index].irq = interrupts ? interrupts[0] : 0; | ||
1205 | serial_ports[index].flags = ASYNC_BOOT_AUTOCONF; | ||
1206 | |||
1207 | DBG("Added legacy port, index: %d, port: %x, irq: %d, clk: %d\n", | ||
1208 | index, | ||
1209 | serial_ports[index].iobase, | ||
1210 | serial_ports[index].irq, | ||
1211 | serial_ports[index].uartclk); | ||
1212 | |||
1213 | /* Get phys address of IO reg for port 1 */ | ||
1214 | if (index != 0) | ||
1215 | goto next_port; | ||
1216 | |||
1217 | pci = of_get_parent(isa); | ||
1218 | if (!pci) { | ||
1219 | DBG("%s: no pci parent found\n", np->full_name); | ||
1220 | goto next_port; | ||
1221 | } | ||
1222 | |||
1223 | rangesp = (u32 *)get_property(pci, "ranges", &rlen); | ||
1224 | if (rangesp == NULL) { | ||
1225 | of_node_put(pci); | ||
1226 | goto next_port; | ||
1227 | } | ||
1228 | rlen /= 4; | ||
1229 | |||
1230 | /* we need the #size-cells of the PCI bridge node itself */ | ||
1231 | phys_size = 1; | ||
1232 | sizeprop = (u32 *)get_property(pci, "#size-cells", NULL); | ||
1233 | if (sizeprop != NULL) | ||
1234 | phys_size = *sizeprop; | ||
1235 | /* we need the parent #addr-cells */ | ||
1236 | addr_size = prom_n_addr_cells(pci); | ||
1237 | rentsize = 3 + addr_size + phys_size; | ||
1238 | io_base = 0; | ||
1239 | for (;rlen >= rentsize; rlen -= rentsize,rangesp += rentsize) { | ||
1240 | if (((rangesp[0] >> 24) & 0x3) != 1) | ||
1241 | continue; /* not IO space */ | ||
1242 | io_base = rangesp[3]; | ||
1243 | if (addr_size == 2) | ||
1244 | io_base = (io_base << 32) | rangesp[4]; | ||
1245 | } | ||
1246 | if (io_base != 0) { | ||
1247 | *physport = io_base + reg->address; | ||
1248 | if (default_speed && spd) | ||
1249 | *default_speed = *spd; | ||
1250 | } | ||
1251 | of_node_put(pci); | ||
1252 | next_port: | ||
1253 | of_node_put(isa); | ||
1254 | } | ||
1255 | |||
1256 | DBG(" <- generic_find_legacy_serial_port()\n"); | ||
1257 | } | ||
1258 | |||
1259 | static struct platform_device serial_device = { | ||
1260 | .name = "serial8250", | ||
1261 | .id = PLAT8250_DEV_PLATFORM, | ||
1262 | .dev = { | ||
1263 | .platform_data = serial_ports, | ||
1264 | }, | ||
1265 | }; | ||
1266 | |||
1267 | static int __init serial_dev_init(void) | ||
1268 | { | ||
1269 | return platform_device_register(&serial_device); | ||
1270 | } | ||
1271 | arch_initcall(serial_dev_init); | ||
1272 | |||
1273 | #endif /* CONFIG_PPC_ISERIES */ | ||
1274 | |||
1275 | int check_legacy_ioport(unsigned long base_port) | ||
1276 | { | ||
1277 | if (ppc_md.check_legacy_ioport == NULL) | ||
1278 | return 0; | ||
1279 | return ppc_md.check_legacy_ioport(base_port); | ||
1280 | } | ||
1281 | EXPORT_SYMBOL(check_legacy_ioport); | ||
1282 | |||
1283 | #ifdef CONFIG_XMON | ||
1284 | static int __init early_xmon(char *p) | ||
1285 | { | ||
1286 | /* ensure xmon is enabled */ | ||
1287 | if (p) { | ||
1288 | if (strncmp(p, "on", 2) == 0) | ||
1289 | xmon_init(1); | ||
1290 | if (strncmp(p, "off", 3) == 0) | ||
1291 | xmon_init(0); | ||
1292 | if (strncmp(p, "early", 5) != 0) | ||
1293 | return 0; | ||
1294 | } | ||
1295 | xmon_init(1); | ||
1296 | debugger(NULL); | ||
1297 | |||
1298 | return 0; | ||
1299 | } | ||
1300 | early_param("xmon", early_xmon); | ||
1301 | #endif | ||
1302 | |||
1303 | void cpu_die(void) | ||
1304 | { | ||
1305 | if (ppc_md.cpu_die) | ||
1306 | ppc_md.cpu_die(); | ||
1307 | } | ||