1 #include <linux/module.h> 2 #include <linux/reboot.h> 3 #include <linux/init.h> 4 #include <linux/pm.h> 5 #include <linux/efi.h> 6 #include <acpi/reboot.h> 7 #include <asm/io.h> 8 #include <asm/apic.h> 9 #include <asm/desc.h> 10 #include <asm/hpet.h> 11 #include <asm/pgtable.h> 12 #include <asm/proto.h> 13 #include <asm/reboot_fixups.h> 14 #include <asm/reboot.h> 15 16 #ifdef CONFIG_X86_32 17 # include <linux/dmi.h> 18 # include <linux/ctype.h> 19 # include <linux/mc146818rtc.h> 20 #else 21 # include <asm/iommu.h> 22 #endif 23 24 /* 25 * Power off function, if any 26 */ 27 void (*pm_power_off)(void); 28 EXPORT_SYMBOL(pm_power_off); 29 30 static const struct desc_ptr no_idt = {}; 31 static int reboot_mode; 32 /* 33 * Keyboard reset and triple fault may result in INIT, not RESET, which 34 * doesn't work when we're in vmx root mode. Try ACPI first. 35 */ 36 enum reboot_type reboot_type = BOOT_ACPI; 37 int reboot_force; 38 39 #if defined(CONFIG_X86_32) && defined(CONFIG_SMP) 40 static int reboot_cpu = -1; 41 #endif 42 43 /* reboot=b[ios] | s[mp] | t[riple] | k[bd] | e[fi] [, [w]arm | [c]old] 44 warm Don't set the cold reboot flag 45 cold Set the cold reboot flag 46 bios Reboot by jumping through the BIOS (only for X86_32) 47 smp Reboot by executing reset on BSP or other CPU (only for X86_32) 48 triple Force a triple fault (init) 49 kbd Use the keyboard controller. cold reset (default) 50 acpi Use the RESET_REG in the FADT 51 efi Use efi reset_system runtime service 52 force Avoid anything that could hang. 53 */ 54 static int __init reboot_setup(char *str) 55 { 56 for (;;) { 57 switch (*str) { 58 case 'w': 59 reboot_mode = 0x1234; 60 break; 61 62 case 'c': 63 reboot_mode = 0; 64 break; 65 66 #ifdef CONFIG_X86_32 67 #ifdef CONFIG_SMP 68 case 's': 69 if (isdigit(*(str+1))) { 70 reboot_cpu = (int) (*(str+1) - '0'); 71 if (isdigit(*(str+2))) 72 reboot_cpu = reboot_cpu*10 + (int)(*(str+2) - '0'); 73 } 74 /* we will leave sorting out the final value 75 when we are ready to reboot, since we might not 76 have set up boot_cpu_id or smp_num_cpu */ 77 break; 78 #endif /* CONFIG_SMP */ 79 80 case 'b': 81 #endif 82 case 'a': 83 case 'k': 84 case 't': 85 case 'e': 86 reboot_type = *str; 87 break; 88 89 case 'f': 90 reboot_force = 1; 91 break; 92 } 93 94 str = strchr(str, ','); 95 if (str) 96 str++; 97 else 98 break; 99 } 100 return 1; 101 } 102 103 __setup("reboot=", reboot_setup); 104 105 106 #ifdef CONFIG_X86_32 107 /* 108 * Reboot options and system auto-detection code provided by 109 * Dell Inc. so their systems "just work". :-) 110 */ 111 112 /* 113 * Some machines require the "reboot=b" commandline option, 114 * this quirk makes that automatic. 115 */ 116 static int __init set_bios_reboot(const struct dmi_system_id *d) 117 { 118 if (reboot_type != BOOT_BIOS) { 119 reboot_type = BOOT_BIOS; 120 printk(KERN_INFO "%s series board detected. Selecting BIOS-method for reboots.\n", d->ident); 121 } 122 return 0; 123 } 124 125 static struct dmi_system_id __initdata reboot_dmi_table[] = { 126 { /* Handle problems with rebooting on Dell E520's */ 127 .callback = set_bios_reboot, 128 .ident = "Dell E520", 129 .matches = { 130 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 131 DMI_MATCH(DMI_PRODUCT_NAME, "Dell DM061"), 132 }, 133 }, 134 { /* Handle problems with rebooting on Dell 1300's */ 135 .callback = set_bios_reboot, 136 .ident = "Dell PowerEdge 1300", 137 .matches = { 138 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 139 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1300/"), 140 }, 141 }, 142 { /* Handle problems with rebooting on Dell 300's */ 143 .callback = set_bios_reboot, 144 .ident = "Dell PowerEdge 300", 145 .matches = { 146 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 147 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"), 148 }, 149 }, 150 { /* Handle problems with rebooting on Dell Optiplex 745's SFF*/ 151 .callback = set_bios_reboot, 152 .ident = "Dell OptiPlex 745", 153 .matches = { 154 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 155 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 156 }, 157 }, 158 { /* Handle problems with rebooting on Dell Optiplex 745's DFF*/ 159 .callback = set_bios_reboot, 160 .ident = "Dell OptiPlex 745", 161 .matches = { 162 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 163 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 164 DMI_MATCH(DMI_BOARD_NAME, "0MM599"), 165 }, 166 }, 167 { /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */ 168 .callback = set_bios_reboot, 169 .ident = "Dell OptiPlex 745", 170 .matches = { 171 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 172 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 173 DMI_MATCH(DMI_BOARD_NAME, "0KW626"), 174 }, 175 }, 176 { /* Handle problems with rebooting on Dell 2400's */ 177 .callback = set_bios_reboot, 178 .ident = "Dell PowerEdge 2400", 179 .matches = { 180 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 181 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"), 182 }, 183 }, 184 { /* Handle problems with rebooting on Dell T5400's */ 185 .callback = set_bios_reboot, 186 .ident = "Dell Precision T5400", 187 .matches = { 188 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 189 DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T5400"), 190 }, 191 }, 192 { /* Handle problems with rebooting on HP laptops */ 193 .callback = set_bios_reboot, 194 .ident = "HP Compaq Laptop", 195 .matches = { 196 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 197 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"), 198 }, 199 }, 200 { } 201 }; 202 203 static int __init reboot_init(void) 204 { 205 dmi_check_system(reboot_dmi_table); 206 return 0; 207 } 208 core_initcall(reboot_init); 209 210 /* The following code and data reboots the machine by switching to real 211 mode and jumping to the BIOS reset entry point, as if the CPU has 212 really been reset. The previous version asked the keyboard 213 controller to pulse the CPU reset line, which is more thorough, but 214 doesn't work with at least one type of 486 motherboard. It is easy 215 to stop this code working; hence the copious comments. */ 216 static const unsigned long long 217 real_mode_gdt_entries [3] = 218 { 219 0x0000000000000000ULL, /* Null descriptor */ 220 0x00009b000000ffffULL, /* 16-bit real-mode 64k code at 0x00000000 */ 221 0x000093000100ffffULL /* 16-bit real-mode 64k data at 0x00000100 */ 222 }; 223 224 static const struct desc_ptr 225 real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, (long)real_mode_gdt_entries }, 226 real_mode_idt = { 0x3ff, 0 }; 227 228 /* This is 16-bit protected mode code to disable paging and the cache, 229 switch to real mode and jump to the BIOS reset code. 230 231 The instruction that switches to real mode by writing to CR0 must be 232 followed immediately by a far jump instruction, which set CS to a 233 valid value for real mode, and flushes the prefetch queue to avoid 234 running instructions that have already been decoded in protected 235 mode. 236 237 Clears all the flags except ET, especially PG (paging), PE 238 (protected-mode enable) and TS (task switch for coprocessor state 239 save). Flushes the TLB after paging has been disabled. Sets CD and 240 NW, to disable the cache on a 486, and invalidates the cache. This 241 is more like the state of a 486 after reset. I don't know if 242 something else should be done for other chips. 243 244 More could be done here to set up the registers as if a CPU reset had 245 occurred; hopefully real BIOSs don't assume much. */ 246 static const unsigned char real_mode_switch [] = 247 { 248 0x66, 0x0f, 0x20, 0xc0, /* movl %cr0,%eax */ 249 0x66, 0x83, 0xe0, 0x11, /* andl $0x00000011,%eax */ 250 0x66, 0x0d, 0x00, 0x00, 0x00, 0x60, /* orl $0x60000000,%eax */ 251 0x66, 0x0f, 0x22, 0xc0, /* movl %eax,%cr0 */ 252 0x66, 0x0f, 0x22, 0xd8, /* movl %eax,%cr3 */ 253 0x66, 0x0f, 0x20, 0xc3, /* movl %cr0,%ebx */ 254 0x66, 0x81, 0xe3, 0x00, 0x00, 0x00, 0x60, /* andl $0x60000000,%ebx */ 255 0x74, 0x02, /* jz f */ 256 0x0f, 0x09, /* wbinvd */ 257 0x24, 0x10, /* f: andb $0x10,al */ 258 0x66, 0x0f, 0x22, 0xc0 /* movl %eax,%cr0 */ 259 }; 260 static const unsigned char jump_to_bios [] = 261 { 262 0xea, 0x00, 0x00, 0xff, 0xff /* ljmp $0xffff,$0x0000 */ 263 }; 264 265 /* 266 * Switch to real mode and then execute the code 267 * specified by the code and length parameters. 268 * We assume that length will aways be less that 100! 269 */ 270 void machine_real_restart(const unsigned char *code, int length) 271 { 272 local_irq_disable(); 273 274 /* Write zero to CMOS register number 0x0f, which the BIOS POST 275 routine will recognize as telling it to do a proper reboot. (Well 276 that's what this book in front of me says -- it may only apply to 277 the Phoenix BIOS though, it's not clear). At the same time, 278 disable NMIs by setting the top bit in the CMOS address register, 279 as we're about to do peculiar things to the CPU. I'm not sure if 280 `outb_p' is needed instead of just `outb'. Use it to be on the 281 safe side. (Yes, CMOS_WRITE does outb_p's. - Paul G.) 282 */ 283 spin_lock(&rtc_lock); 284 CMOS_WRITE(0x00, 0x8f); 285 spin_unlock(&rtc_lock); 286 287 /* Remap the kernel at virtual address zero, as well as offset zero 288 from the kernel segment. This assumes the kernel segment starts at 289 virtual address PAGE_OFFSET. */ 290 memcpy(swapper_pg_dir, swapper_pg_dir + KERNEL_PGD_BOUNDARY, 291 sizeof(swapper_pg_dir [0]) * KERNEL_PGD_PTRS); 292 293 /* 294 * Use `swapper_pg_dir' as our page directory. 295 */ 296 load_cr3(swapper_pg_dir); 297 298 /* Write 0x1234 to absolute memory location 0x472. The BIOS reads 299 this on booting to tell it to "Bypass memory test (also warm 300 boot)". This seems like a fairly standard thing that gets set by 301 REBOOT.COM programs, and the previous reset routine did this 302 too. */ 303 *((unsigned short *)0x472) = reboot_mode; 304 305 /* For the switch to real mode, copy some code to low memory. It has 306 to be in the first 64k because it is running in 16-bit mode, and it 307 has to have the same physical and virtual address, because it turns 308 off paging. Copy it near the end of the first page, out of the way 309 of BIOS variables. */ 310 memcpy((void *)(0x1000 - sizeof(real_mode_switch) - 100), 311 real_mode_switch, sizeof (real_mode_switch)); 312 memcpy((void *)(0x1000 - 100), code, length); 313 314 /* Set up the IDT for real mode. */ 315 load_idt(&real_mode_idt); 316 317 /* Set up a GDT from which we can load segment descriptors for real 318 mode. The GDT is not used in real mode; it is just needed here to 319 prepare the descriptors. */ 320 load_gdt(&real_mode_gdt); 321 322 /* Load the data segment registers, and thus the descriptors ready for 323 real mode. The base address of each segment is 0x100, 16 times the 324 selector value being loaded here. This is so that the segment 325 registers don't have to be reloaded after switching to real mode: 326 the values are consistent for real mode operation already. */ 327 __asm__ __volatile__ ("movl $0x0010,%%eax\n" 328 "\tmovl %%eax,%%ds\n" 329 "\tmovl %%eax,%%es\n" 330 "\tmovl %%eax,%%fs\n" 331 "\tmovl %%eax,%%gs\n" 332 "\tmovl %%eax,%%ss" : : : "eax"); 333 334 /* Jump to the 16-bit code that we copied earlier. It disables paging 335 and the cache, switches to real mode, and jumps to the BIOS reset 336 entry point. */ 337 __asm__ __volatile__ ("ljmp $0x0008,%0" 338 : 339 : "i" ((void *)(0x1000 - sizeof (real_mode_switch) - 100))); 340 } 341 #ifdef CONFIG_APM_MODULE 342 EXPORT_SYMBOL(machine_real_restart); 343 #endif 344 345 #endif /* CONFIG_X86_32 */ 346 347 static inline void kb_wait(void) 348 { 349 int i; 350 351 for (i = 0; i < 0x10000; i++) { 352 if ((inb(0x64) & 0x02) == 0) 353 break; 354 udelay(2); 355 } 356 } 357 358 void __attribute__((weak)) mach_reboot_fixups(void) 359 { 360 } 361 362 static void native_machine_emergency_restart(void) 363 { 364 int i; 365 366 /* Tell the BIOS if we want cold or warm reboot */ 367 *((unsigned short *)__va(0x472)) = reboot_mode; 368 369 for (;;) { 370 /* Could also try the reset bit in the Hammer NB */ 371 switch (reboot_type) { 372 case BOOT_KBD: 373 mach_reboot_fixups(); /* for board specific fixups */ 374 375 for (i = 0; i < 10; i++) { 376 kb_wait(); 377 udelay(50); 378 outb(0xfe, 0x64); /* pulse reset low */ 379 udelay(50); 380 } 381 382 case BOOT_TRIPLE: 383 load_idt(&no_idt); 384 __asm__ __volatile__("int3"); 385 386 reboot_type = BOOT_KBD; 387 break; 388 389 #ifdef CONFIG_X86_32 390 case BOOT_BIOS: 391 machine_real_restart(jump_to_bios, sizeof(jump_to_bios)); 392 393 reboot_type = BOOT_KBD; 394 break; 395 #endif 396 397 case BOOT_ACPI: 398 acpi_reboot(); 399 reboot_type = BOOT_KBD; 400 break; 401 402 403 case BOOT_EFI: 404 if (efi_enabled) 405 efi.reset_system(reboot_mode ? EFI_RESET_WARM : EFI_RESET_COLD, 406 EFI_SUCCESS, 0, NULL); 407 408 reboot_type = BOOT_KBD; 409 break; 410 } 411 } 412 } 413 414 void native_machine_shutdown(void) 415 { 416 /* Stop the cpus and apics */ 417 #ifdef CONFIG_SMP 418 419 /* The boot cpu is always logical cpu 0 */ 420 int reboot_cpu_id = 0; 421 422 #ifdef CONFIG_X86_32 423 /* See if there has been given a command line override */ 424 if ((reboot_cpu != -1) && (reboot_cpu < NR_CPUS) && 425 cpu_online(reboot_cpu)) 426 reboot_cpu_id = reboot_cpu; 427 #endif 428 429 /* Make certain the cpu I'm about to reboot on is online */ 430 if (!cpu_online(reboot_cpu_id)) 431 reboot_cpu_id = smp_processor_id(); 432 433 /* Make certain I only run on the appropriate processor */ 434 set_cpus_allowed_ptr(current, &cpumask_of_cpu(reboot_cpu_id)); 435 436 /* O.K Now that I'm on the appropriate processor, 437 * stop all of the others. 438 */ 439 smp_send_stop(); 440 #endif 441 442 lapic_shutdown(); 443 444 #ifdef CONFIG_X86_IO_APIC 445 disable_IO_APIC(); 446 #endif 447 448 #ifdef CONFIG_HPET_TIMER 449 hpet_disable(); 450 #endif 451 452 #ifdef CONFIG_X86_64 453 pci_iommu_shutdown(); 454 #endif 455 } 456 457 static void native_machine_restart(char *__unused) 458 { 459 printk("machine restart\n"); 460 461 if (!reboot_force) 462 machine_shutdown(); 463 machine_emergency_restart(); 464 } 465 466 static void native_machine_halt(void) 467 { 468 } 469 470 static void native_machine_power_off(void) 471 { 472 if (pm_power_off) { 473 if (!reboot_force) 474 machine_shutdown(); 475 pm_power_off(); 476 } 477 } 478 479 struct machine_ops machine_ops = { 480 .power_off = native_machine_power_off, 481 .shutdown = native_machine_shutdown, 482 .emergency_restart = native_machine_emergency_restart, 483 .restart = native_machine_restart, 484 .halt = native_machine_halt, 485 #ifdef CONFIG_KEXEC 486 .crash_shutdown = native_machine_crash_shutdown, 487 #endif 488 }; 489 490 void machine_power_off(void) 491 { 492 machine_ops.power_off(); 493 } 494 495 void machine_shutdown(void) 496 { 497 machine_ops.shutdown(); 498 } 499 500 void machine_emergency_restart(void) 501 { 502 machine_ops.emergency_restart(); 503 } 504 505 void machine_restart(char *cmd) 506 { 507 machine_ops.restart(cmd); 508 } 509 510 void machine_halt(void) 511 { 512 machine_ops.halt(); 513 } 514 515 #ifdef CONFIG_KEXEC 516 void machine_crash_shutdown(struct pt_regs *regs) 517 { 518 machine_ops.crash_shutdown(regs); 519 } 520 #endif 521