Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 1 | /* |
| 2 | * Common boot and setup code for both 32-bit and 64-bit. |
| 3 | * Extracted from arch/powerpc/kernel/setup_64.c. |
| 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 | */ |
Benjamin Herrenschmidt | e822250 | 2006-03-28 23:15:54 +1100 | [diff] [blame] | 12 | |
| 13 | #undef DEBUG |
| 14 | |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 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> |
Michael Neuling | e5c6c8e | 2006-03-14 00:11:50 -0500 | [diff] [blame] | 23 | #include <linux/platform_device.h> |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 24 | #include <linux/seq_file.h> |
| 25 | #include <linux/ioport.h> |
| 26 | #include <linux/console.h> |
Jon Smirl | 894673e | 2006-07-10 04:44:13 -0700 | [diff] [blame] | 27 | #include <linux/screen_info.h> |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 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> |
Michael Ellerman | 94a3807 | 2007-06-20 10:54:19 +1000 | [diff] [blame] | 34 | #include <linux/debugfs.h> |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 35 | #include <linux/percpu.h> |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 36 | #include <linux/memblock.h> |
Kumar Gala | d746286 | 2009-03-19 03:40:51 +0000 | [diff] [blame] | 37 | #include <linux/of_platform.h> |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 38 | #include <asm/io.h> |
Michael Ellerman | 1426d5a | 2010-01-28 13:23:22 +0000 | [diff] [blame] | 39 | #include <asm/paca.h> |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 40 | #include <asm/prom.h> |
| 41 | #include <asm/processor.h> |
Benjamin Herrenschmidt | a7f290d | 2005-11-11 21:15:21 +1100 | [diff] [blame] | 42 | #include <asm/vdso_datapage.h> |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 43 | #include <asm/pgtable.h> |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 44 | #include <asm/smp.h> |
| 45 | #include <asm/elf.h> |
| 46 | #include <asm/machdep.h> |
| 47 | #include <asm/time.h> |
| 48 | #include <asm/cputable.h> |
| 49 | #include <asm/sections.h> |
Benjamin Herrenschmidt | e822250 | 2006-03-28 23:15:54 +1100 | [diff] [blame] | 50 | #include <asm/firmware.h> |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 51 | #include <asm/btext.h> |
| 52 | #include <asm/nvram.h> |
| 53 | #include <asm/setup.h> |
| 54 | #include <asm/system.h> |
| 55 | #include <asm/rtas.h> |
| 56 | #include <asm/iommu.h> |
| 57 | #include <asm/serial.h> |
| 58 | #include <asm/cache.h> |
| 59 | #include <asm/page.h> |
| 60 | #include <asm/mmu.h> |
Paul Mackerras | fca5dcd | 2005-11-08 22:55:08 +1100 | [diff] [blame] | 61 | #include <asm/xmon.h> |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 62 | #include <asm/cputhreads.h> |
Becky Bruce | f465df8 | 2008-10-15 08:25:28 +0000 | [diff] [blame] | 63 | #include <mm/mmu_decl.h> |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 64 | |
Stephen Rothwell | 66ba135 | 2005-11-09 11:01:06 +1100 | [diff] [blame] | 65 | #include "setup.h" |
| 66 | |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 67 | #ifdef DEBUG |
Michael Ellerman | f9e4ec5 | 2005-11-15 15:16:38 +1100 | [diff] [blame] | 68 | #include <asm/udbg.h> |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 69 | #define DBG(fmt...) udbg_printf(fmt) |
| 70 | #else |
| 71 | #define DBG(fmt...) |
| 72 | #endif |
| 73 | |
Benjamin Herrenschmidt | e822250 | 2006-03-28 23:15:54 +1100 | [diff] [blame] | 74 | /* The main machine-dep calls structure |
| 75 | */ |
| 76 | struct machdep_calls ppc_md; |
| 77 | EXPORT_SYMBOL(ppc_md); |
| 78 | struct machdep_calls *machine_id; |
| 79 | EXPORT_SYMBOL(machine_id); |
Paul Mackerras | 799d604 | 2005-11-10 13:37:51 +1100 | [diff] [blame] | 80 | |
Paul Mackerras | 49b0985 | 2005-11-10 15:53:40 +1100 | [diff] [blame] | 81 | unsigned long klimit = (unsigned long) _end; |
| 82 | |
Stephen Rothwell | 19a8d97 | 2007-09-17 14:41:38 +1000 | [diff] [blame] | 83 | char cmd_line[COMMAND_LINE_SIZE]; |
| 84 | |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 85 | /* |
| 86 | * This still seems to be needed... -- paulus |
| 87 | */ |
| 88 | struct screen_info screen_info = { |
| 89 | .orig_x = 0, |
| 90 | .orig_y = 25, |
| 91 | .orig_video_cols = 80, |
| 92 | .orig_video_lines = 25, |
| 93 | .orig_video_isVGA = 1, |
| 94 | .orig_video_points = 16 |
| 95 | }; |
| 96 | |
Martyn Welch | 540c6c3 | 2010-05-24 22:09:16 +0000 | [diff] [blame] | 97 | /* Variables required to store legacy IO irq routing */ |
| 98 | int of_i8042_kbd_irq; |
Grant Likely | ee11006 | 2010-08-06 20:49:20 -0600 | [diff] [blame] | 99 | EXPORT_SYMBOL_GPL(of_i8042_kbd_irq); |
Martyn Welch | 540c6c3 | 2010-05-24 22:09:16 +0000 | [diff] [blame] | 100 | int of_i8042_aux_irq; |
Grant Likely | ee11006 | 2010-08-06 20:49:20 -0600 | [diff] [blame] | 101 | EXPORT_SYMBOL_GPL(of_i8042_aux_irq); |
Martyn Welch | 540c6c3 | 2010-05-24 22:09:16 +0000 | [diff] [blame] | 102 | |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 103 | #ifdef __DO_IRQ_CANON |
| 104 | /* XXX should go elsewhere eventually */ |
| 105 | int ppc_do_canonicalize_irqs; |
| 106 | EXPORT_SYMBOL(ppc_do_canonicalize_irqs); |
| 107 | #endif |
| 108 | |
| 109 | /* also used by kexec */ |
| 110 | void machine_shutdown(void) |
| 111 | { |
Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 112 | if (ppc_md.machine_shutdown) |
| 113 | ppc_md.machine_shutdown(); |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | void machine_restart(char *cmd) |
| 117 | { |
| 118 | machine_shutdown(); |
Kumar Gala | b8e383d | 2006-01-13 10:15:17 -0600 | [diff] [blame] | 119 | if (ppc_md.restart) |
| 120 | ppc_md.restart(cmd); |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 121 | #ifdef CONFIG_SMP |
| 122 | smp_send_stop(); |
| 123 | #endif |
| 124 | printk(KERN_EMERG "System Halted, OK to turn off power\n"); |
| 125 | local_irq_disable(); |
| 126 | while (1) ; |
| 127 | } |
| 128 | |
| 129 | void machine_power_off(void) |
| 130 | { |
| 131 | machine_shutdown(); |
Kumar Gala | b8e383d | 2006-01-13 10:15:17 -0600 | [diff] [blame] | 132 | if (ppc_md.power_off) |
| 133 | ppc_md.power_off(); |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 134 | #ifdef CONFIG_SMP |
| 135 | smp_send_stop(); |
| 136 | #endif |
| 137 | printk(KERN_EMERG "System Halted, OK to turn off power\n"); |
| 138 | local_irq_disable(); |
| 139 | while (1) ; |
| 140 | } |
| 141 | /* Used by the G5 thermal driver */ |
| 142 | EXPORT_SYMBOL_GPL(machine_power_off); |
| 143 | |
| 144 | void (*pm_power_off)(void) = machine_power_off; |
| 145 | EXPORT_SYMBOL_GPL(pm_power_off); |
| 146 | |
| 147 | void machine_halt(void) |
| 148 | { |
| 149 | machine_shutdown(); |
Kumar Gala | b8e383d | 2006-01-13 10:15:17 -0600 | [diff] [blame] | 150 | if (ppc_md.halt) |
| 151 | ppc_md.halt(); |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 152 | #ifdef CONFIG_SMP |
| 153 | smp_send_stop(); |
| 154 | #endif |
| 155 | printk(KERN_EMERG "System Halted, OK to turn off power\n"); |
| 156 | local_irq_disable(); |
| 157 | while (1) ; |
| 158 | } |
| 159 | |
| 160 | |
| 161 | #ifdef CONFIG_TAU |
| 162 | extern u32 cpu_temp(unsigned long cpu); |
| 163 | extern u32 cpu_temp_both(unsigned long cpu); |
| 164 | #endif /* CONFIG_TAU */ |
| 165 | |
| 166 | #ifdef CONFIG_SMP |
Tejun Heo | 6b7487f | 2009-10-29 22:34:14 +0900 | [diff] [blame] | 167 | DEFINE_PER_CPU(unsigned int, cpu_pvr); |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 168 | #endif |
| 169 | |
Anton Blanchard | 2c2df03 | 2010-04-26 15:32:39 +0000 | [diff] [blame] | 170 | static void show_cpuinfo_summary(struct seq_file *m) |
| 171 | { |
| 172 | struct device_node *root; |
| 173 | const char *model = NULL; |
| 174 | #if defined(CONFIG_SMP) && defined(CONFIG_PPC32) |
| 175 | unsigned long bogosum = 0; |
| 176 | int i; |
| 177 | for_each_online_cpu(i) |
| 178 | bogosum += loops_per_jiffy; |
| 179 | seq_printf(m, "total bogomips\t: %lu.%02lu\n", |
| 180 | bogosum/(500000/HZ), bogosum/(5000/HZ) % 100); |
| 181 | #endif /* CONFIG_SMP && CONFIG_PPC32 */ |
| 182 | seq_printf(m, "timebase\t: %lu\n", ppc_tb_freq); |
| 183 | if (ppc_md.name) |
| 184 | seq_printf(m, "platform\t: %s\n", ppc_md.name); |
| 185 | root = of_find_node_by_path("/"); |
| 186 | if (root) |
| 187 | model = of_get_property(root, "model", NULL); |
| 188 | if (model) |
| 189 | seq_printf(m, "model\t\t: %s\n", model); |
| 190 | of_node_put(root); |
| 191 | |
| 192 | if (ppc_md.show_cpuinfo != NULL) |
| 193 | ppc_md.show_cpuinfo(m); |
| 194 | |
| 195 | #ifdef CONFIG_PPC32 |
| 196 | /* Display the amount of memory */ |
| 197 | seq_printf(m, "Memory\t\t: %d MB\n", |
| 198 | (unsigned int)(total_memory / (1024 * 1024))); |
| 199 | #endif |
| 200 | } |
| 201 | |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 202 | static int show_cpuinfo(struct seq_file *m, void *v) |
| 203 | { |
| 204 | unsigned long cpu_id = (unsigned long)v - 1; |
| 205 | unsigned int pvr; |
| 206 | unsigned short maj; |
| 207 | unsigned short min; |
| 208 | |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 209 | /* We only show online cpus: disable preempt (overzealous, I |
| 210 | * knew) to prevent cpu going down. */ |
| 211 | preempt_disable(); |
| 212 | if (!cpu_online(cpu_id)) { |
| 213 | preempt_enable(); |
| 214 | return 0; |
| 215 | } |
| 216 | |
| 217 | #ifdef CONFIG_SMP |
Tejun Heo | 6b7487f | 2009-10-29 22:34:14 +0900 | [diff] [blame] | 218 | pvr = per_cpu(cpu_pvr, cpu_id); |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 219 | #else |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 220 | pvr = mfspr(SPRN_PVR); |
| 221 | #endif |
| 222 | maj = (pvr >> 8) & 0xFF; |
| 223 | min = pvr & 0xFF; |
| 224 | |
| 225 | seq_printf(m, "processor\t: %lu\n", cpu_id); |
| 226 | seq_printf(m, "cpu\t\t: "); |
| 227 | |
| 228 | if (cur_cpu_spec->pvr_mask) |
| 229 | seq_printf(m, "%s", cur_cpu_spec->cpu_name); |
| 230 | else |
| 231 | seq_printf(m, "unknown (%08x)", pvr); |
| 232 | |
| 233 | #ifdef CONFIG_ALTIVEC |
| 234 | if (cpu_has_feature(CPU_FTR_ALTIVEC)) |
| 235 | seq_printf(m, ", altivec supported"); |
| 236 | #endif /* CONFIG_ALTIVEC */ |
| 237 | |
| 238 | seq_printf(m, "\n"); |
| 239 | |
| 240 | #ifdef CONFIG_TAU |
| 241 | if (cur_cpu_spec->cpu_features & CPU_FTR_TAU) { |
| 242 | #ifdef CONFIG_TAU_AVERAGE |
| 243 | /* more straightforward, but potentially misleading */ |
| 244 | seq_printf(m, "temperature \t: %u C (uncalibrated)\n", |
Paul Mackerras | bccfd58 | 2005-11-02 15:06:22 +1100 | [diff] [blame] | 245 | cpu_temp(cpu_id)); |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 246 | #else |
| 247 | /* show the actual temp sensor range */ |
| 248 | u32 temp; |
Paul Mackerras | bccfd58 | 2005-11-02 15:06:22 +1100 | [diff] [blame] | 249 | temp = cpu_temp_both(cpu_id); |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 250 | seq_printf(m, "temperature \t: %u-%u C (uncalibrated)\n", |
| 251 | temp & 0xff, temp >> 16); |
| 252 | #endif |
| 253 | } |
| 254 | #endif /* CONFIG_TAU */ |
| 255 | |
| 256 | /* |
| 257 | * Assume here that all clock rates are the same in a |
| 258 | * smp system. -- Cort |
| 259 | */ |
| 260 | if (ppc_proc_freq) |
| 261 | seq_printf(m, "clock\t\t: %lu.%06luMHz\n", |
| 262 | ppc_proc_freq / 1000000, ppc_proc_freq % 1000000); |
| 263 | |
| 264 | if (ppc_md.show_percpuinfo != NULL) |
| 265 | ppc_md.show_percpuinfo(m, cpu_id); |
| 266 | |
| 267 | /* If we are a Freescale core do a simple check so |
| 268 | * we dont have to keep adding cases in the future */ |
| 269 | if (PVR_VER(pvr) & 0x8000) { |
Martin Langer | a501d8f | 2008-09-07 17:51:32 +1000 | [diff] [blame] | 270 | switch (PVR_VER(pvr)) { |
| 271 | case 0x8000: /* 7441/7450/7451, Voyager */ |
| 272 | case 0x8001: /* 7445/7455, Apollo 6 */ |
| 273 | case 0x8002: /* 7447/7457, Apollo 7 */ |
| 274 | case 0x8003: /* 7447A, Apollo 7 PM */ |
| 275 | case 0x8004: /* 7448, Apollo 8 */ |
| 276 | case 0x800c: /* 7410, Nitro */ |
| 277 | maj = ((pvr >> 8) & 0xF); |
| 278 | min = PVR_MIN(pvr); |
| 279 | break; |
| 280 | default: /* e500/book-e */ |
| 281 | maj = PVR_MAJ(pvr); |
| 282 | min = PVR_MIN(pvr); |
| 283 | break; |
| 284 | } |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 285 | } else { |
| 286 | switch (PVR_VER(pvr)) { |
| 287 | case 0x0020: /* 403 family */ |
| 288 | maj = PVR_MAJ(pvr) + 1; |
| 289 | min = PVR_MIN(pvr); |
| 290 | break; |
| 291 | case 0x1008: /* 740P/750P ?? */ |
| 292 | maj = ((pvr >> 8) & 0xFF) - 1; |
| 293 | min = pvr & 0xFF; |
| 294 | break; |
| 295 | default: |
| 296 | maj = (pvr >> 8) & 0xFF; |
| 297 | min = pvr & 0xFF; |
| 298 | break; |
| 299 | } |
| 300 | } |
| 301 | |
| 302 | seq_printf(m, "revision\t: %hd.%hd (pvr %04x %04x)\n", |
| 303 | maj, min, PVR_VER(pvr), PVR_REV(pvr)); |
| 304 | |
| 305 | #ifdef CONFIG_PPC32 |
| 306 | seq_printf(m, "bogomips\t: %lu.%02lu\n", |
| 307 | loops_per_jiffy / (500000/HZ), |
| 308 | (loops_per_jiffy / (5000/HZ)) % 100); |
| 309 | #endif |
| 310 | |
| 311 | #ifdef CONFIG_SMP |
| 312 | seq_printf(m, "\n"); |
| 313 | #endif |
| 314 | |
| 315 | preempt_enable(); |
Anton Blanchard | e6532c6 | 2010-04-26 15:32:40 +0000 | [diff] [blame] | 316 | |
| 317 | /* If this is the last cpu, print the summary */ |
| 318 | if (cpumask_next(cpu_id, cpu_online_mask) >= nr_cpu_ids) |
| 319 | show_cpuinfo_summary(m); |
| 320 | |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 321 | return 0; |
| 322 | } |
| 323 | |
| 324 | static void *c_start(struct seq_file *m, loff_t *pos) |
| 325 | { |
Anton Blanchard | e6532c6 | 2010-04-26 15:32:40 +0000 | [diff] [blame] | 326 | if (*pos == 0) /* just in case, cpu 0 is not the first */ |
| 327 | *pos = cpumask_first(cpu_online_mask); |
| 328 | else |
| 329 | *pos = cpumask_next(*pos - 1, cpu_online_mask); |
| 330 | if ((*pos) < nr_cpu_ids) |
| 331 | return (void *)(unsigned long)(*pos + 1); |
| 332 | return NULL; |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 333 | } |
| 334 | |
| 335 | static void *c_next(struct seq_file *m, void *v, loff_t *pos) |
| 336 | { |
Anton Blanchard | e6532c6 | 2010-04-26 15:32:40 +0000 | [diff] [blame] | 337 | (*pos)++; |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 338 | return c_start(m, pos); |
| 339 | } |
| 340 | |
| 341 | static void c_stop(struct seq_file *m, void *v) |
| 342 | { |
| 343 | } |
| 344 | |
James Morris | 88e9d34 | 2009-09-22 16:43:43 -0700 | [diff] [blame] | 345 | const struct seq_operations cpuinfo_op = { |
Paul Mackerras | 03501da | 2005-10-26 17:11:18 +1000 | [diff] [blame] | 346 | .start =c_start, |
| 347 | .next = c_next, |
| 348 | .stop = c_stop, |
| 349 | .show = show_cpuinfo, |
| 350 | }; |
| 351 | |
David Woodhouse | a82765b | 2005-11-02 22:34:20 +0000 | [diff] [blame] | 352 | void __init check_for_initrd(void) |
| 353 | { |
| 354 | #ifdef CONFIG_BLK_DEV_INITRD |
David Gibson | 30437b3 | 2007-02-28 14:12:29 +1100 | [diff] [blame] | 355 | DBG(" -> check_for_initrd() initrd_start=0x%lx initrd_end=0x%lx\n", |
| 356 | initrd_start, initrd_end); |
David Woodhouse | a82765b | 2005-11-02 22:34:20 +0000 | [diff] [blame] | 357 | |
| 358 | /* If we were passed an initrd, set the ROOT_DEV properly if the values |
| 359 | * look sensible. If not, clear initrd reference. |
| 360 | */ |
Michael Ellerman | 51fae6de | 2005-12-04 18:39:15 +1100 | [diff] [blame] | 361 | if (is_kernel_addr(initrd_start) && is_kernel_addr(initrd_end) && |
David Woodhouse | a82765b | 2005-11-02 22:34:20 +0000 | [diff] [blame] | 362 | initrd_end > initrd_start) |
| 363 | ROOT_DEV = Root_RAM0; |
David Woodhouse | 6761c4a | 2005-11-11 08:07:11 +0000 | [diff] [blame] | 364 | else |
David Woodhouse | a82765b | 2005-11-02 22:34:20 +0000 | [diff] [blame] | 365 | initrd_start = initrd_end = 0; |
David Woodhouse | a82765b | 2005-11-02 22:34:20 +0000 | [diff] [blame] | 366 | |
| 367 | if (initrd_start) |
| 368 | printk("Found initrd at 0x%lx:0x%lx\n", initrd_start, initrd_end); |
| 369 | |
| 370 | DBG(" <- check_for_initrd()\n"); |
| 371 | #endif /* CONFIG_BLK_DEV_INITRD */ |
| 372 | } |
| 373 | |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 374 | #ifdef CONFIG_SMP |
| 375 | |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 376 | int threads_per_core, threads_shift; |
| 377 | cpumask_t threads_core_mask; |
| 378 | |
| 379 | static void __init cpu_init_thread_core_maps(int tpc) |
| 380 | { |
| 381 | int i; |
| 382 | |
| 383 | threads_per_core = tpc; |
KOSAKI Motohiro | 104699c | 2011-04-28 05:07:23 +0000 | [diff] [blame] | 384 | cpumask_clear(&threads_core_mask); |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 385 | |
| 386 | /* This implementation only supports power of 2 number of threads |
| 387 | * for simplicity and performance |
| 388 | */ |
| 389 | threads_shift = ilog2(tpc); |
| 390 | BUG_ON(tpc != (1 << threads_shift)); |
| 391 | |
| 392 | for (i = 0; i < tpc; i++) |
KOSAKI Motohiro | 104699c | 2011-04-28 05:07:23 +0000 | [diff] [blame] | 393 | cpumask_set_cpu(i, &threads_core_mask); |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 394 | |
| 395 | printk(KERN_INFO "CPU maps initialized for %d thread%s per core\n", |
| 396 | tpc, tpc > 1 ? "s" : ""); |
| 397 | printk(KERN_DEBUG " (thread shift is %d)\n", threads_shift); |
| 398 | } |
| 399 | |
| 400 | |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 401 | /** |
| 402 | * setup_cpu_maps - initialize the following cpu maps: |
Anton Blanchard | 828a698 | 2010-04-26 15:32:44 +0000 | [diff] [blame] | 403 | * cpu_possible_mask |
| 404 | * cpu_present_mask |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 405 | * |
| 406 | * Having the possible map set up early allows us to restrict allocations |
Milton Miller | 8657ae2 | 2011-05-10 19:28:48 +0000 | [diff] [blame] | 407 | * of things like irqstacks to nr_cpu_ids rather than NR_CPUS. |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 408 | * |
| 409 | * We do not initialize the online map here; cpus set their own bits in |
Anton Blanchard | 828a698 | 2010-04-26 15:32:44 +0000 | [diff] [blame] | 410 | * cpu_online_mask as they come up. |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 411 | * |
| 412 | * This function is valid only for Open Firmware systems. finish_device_tree |
| 413 | * must be called before using this. |
| 414 | * |
| 415 | * While we're here, we may as well set the "physical" cpu ids in the paca. |
Anton Blanchard | 4df2046 | 2006-03-25 17:25:17 +1100 | [diff] [blame] | 416 | * |
| 417 | * NOTE: This must match the parsing done in early_init_dt_scan_cpus. |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 418 | */ |
| 419 | void __init smp_setup_cpu_maps(void) |
| 420 | { |
| 421 | struct device_node *dn = NULL; |
| 422 | int cpu = 0; |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 423 | int nthreads = 1; |
| 424 | |
| 425 | DBG("smp_setup_cpu_maps()\n"); |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 426 | |
Milton Miller | 8657ae2 | 2011-05-10 19:28:48 +0000 | [diff] [blame] | 427 | while ((dn = of_find_node_by_type(dn, "cpu")) && cpu < nr_cpu_ids) { |
Jeremy Kerr | a7f67bd | 2006-07-12 15:35:54 +1000 | [diff] [blame] | 428 | const int *intserv; |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 429 | int j, len; |
| 430 | |
| 431 | DBG(" * %s...\n", dn->full_name); |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 432 | |
Stephen Rothwell | e2eb639 | 2007-04-03 22:26:41 +1000 | [diff] [blame] | 433 | intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", |
| 434 | &len); |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 435 | if (intserv) { |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 436 | nthreads = len / sizeof(int); |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 437 | DBG(" ibm,ppc-interrupt-server#s -> %d threads\n", |
| 438 | nthreads); |
| 439 | } else { |
| 440 | DBG(" no ibm,ppc-interrupt-server#s -> 1 thread\n"); |
Stephen Rothwell | e2eb639 | 2007-04-03 22:26:41 +1000 | [diff] [blame] | 441 | intserv = of_get_property(dn, "reg", NULL); |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 442 | if (!intserv) |
| 443 | intserv = &cpu; /* assume logical == phys */ |
| 444 | } |
| 445 | |
Milton Miller | 8657ae2 | 2011-05-10 19:28:48 +0000 | [diff] [blame] | 446 | for (j = 0; j < nthreads && cpu < nr_cpu_ids; j++) { |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 447 | DBG(" thread %d -> cpu %d (hard id %d)\n", |
| 448 | j, cpu, intserv[j]); |
Rusty Russell | ea0f1ca | 2009-09-24 09:34:48 -0600 | [diff] [blame] | 449 | set_cpu_present(cpu, true); |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 450 | set_hard_smp_processor_id(cpu, intserv[j]); |
Rusty Russell | ea0f1ca | 2009-09-24 09:34:48 -0600 | [diff] [blame] | 451 | set_cpu_possible(cpu, true); |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 452 | cpu++; |
| 453 | } |
| 454 | } |
| 455 | |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 456 | /* If no SMT supported, nthreads is forced to 1 */ |
| 457 | if (!cpu_has_feature(CPU_FTR_SMT)) { |
| 458 | DBG(" SMT disabled ! nthreads forced to 1\n"); |
| 459 | nthreads = 1; |
| 460 | } |
| 461 | |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 462 | #ifdef CONFIG_PPC64 |
| 463 | /* |
| 464 | * On pSeries LPAR, we need to know how many cpus |
| 465 | * could possibly be added to this partition. |
| 466 | */ |
Benjamin Herrenschmidt | e822250 | 2006-03-28 23:15:54 +1100 | [diff] [blame] | 467 | if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR) && |
Paul Mackerras | 799d604 | 2005-11-10 13:37:51 +1100 | [diff] [blame] | 468 | (dn = of_find_node_by_path("/rtas"))) { |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 469 | int num_addr_cell, num_size_cell, maxcpus; |
Jeremy Kerr | a7f67bd | 2006-07-12 15:35:54 +1000 | [diff] [blame] | 470 | const unsigned int *ireg; |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 471 | |
Stephen Rothwell | a8bda5d | 2007-04-03 10:56:50 +1000 | [diff] [blame] | 472 | num_addr_cell = of_n_addr_cells(dn); |
Stephen Rothwell | 9213fee | 2007-04-03 10:57:48 +1000 | [diff] [blame] | 473 | num_size_cell = of_n_size_cells(dn); |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 474 | |
Stephen Rothwell | e2eb639 | 2007-04-03 22:26:41 +1000 | [diff] [blame] | 475 | ireg = of_get_property(dn, "ibm,lrdr-capacity", NULL); |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 476 | |
| 477 | if (!ireg) |
| 478 | goto out; |
| 479 | |
| 480 | maxcpus = ireg[num_addr_cell + num_size_cell]; |
| 481 | |
| 482 | /* Double maxcpus for processors which have SMT capability */ |
| 483 | if (cpu_has_feature(CPU_FTR_SMT)) |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 484 | maxcpus *= nthreads; |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 485 | |
Milton Miller | 8657ae2 | 2011-05-10 19:28:48 +0000 | [diff] [blame] | 486 | if (maxcpus > nr_cpu_ids) { |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 487 | printk(KERN_WARNING |
| 488 | "Partition configured for %d cpus, " |
| 489 | "operating system maximum is %d.\n", |
Milton Miller | 8657ae2 | 2011-05-10 19:28:48 +0000 | [diff] [blame] | 490 | maxcpus, nr_cpu_ids); |
| 491 | maxcpus = nr_cpu_ids; |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 492 | } else |
| 493 | printk(KERN_INFO "Partition configured for %d cpus.\n", |
| 494 | maxcpus); |
| 495 | |
| 496 | for (cpu = 0; cpu < maxcpus; cpu++) |
Rusty Russell | ea0f1ca | 2009-09-24 09:34:48 -0600 | [diff] [blame] | 497 | set_cpu_possible(cpu, true); |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 498 | out: |
| 499 | of_node_put(dn); |
| 500 | } |
Mike Travis | d5a7430 | 2007-10-16 01:24:05 -0700 | [diff] [blame] | 501 | vdso_data->processorCount = num_present_cpus(); |
| 502 | #endif /* CONFIG_PPC64 */ |
Benjamin Herrenschmidt | 8d08908 | 2007-10-25 15:27:44 +1000 | [diff] [blame] | 503 | |
| 504 | /* Initialize CPU <=> thread mapping/ |
| 505 | * |
| 506 | * WARNING: We assume that the number of threads is the same for |
| 507 | * every CPU in the system. If that is not the case, then some code |
| 508 | * here will have to be reworked |
| 509 | */ |
| 510 | cpu_init_thread_core_maps(nthreads); |
Michael Ellerman | 1426d5a | 2010-01-28 13:23:22 +0000 | [diff] [blame] | 511 | |
Ryan Grimm | c1854e0 | 2011-03-31 19:33:02 +0000 | [diff] [blame] | 512 | /* Now that possible cpus are set, set nr_cpu_ids for later use */ |
Milton Miller | aa79bc2 | 2011-05-10 19:28:55 +0000 | [diff] [blame] | 513 | setup_nr_cpu_ids(); |
Ryan Grimm | c1854e0 | 2011-03-31 19:33:02 +0000 | [diff] [blame] | 514 | |
Michael Ellerman | 1426d5a | 2010-01-28 13:23:22 +0000 | [diff] [blame] | 515 | free_unused_pacas(); |
Mike Travis | d5a7430 | 2007-10-16 01:24:05 -0700 | [diff] [blame] | 516 | } |
Paul Mackerras | 5ad5707 | 2005-11-05 10:33:55 +1100 | [diff] [blame] | 517 | #endif /* CONFIG_SMP */ |
Paul Mackerras | fca5dcd | 2005-11-08 22:55:08 +1100 | [diff] [blame] | 518 | |
Emil Medve | d33b78d | 2008-05-23 08:40:16 +1000 | [diff] [blame] | 519 | #ifdef CONFIG_PCSPKR_PLATFORM |
Michael Neuling | e5c6c8e | 2006-03-14 00:11:50 -0500 | [diff] [blame] | 520 | static __init int add_pcspkr(void) |
| 521 | { |
| 522 | struct device_node *np; |
| 523 | struct platform_device *pd; |
| 524 | int ret; |
| 525 | |
| 526 | np = of_find_compatible_node(NULL, NULL, "pnpPNP,100"); |
| 527 | of_node_put(np); |
| 528 | if (!np) |
| 529 | return -ENODEV; |
| 530 | |
| 531 | pd = platform_device_alloc("pcspkr", -1); |
| 532 | if (!pd) |
| 533 | return -ENOMEM; |
| 534 | |
| 535 | ret = platform_device_add(pd); |
| 536 | if (ret) |
| 537 | platform_device_put(pd); |
| 538 | |
| 539 | return ret; |
| 540 | } |
| 541 | device_initcall(add_pcspkr); |
Emil Medve | d33b78d | 2008-05-23 08:40:16 +1000 | [diff] [blame] | 542 | #endif /* CONFIG_PCSPKR_PLATFORM */ |
Dmitry Torokhov | 95d465f | 2006-04-02 00:08:05 -0500 | [diff] [blame] | 543 | |
Benjamin Herrenschmidt | e822250 | 2006-03-28 23:15:54 +1100 | [diff] [blame] | 544 | void probe_machine(void) |
| 545 | { |
| 546 | extern struct machdep_calls __machine_desc_start; |
| 547 | extern struct machdep_calls __machine_desc_end; |
| 548 | |
| 549 | /* |
| 550 | * Iterate all ppc_md structures until we find the proper |
| 551 | * one for the current machine type |
| 552 | */ |
| 553 | DBG("Probing machine type ...\n"); |
| 554 | |
| 555 | for (machine_id = &__machine_desc_start; |
| 556 | machine_id < &__machine_desc_end; |
| 557 | machine_id++) { |
| 558 | DBG(" %s ...", machine_id->name); |
| 559 | memcpy(&ppc_md, machine_id, sizeof(struct machdep_calls)); |
| 560 | if (ppc_md.probe()) { |
| 561 | DBG(" match !\n"); |
| 562 | break; |
| 563 | } |
| 564 | DBG("\n"); |
| 565 | } |
| 566 | /* What can we do if we didn't find ? */ |
| 567 | if (machine_id >= &__machine_desc_end) { |
| 568 | DBG("No suitable machine found !\n"); |
| 569 | for (;;); |
| 570 | } |
| 571 | |
| 572 | printk(KERN_INFO "Using %s machine description\n", ppc_md.name); |
| 573 | } |
David Woodhouse | 1269277a | 2006-04-24 23:22:17 +0100 | [diff] [blame] | 574 | |
Olaf Hering | 8d8a024 | 2007-04-26 06:36:56 +1000 | [diff] [blame] | 575 | /* Match a class of boards, not a specific device configuration. */ |
David Woodhouse | 1269277a | 2006-04-24 23:22:17 +0100 | [diff] [blame] | 576 | int check_legacy_ioport(unsigned long base_port) |
| 577 | { |
Olaf Hering | 8d8a024 | 2007-04-26 06:36:56 +1000 | [diff] [blame] | 578 | struct device_node *parent, *np = NULL; |
| 579 | int ret = -ENODEV; |
| 580 | |
| 581 | switch(base_port) { |
| 582 | case I8042_DATA_REG: |
Wade Farnsworth | db0dbae | 2007-06-20 10:15:10 +1000 | [diff] [blame] | 583 | if (!(np = of_find_compatible_node(NULL, NULL, "pnpPNP,303"))) |
| 584 | np = of_find_compatible_node(NULL, NULL, "pnpPNP,f03"); |
| 585 | if (np) { |
| 586 | parent = of_get_parent(np); |
Martyn Welch | 540c6c3 | 2010-05-24 22:09:16 +0000 | [diff] [blame] | 587 | |
| 588 | of_i8042_kbd_irq = irq_of_parse_and_map(parent, 0); |
| 589 | if (!of_i8042_kbd_irq) |
| 590 | of_i8042_kbd_irq = 1; |
| 591 | |
| 592 | of_i8042_aux_irq = irq_of_parse_and_map(parent, 1); |
| 593 | if (!of_i8042_aux_irq) |
| 594 | of_i8042_aux_irq = 12; |
| 595 | |
Wade Farnsworth | db0dbae | 2007-06-20 10:15:10 +1000 | [diff] [blame] | 596 | of_node_put(np); |
| 597 | np = parent; |
| 598 | break; |
| 599 | } |
Olaf Hering | 8d8a024 | 2007-04-26 06:36:56 +1000 | [diff] [blame] | 600 | np = of_find_node_by_type(NULL, "8042"); |
Alan Curry | f5d834f | 2007-07-25 11:28:32 +1000 | [diff] [blame] | 601 | /* Pegasos has no device_type on its 8042 node, look for the |
| 602 | * name instead */ |
| 603 | if (!np) |
| 604 | np = of_find_node_by_name(NULL, "8042"); |
Gabriel Paubert | 2c78027 | 2011-05-13 01:03:13 +0000 | [diff] [blame] | 605 | if (np) { |
| 606 | of_i8042_kbd_irq = 1; |
| 607 | of_i8042_aux_irq = 12; |
| 608 | } |
Olaf Hering | 8d8a024 | 2007-04-26 06:36:56 +1000 | [diff] [blame] | 609 | break; |
| 610 | case FDC_BASE: /* FDC1 */ |
| 611 | np = of_find_node_by_type(NULL, "fdc"); |
| 612 | break; |
| 613 | #ifdef CONFIG_PPC_PREP |
| 614 | case _PIDXR: |
| 615 | case _PNPWRP: |
| 616 | case PNPBIOS_BASE: |
| 617 | /* implement me */ |
| 618 | #endif |
| 619 | default: |
| 620 | /* ipmi is supposed to fail here */ |
| 621 | break; |
| 622 | } |
| 623 | if (!np) |
| 624 | return ret; |
| 625 | parent = of_get_parent(np); |
| 626 | if (parent) { |
| 627 | if (strcmp(parent->type, "isa") == 0) |
| 628 | ret = 0; |
| 629 | of_node_put(parent); |
| 630 | } |
| 631 | of_node_put(np); |
| 632 | return ret; |
David Woodhouse | 1269277a | 2006-04-24 23:22:17 +0100 | [diff] [blame] | 633 | } |
| 634 | EXPORT_SYMBOL(check_legacy_ioport); |
Kumar Gala | 7e99026 | 2006-05-05 00:02:08 -0500 | [diff] [blame] | 635 | |
| 636 | static int ppc_panic_event(struct notifier_block *this, |
| 637 | unsigned long event, void *ptr) |
| 638 | { |
| 639 | ppc_md.panic(ptr); /* May not return */ |
| 640 | return NOTIFY_DONE; |
| 641 | } |
| 642 | |
| 643 | static struct notifier_block ppc_panic_block = { |
| 644 | .notifier_call = ppc_panic_event, |
| 645 | .priority = INT_MIN /* may not return; must be done last */ |
| 646 | }; |
| 647 | |
| 648 | void __init setup_panic(void) |
| 649 | { |
| 650 | atomic_notifier_chain_register(&panic_notifier_list, &ppc_panic_block); |
| 651 | } |
Dale Farnsworth | 06cce43 | 2007-05-12 10:57:35 +1000 | [diff] [blame] | 652 | |
| 653 | #ifdef CONFIG_CHECK_CACHE_COHERENCY |
| 654 | /* |
| 655 | * For platforms that have configurable cache-coherency. This function |
| 656 | * checks that the cache coherency setting of the kernel matches the setting |
| 657 | * left by the firmware, as indicated in the device tree. Since a mismatch |
| 658 | * will eventually result in DMA failures, we print * and error and call |
| 659 | * BUG() in that case. |
| 660 | */ |
| 661 | |
| 662 | #ifdef CONFIG_NOT_COHERENT_CACHE |
| 663 | #define KERNEL_COHERENCY 0 |
| 664 | #else |
| 665 | #define KERNEL_COHERENCY 1 |
| 666 | #endif |
| 667 | |
| 668 | static int __init check_cache_coherency(void) |
| 669 | { |
| 670 | struct device_node *np; |
| 671 | const void *prop; |
| 672 | int devtree_coherency; |
| 673 | |
| 674 | np = of_find_node_by_path("/"); |
| 675 | prop = of_get_property(np, "coherency-off", NULL); |
| 676 | of_node_put(np); |
| 677 | |
| 678 | devtree_coherency = prop ? 0 : 1; |
| 679 | |
| 680 | if (devtree_coherency != KERNEL_COHERENCY) { |
| 681 | printk(KERN_ERR |
| 682 | "kernel coherency:%s != device tree_coherency:%s\n", |
| 683 | KERNEL_COHERENCY ? "on" : "off", |
| 684 | devtree_coherency ? "on" : "off"); |
| 685 | BUG(); |
| 686 | } |
| 687 | |
| 688 | return 0; |
| 689 | } |
| 690 | |
| 691 | late_initcall(check_cache_coherency); |
| 692 | #endif /* CONFIG_CHECK_CACHE_COHERENCY */ |
Michael Ellerman | 94a3807 | 2007-06-20 10:54:19 +1000 | [diff] [blame] | 693 | |
| 694 | #ifdef CONFIG_DEBUG_FS |
| 695 | struct dentry *powerpc_debugfs_root; |
Anton Blanchard | 907b1f4 | 2009-10-26 18:52:24 +0000 | [diff] [blame] | 696 | EXPORT_SYMBOL(powerpc_debugfs_root); |
Michael Ellerman | 94a3807 | 2007-06-20 10:54:19 +1000 | [diff] [blame] | 697 | |
| 698 | static int powerpc_debugfs_init(void) |
| 699 | { |
| 700 | powerpc_debugfs_root = debugfs_create_dir("powerpc", NULL); |
| 701 | |
| 702 | return powerpc_debugfs_root == NULL; |
| 703 | } |
| 704 | arch_initcall(powerpc_debugfs_init); |
| 705 | #endif |
Kumar Gala | d746286 | 2009-03-19 03:40:51 +0000 | [diff] [blame] | 706 | |
| 707 | static int ppc_dflt_bus_notify(struct notifier_block *nb, |
| 708 | unsigned long action, void *data) |
| 709 | { |
| 710 | struct device *dev = data; |
| 711 | |
| 712 | /* We are only intereted in device addition */ |
| 713 | if (action != BUS_NOTIFY_ADD_DEVICE) |
| 714 | return 0; |
| 715 | |
| 716 | set_dma_ops(dev, &dma_direct_ops); |
| 717 | |
| 718 | return NOTIFY_DONE; |
| 719 | } |
| 720 | |
| 721 | static struct notifier_block ppc_dflt_plat_bus_notifier = { |
| 722 | .notifier_call = ppc_dflt_bus_notify, |
| 723 | .priority = INT_MAX, |
| 724 | }; |
| 725 | |
Kumar Gala | d746286 | 2009-03-19 03:40:51 +0000 | [diff] [blame] | 726 | static int __init setup_bus_notifier(void) |
| 727 | { |
| 728 | bus_register_notifier(&platform_bus_type, &ppc_dflt_plat_bus_notifier); |
Kumar Gala | d746286 | 2009-03-19 03:40:51 +0000 | [diff] [blame] | 729 | return 0; |
| 730 | } |
| 731 | |
| 732 | arch_initcall(setup_bus_notifier); |