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