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