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 2400's */ 173 .callback = set_bios_reboot, 174 .ident = "Dell PowerEdge 2400", 175 .matches = { 176 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 177 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"), 178 }, 179 }, 180 { /* Handle problems with rebooting on Dell T5400's */ 181 .callback = set_bios_reboot, 182 .ident = "Dell Precision T5400", 183 .matches = { 184 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 185 DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T5400"), 186 }, 187 }, 188 { /* Handle problems with rebooting on HP laptops */ 189 .callback = set_bios_reboot, 190 .ident = "HP Compaq Laptop", 191 .matches = { 192 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 193 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"), 194 }, 195 }, 196 { } 197 }; 198 199 static int __init reboot_init(void) 200 { 201 dmi_check_system(reboot_dmi_table); 202 return 0; 203 } 204 core_initcall(reboot_init); 205 206 /* The following code and data reboots the machine by switching to real 207 mode and jumping to the BIOS reset entry point, as if the CPU has 208 really been reset. The previous version asked the keyboard 209 controller to pulse the CPU reset line, which is more thorough, but 210 doesn't work with at least one type of 486 motherboard. It is easy 211 to stop this code working; hence the copious comments. */ 212 static const unsigned long long 213 real_mode_gdt_entries [3] = 214 { 215 0x0000000000000000ULL, /* Null descriptor */ 216 0x00009b000000ffffULL, /* 16-bit real-mode 64k code at 0x00000000 */ 217 0x000093000100ffffULL /* 16-bit real-mode 64k data at 0x00000100 */ 218 }; 219 220 static const struct desc_ptr 221 real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, (long)real_mode_gdt_entries }, 222 real_mode_idt = { 0x3ff, 0 }; 223 224 /* This is 16-bit protected mode code to disable paging and the cache, 225 switch to real mode and jump to the BIOS reset code. 226 227 The instruction that switches to real mode by writing to CR0 must be 228 followed immediately by a far jump instruction, which set CS to a 229 valid value for real mode, and flushes the prefetch queue to avoid 230 running instructions that have already been decoded in protected 231 mode. 232 233 Clears all the flags except ET, especially PG (paging), PE 234 (protected-mode enable) and TS (task switch for coprocessor state 235 save). Flushes the TLB after paging has been disabled. Sets CD and 236 NW, to disable the cache on a 486, and invalidates the cache. This 237 is more like the state of a 486 after reset. I don't know if 238 something else should be done for other chips. 239 240 More could be done here to set up the registers as if a CPU reset had 241 occurred; hopefully real BIOSs don't assume much. */ 242 static const unsigned char real_mode_switch [] = 243 { 244 0x66, 0x0f, 0x20, 0xc0, /* movl %cr0,%eax */ 245 0x66, 0x83, 0xe0, 0x11, /* andl $0x00000011,%eax */ 246 0x66, 0x0d, 0x00, 0x00, 0x00, 0x60, /* orl $0x60000000,%eax */ 247 0x66, 0x0f, 0x22, 0xc0, /* movl %eax,%cr0 */ 248 0x66, 0x0f, 0x22, 0xd8, /* movl %eax,%cr3 */ 249 0x66, 0x0f, 0x20, 0xc3, /* movl %cr0,%ebx */ 250 0x66, 0x81, 0xe3, 0x00, 0x00, 0x00, 0x60, /* andl $0x60000000,%ebx */ 251 0x74, 0x02, /* jz f */ 252 0x0f, 0x09, /* wbinvd */ 253 0x24, 0x10, /* f: andb $0x10,al */ 254 0x66, 0x0f, 0x22, 0xc0 /* movl %eax,%cr0 */ 255 }; 256 static const unsigned char jump_to_bios [] = 257 { 258 0xea, 0x00, 0x00, 0xff, 0xff /* ljmp $0xffff,$0x0000 */ 259 }; 260 261 /* 262 * Switch to real mode and then execute the code 263 * specified by the code and length parameters. 264 * We assume that length will aways be less that 100! 265 */ 266 void machine_real_restart(const unsigned char *code, int length) 267 { 268 local_irq_disable(); 269 270 /* Write zero to CMOS register number 0x0f, which the BIOS POST 271 routine will recognize as telling it to do a proper reboot. (Well 272 that's what this book in front of me says -- it may only apply to 273 the Phoenix BIOS though, it's not clear). At the same time, 274 disable NMIs by setting the top bit in the CMOS address register, 275 as we're about to do peculiar things to the CPU. I'm not sure if 276 `outb_p' is needed instead of just `outb'. Use it to be on the 277 safe side. (Yes, CMOS_WRITE does outb_p's. - Paul G.) 278 */ 279 spin_lock(&rtc_lock); 280 CMOS_WRITE(0x00, 0x8f); 281 spin_unlock(&rtc_lock); 282 283 /* Remap the kernel at virtual address zero, as well as offset zero 284 from the kernel segment. This assumes the kernel segment starts at 285 virtual address PAGE_OFFSET. */ 286 memcpy(swapper_pg_dir, swapper_pg_dir + KERNEL_PGD_BOUNDARY, 287 sizeof(swapper_pg_dir [0]) * KERNEL_PGD_PTRS); 288 289 /* 290 * Use `swapper_pg_dir' as our page directory. 291 */ 292 load_cr3(swapper_pg_dir); 293 294 /* Write 0x1234 to absolute memory location 0x472. The BIOS reads 295 this on booting to tell it to "Bypass memory test (also warm 296 boot)". This seems like a fairly standard thing that gets set by 297 REBOOT.COM programs, and the previous reset routine did this 298 too. */ 299 *((unsigned short *)0x472) = reboot_mode; 300 301 /* For the switch to real mode, copy some code to low memory. It has 302 to be in the first 64k because it is running in 16-bit mode, and it 303 has to have the same physical and virtual address, because it turns 304 off paging. Copy it near the end of the first page, out of the way 305 of BIOS variables. */ 306 memcpy((void *)(0x1000 - sizeof(real_mode_switch) - 100), 307 real_mode_switch, sizeof (real_mode_switch)); 308 memcpy((void *)(0x1000 - 100), code, length); 309 310 /* Set up the IDT for real mode. */ 311 load_idt(&real_mode_idt); 312 313 /* Set up a GDT from which we can load segment descriptors for real 314 mode. The GDT is not used in real mode; it is just needed here to 315 prepare the descriptors. */ 316 load_gdt(&real_mode_gdt); 317 318 /* Load the data segment registers, and thus the descriptors ready for 319 real mode. The base address of each segment is 0x100, 16 times the 320 selector value being loaded here. This is so that the segment 321 registers don't have to be reloaded after switching to real mode: 322 the values are consistent for real mode operation already. */ 323 __asm__ __volatile__ ("movl $0x0010,%%eax\n" 324 "\tmovl %%eax,%%ds\n" 325 "\tmovl %%eax,%%es\n" 326 "\tmovl %%eax,%%fs\n" 327 "\tmovl %%eax,%%gs\n" 328 "\tmovl %%eax,%%ss" : : : "eax"); 329 330 /* Jump to the 16-bit code that we copied earlier. It disables paging 331 and the cache, switches to real mode, and jumps to the BIOS reset 332 entry point. */ 333 __asm__ __volatile__ ("ljmp $0x0008,%0" 334 : 335 : "i" ((void *)(0x1000 - sizeof (real_mode_switch) - 100))); 336 } 337 #ifdef CONFIG_APM_MODULE 338 EXPORT_SYMBOL(machine_real_restart); 339 #endif 340 341 #endif /* CONFIG_X86_32 */ 342 343 static inline void kb_wait(void) 344 { 345 int i; 346 347 for (i = 0; i < 0x10000; i++) { 348 if ((inb(0x64) & 0x02) == 0) 349 break; 350 udelay(2); 351 } 352 } 353 354 void __attribute__((weak)) mach_reboot_fixups(void) 355 { 356 } 357 358 static void native_machine_emergency_restart(void) 359 { 360 int i; 361 362 /* Tell the BIOS if we want cold or warm reboot */ 363 *((unsigned short *)__va(0x472)) = reboot_mode; 364 365 for (;;) { 366 /* Could also try the reset bit in the Hammer NB */ 367 switch (reboot_type) { 368 case BOOT_KBD: 369 mach_reboot_fixups(); /* for board specific fixups */ 370 371 for (i = 0; i < 10; i++) { 372 kb_wait(); 373 udelay(50); 374 outb(0xfe, 0x64); /* pulse reset low */ 375 udelay(50); 376 } 377 378 case BOOT_TRIPLE: 379 load_idt(&no_idt); 380 __asm__ __volatile__("int3"); 381 382 reboot_type = BOOT_KBD; 383 break; 384 385 #ifdef CONFIG_X86_32 386 case BOOT_BIOS: 387 machine_real_restart(jump_to_bios, sizeof(jump_to_bios)); 388 389 reboot_type = BOOT_KBD; 390 break; 391 #endif 392 393 case BOOT_ACPI: 394 acpi_reboot(); 395 reboot_type = BOOT_KBD; 396 break; 397 398 399 case BOOT_EFI: 400 if (efi_enabled) 401 efi.reset_system(reboot_mode ? EFI_RESET_WARM : EFI_RESET_COLD, 402 EFI_SUCCESS, 0, NULL); 403 404 reboot_type = BOOT_KBD; 405 break; 406 } 407 } 408 } 409 410 void native_machine_shutdown(void) 411 { 412 /* Stop the cpus and apics */ 413 #ifdef CONFIG_SMP 414 415 /* The boot cpu is always logical cpu 0 */ 416 int reboot_cpu_id = 0; 417 418 #ifdef CONFIG_X86_32 419 /* See if there has been given a command line override */ 420 if ((reboot_cpu != -1) && (reboot_cpu < NR_CPUS) && 421 cpu_online(reboot_cpu)) 422 reboot_cpu_id = reboot_cpu; 423 #endif 424 425 /* Make certain the cpu I'm about to reboot on is online */ 426 if (!cpu_online(reboot_cpu_id)) 427 reboot_cpu_id = smp_processor_id(); 428 429 /* Make certain I only run on the appropriate processor */ 430 set_cpus_allowed_ptr(current, &cpumask_of_cpu(reboot_cpu_id)); 431 432 /* O.K Now that I'm on the appropriate processor, 433 * stop all of the others. 434 */ 435 smp_send_stop(); 436 #endif 437 438 lapic_shutdown(); 439 440 #ifdef CONFIG_X86_IO_APIC 441 disable_IO_APIC(); 442 #endif 443 444 #ifdef CONFIG_HPET_TIMER 445 hpet_disable(); 446 #endif 447 448 #ifdef CONFIG_X86_64 449 pci_iommu_shutdown(); 450 #endif 451 } 452 453 static void native_machine_restart(char *__unused) 454 { 455 printk("machine restart\n"); 456 457 if (!reboot_force) 458 machine_shutdown(); 459 machine_emergency_restart(); 460 } 461 462 static void native_machine_halt(void) 463 { 464 } 465 466 static void native_machine_power_off(void) 467 { 468 if (pm_power_off) { 469 if (!reboot_force) 470 machine_shutdown(); 471 pm_power_off(); 472 } 473 } 474 475 struct machine_ops machine_ops = { 476 .power_off = native_machine_power_off, 477 .shutdown = native_machine_shutdown, 478 .emergency_restart = native_machine_emergency_restart, 479 .restart = native_machine_restart, 480 .halt = native_machine_halt, 481 #ifdef CONFIG_KEXEC 482 .crash_shutdown = native_machine_crash_shutdown, 483 #endif 484 }; 485 486 void machine_power_off(void) 487 { 488 machine_ops.power_off(); 489 } 490 491 void machine_shutdown(void) 492 { 493 machine_ops.shutdown(); 494 } 495 496 void machine_emergency_restart(void) 497 { 498 machine_ops.emergency_restart(); 499 } 500 501 void machine_restart(char *cmd) 502 { 503 machine_ops.restart(cmd); 504 } 505 506 void machine_halt(void) 507 { 508 machine_ops.halt(); 509 } 510 511 #ifdef CONFIG_KEXEC 512 void machine_crash_shutdown(struct pt_regs *regs) 513 { 514 machine_ops.crash_shutdown(regs); 515 } 516 #endif 517