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