1 #include <linux/module.h>
2 #include <linux/reboot.h>
3 #include <linux/init.h>
6 #include <linux/tboot.h>
7 #include <acpi/reboot.h>
12 #include <asm/pgtable.h>
13 #include <asm/proto.h>
14 #include <asm/reboot_fixups.h>
15 #include <asm/reboot.h>
16 #include <asm/pci_x86.h>
17 #include <asm/virtext.h>
21 # include <linux/dmi.h>
22 # include <linux/ctype.h>
23 # include <linux/mc146818rtc.h>
25 # include <asm/iommu.h>
29 * Power off function, if any
31 void (*pm_power_off)(void);
32 EXPORT_SYMBOL(pm_power_off);
34 static const struct desc_ptr no_idt = {};
35 static int reboot_mode;
36 enum reboot_type reboot_type = BOOT_KBD;
39 #if defined(CONFIG_X86_32) && defined(CONFIG_SMP)
40 static int reboot_cpu = -1;
43 /* This is set if we need to go through the 'emergency' path.
44 * When machine_emergency_restart() is called, we may be on
45 * an inconsistent state and won't be able to do a clean cleanup
47 static int reboot_emergency;
49 /* This is set by the PCI code if either type 1 or type 2 PCI is detected */
50 bool port_cf9_safe = false;
52 /* reboot=b[ios] | s[mp] | t[riple] | k[bd] | e[fi] [, [w]arm | [c]old] | p[ci]
53 warm Don't set the cold reboot flag
54 cold Set the cold reboot flag
55 bios Reboot by jumping through the BIOS (only for X86_32)
56 smp Reboot by executing reset on BSP or other CPU (only for X86_32)
57 triple Force a triple fault (init)
58 kbd Use the keyboard controller. cold reset (default)
59 acpi Use the RESET_REG in the FADT
60 efi Use efi reset_system runtime service
61 pci Use the so-called "PCI reset register", CF9
62 force Avoid anything that could hang.
64 static int __init reboot_setup(char *str)
79 if (isdigit(*(str+1))) {
80 reboot_cpu = (int) (*(str+1) - '0');
81 if (isdigit(*(str+2)))
82 reboot_cpu = reboot_cpu*10 + (int)(*(str+2) - '0');
84 /* we will leave sorting out the final value
85 when we are ready to reboot, since we might not
86 have set up boot_cpu_id or smp_num_cpu */
88 #endif /* CONFIG_SMP */
105 str = strchr(str, ',');
114 __setup("reboot=", reboot_setup);
119 * Reboot options and system auto-detection code provided by
120 * Dell Inc. so their systems "just work". :-)
124 * Some machines require the "reboot=b" commandline option,
125 * this quirk makes that automatic.
127 static int __init set_bios_reboot(const struct dmi_system_id *d)
129 if (reboot_type != BOOT_BIOS) {
130 reboot_type = BOOT_BIOS;
131 printk(KERN_INFO "%s series board detected. Selecting BIOS-method for reboots.\n", d->ident);
136 static struct dmi_system_id __initdata reboot_dmi_table[] = {
137 { /* Handle problems with rebooting on Dell E520's */
138 .callback = set_bios_reboot,
139 .ident = "Dell E520",
141 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
142 DMI_MATCH(DMI_PRODUCT_NAME, "Dell DM061"),
145 { /* Handle problems with rebooting on Dell 1300's */
146 .callback = set_bios_reboot,
147 .ident = "Dell PowerEdge 1300",
149 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
150 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1300/"),
153 { /* Handle problems with rebooting on Dell 300's */
154 .callback = set_bios_reboot,
155 .ident = "Dell PowerEdge 300",
157 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
158 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"),
161 { /* Handle problems with rebooting on Dell Optiplex 745's SFF*/
162 .callback = set_bios_reboot,
163 .ident = "Dell OptiPlex 745",
165 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
166 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
169 { /* Handle problems with rebooting on Dell Optiplex 745's DFF*/
170 .callback = set_bios_reboot,
171 .ident = "Dell OptiPlex 745",
173 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
174 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
175 DMI_MATCH(DMI_BOARD_NAME, "0MM599"),
178 { /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */
179 .callback = set_bios_reboot,
180 .ident = "Dell OptiPlex 745",
182 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
183 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
184 DMI_MATCH(DMI_BOARD_NAME, "0KW626"),
187 { /* Handle problems with rebooting on Dell Optiplex 330 with 0KP561 */
188 .callback = set_bios_reboot,
189 .ident = "Dell OptiPlex 330",
191 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
192 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 330"),
193 DMI_MATCH(DMI_BOARD_NAME, "0KP561"),
196 { /* Handle problems with rebooting on Dell Optiplex 360 with 0T656F */
197 .callback = set_bios_reboot,
198 .ident = "Dell OptiPlex 360",
200 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
201 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 360"),
202 DMI_MATCH(DMI_BOARD_NAME, "0T656F"),
205 { /* Handle problems with rebooting on Dell 2400's */
206 .callback = set_bios_reboot,
207 .ident = "Dell PowerEdge 2400",
209 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
210 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"),
213 { /* Handle problems with rebooting on Dell T5400's */
214 .callback = set_bios_reboot,
215 .ident = "Dell Precision T5400",
217 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
218 DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T5400"),
221 { /* Handle problems with rebooting on HP laptops */
222 .callback = set_bios_reboot,
223 .ident = "HP Compaq Laptop",
225 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
226 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"),
229 { /* Handle problems with rebooting on Dell XPS710 */
230 .callback = set_bios_reboot,
231 .ident = "Dell XPS710",
233 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
234 DMI_MATCH(DMI_PRODUCT_NAME, "Dell XPS710"),
237 { /* Handle problems with rebooting on Dell DXP061 */
238 .callback = set_bios_reboot,
239 .ident = "Dell DXP061",
241 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
242 DMI_MATCH(DMI_PRODUCT_NAME, "Dell DXP061"),
245 { /* Handle problems with rebooting on Sony VGN-Z540N */
246 .callback = set_bios_reboot,
247 .ident = "Sony VGN-Z540N",
249 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
250 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-Z540N"),
256 static int __init reboot_init(void)
258 dmi_check_system(reboot_dmi_table);
261 core_initcall(reboot_init);
263 /* The following code and data reboots the machine by switching to real
264 mode and jumping to the BIOS reset entry point, as if the CPU has
265 really been reset. The previous version asked the keyboard
266 controller to pulse the CPU reset line, which is more thorough, but
267 doesn't work with at least one type of 486 motherboard. It is easy
268 to stop this code working; hence the copious comments. */
269 static const unsigned long long
270 real_mode_gdt_entries [3] =
272 0x0000000000000000ULL, /* Null descriptor */
273 0x00009b000000ffffULL, /* 16-bit real-mode 64k code at 0x00000000 */
274 0x000093000100ffffULL /* 16-bit real-mode 64k data at 0x00000100 */
277 static const struct desc_ptr
278 real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, (long)real_mode_gdt_entries },
279 real_mode_idt = { 0x3ff, 0 };
281 /* This is 16-bit protected mode code to disable paging and the cache,
282 switch to real mode and jump to the BIOS reset code.
284 The instruction that switches to real mode by writing to CR0 must be
285 followed immediately by a far jump instruction, which set CS to a
286 valid value for real mode, and flushes the prefetch queue to avoid
287 running instructions that have already been decoded in protected
290 Clears all the flags except ET, especially PG (paging), PE
291 (protected-mode enable) and TS (task switch for coprocessor state
292 save). Flushes the TLB after paging has been disabled. Sets CD and
293 NW, to disable the cache on a 486, and invalidates the cache. This
294 is more like the state of a 486 after reset. I don't know if
295 something else should be done for other chips.
297 More could be done here to set up the registers as if a CPU reset had
298 occurred; hopefully real BIOSs don't assume much. */
299 static const unsigned char real_mode_switch [] =
301 0x66, 0x0f, 0x20, 0xc0, /* movl %cr0,%eax */
302 0x66, 0x83, 0xe0, 0x11, /* andl $0x00000011,%eax */
303 0x66, 0x0d, 0x00, 0x00, 0x00, 0x60, /* orl $0x60000000,%eax */
304 0x66, 0x0f, 0x22, 0xc0, /* movl %eax,%cr0 */
305 0x66, 0x0f, 0x22, 0xd8, /* movl %eax,%cr3 */
306 0x66, 0x0f, 0x20, 0xc3, /* movl %cr0,%ebx */
307 0x66, 0x81, 0xe3, 0x00, 0x00, 0x00, 0x60, /* andl $0x60000000,%ebx */
308 0x74, 0x02, /* jz f */
309 0x0f, 0x09, /* wbinvd */
310 0x24, 0x10, /* f: andb $0x10,al */
311 0x66, 0x0f, 0x22, 0xc0 /* movl %eax,%cr0 */
313 static const unsigned char jump_to_bios [] =
315 0xea, 0x00, 0x00, 0xff, 0xff /* ljmp $0xffff,$0x0000 */
319 * Switch to real mode and then execute the code
320 * specified by the code and length parameters.
321 * We assume that length will aways be less that 100!
323 void machine_real_restart(const unsigned char *code, int length)
327 /* Write zero to CMOS register number 0x0f, which the BIOS POST
328 routine will recognize as telling it to do a proper reboot. (Well
329 that's what this book in front of me says -- it may only apply to
330 the Phoenix BIOS though, it's not clear). At the same time,
331 disable NMIs by setting the top bit in the CMOS address register,
332 as we're about to do peculiar things to the CPU. I'm not sure if
333 `outb_p' is needed instead of just `outb'. Use it to be on the
334 safe side. (Yes, CMOS_WRITE does outb_p's. - Paul G.)
336 spin_lock(&rtc_lock);
337 CMOS_WRITE(0x00, 0x8f);
338 spin_unlock(&rtc_lock);
340 /* Remap the kernel at virtual address zero, as well as offset zero
341 from the kernel segment. This assumes the kernel segment starts at
342 virtual address PAGE_OFFSET. */
343 memcpy(swapper_pg_dir, swapper_pg_dir + KERNEL_PGD_BOUNDARY,
344 sizeof(swapper_pg_dir [0]) * KERNEL_PGD_PTRS);
347 * Use `swapper_pg_dir' as our page directory.
349 load_cr3(swapper_pg_dir);
351 /* Write 0x1234 to absolute memory location 0x472. The BIOS reads
352 this on booting to tell it to "Bypass memory test (also warm
353 boot)". This seems like a fairly standard thing that gets set by
354 REBOOT.COM programs, and the previous reset routine did this
356 *((unsigned short *)0x472) = reboot_mode;
358 /* For the switch to real mode, copy some code to low memory. It has
359 to be in the first 64k because it is running in 16-bit mode, and it
360 has to have the same physical and virtual address, because it turns
361 off paging. Copy it near the end of the first page, out of the way
362 of BIOS variables. */
363 memcpy((void *)(0x1000 - sizeof(real_mode_switch) - 100),
364 real_mode_switch, sizeof (real_mode_switch));
365 memcpy((void *)(0x1000 - 100), code, length);
367 /* Set up the IDT for real mode. */
368 load_idt(&real_mode_idt);
370 /* Set up a GDT from which we can load segment descriptors for real
371 mode. The GDT is not used in real mode; it is just needed here to
372 prepare the descriptors. */
373 load_gdt(&real_mode_gdt);
375 /* Load the data segment registers, and thus the descriptors ready for
376 real mode. The base address of each segment is 0x100, 16 times the
377 selector value being loaded here. This is so that the segment
378 registers don't have to be reloaded after switching to real mode:
379 the values are consistent for real mode operation already. */
380 __asm__ __volatile__ ("movl $0x0010,%%eax\n"
381 "\tmovl %%eax,%%ds\n"
382 "\tmovl %%eax,%%es\n"
383 "\tmovl %%eax,%%fs\n"
384 "\tmovl %%eax,%%gs\n"
385 "\tmovl %%eax,%%ss" : : : "eax");
387 /* Jump to the 16-bit code that we copied earlier. It disables paging
388 and the cache, switches to real mode, and jumps to the BIOS reset
390 __asm__ __volatile__ ("ljmp $0x0008,%0"
392 : "i" ((void *)(0x1000 - sizeof (real_mode_switch) - 100)));
394 #ifdef CONFIG_APM_MODULE
395 EXPORT_SYMBOL(machine_real_restart);
398 #endif /* CONFIG_X86_32 */
400 static inline void kb_wait(void)
404 for (i = 0; i < 0x10000; i++) {
405 if ((inb(0x64) & 0x02) == 0)
411 static void vmxoff_nmi(int cpu, struct die_args *args)
413 cpu_emergency_vmxoff();
416 /* Use NMIs as IPIs to tell all CPUs to disable virtualization
418 static void emergency_vmx_disable_all(void)
420 /* Just make sure we won't change CPUs while doing this */
423 /* We need to disable VMX on all CPUs before rebooting, otherwise
424 * we risk hanging up the machine, because the CPU ignore INIT
425 * signals when VMX is enabled.
427 * We can't take any locks and we may be on an inconsistent
428 * state, so we use NMIs as IPIs to tell the other CPUs to disable
431 * For safety, we will avoid running the nmi_shootdown_cpus()
432 * stuff unnecessarily, but we don't have a way to check
433 * if other CPUs have VMX enabled. So we will call it only if the
434 * CPU we are running on has VMX enabled.
436 * We will miss cases where VMX is not enabled on all CPUs. This
437 * shouldn't do much harm because KVM always enable VMX on all
438 * CPUs anyway. But we can miss it on the small window where KVM
439 * is still enabling VMX.
441 if (cpu_has_vmx() && cpu_vmx_enabled()) {
442 /* Disable VMX on this CPU.
446 /* Halt and disable VMX on the other CPUs */
447 nmi_shootdown_cpus(vmxoff_nmi);
453 void __attribute__((weak)) mach_reboot_fixups(void)
457 static void native_machine_emergency_restart(void)
461 if (reboot_emergency)
462 emergency_vmx_disable_all();
464 tboot_shutdown(TB_SHUTDOWN_REBOOT);
466 /* Tell the BIOS if we want cold or warm reboot */
467 *((unsigned short *)__va(0x472)) = reboot_mode;
470 /* Could also try the reset bit in the Hammer NB */
471 switch (reboot_type) {
473 mach_reboot_fixups(); /* for board specific fixups */
475 for (i = 0; i < 10; i++) {
478 outb(0xfe, 0x64); /* pulse reset low */
484 __asm__ __volatile__("int3");
486 reboot_type = BOOT_KBD;
491 machine_real_restart(jump_to_bios, sizeof(jump_to_bios));
493 reboot_type = BOOT_KBD;
499 reboot_type = BOOT_KBD;
504 efi.reset_system(reboot_mode ?
507 EFI_SUCCESS, 0, NULL);
508 reboot_type = BOOT_KBD;
512 port_cf9_safe = true;
517 u8 cf9 = inb(0xcf9) & ~6;
518 outb(cf9|2, 0xcf9); /* Request hard reset */
520 outb(cf9|6, 0xcf9); /* Actually do the reset */
523 reboot_type = BOOT_KBD;
529 void native_machine_shutdown(void)
531 /* Stop the cpus and apics */
534 /* The boot cpu is always logical cpu 0 */
535 int reboot_cpu_id = 0;
538 /* See if there has been given a command line override */
539 if ((reboot_cpu != -1) && (reboot_cpu < nr_cpu_ids) &&
540 cpu_online(reboot_cpu))
541 reboot_cpu_id = reboot_cpu;
544 /* Make certain the cpu I'm about to reboot on is online */
545 if (!cpu_online(reboot_cpu_id))
546 reboot_cpu_id = smp_processor_id();
548 /* Make certain I only run on the appropriate processor */
549 set_cpus_allowed_ptr(current, cpumask_of(reboot_cpu_id));
551 /* O.K Now that I'm on the appropriate processor,
552 * stop all of the others.
559 #ifdef CONFIG_X86_IO_APIC
563 #ifdef CONFIG_HPET_TIMER
568 pci_iommu_shutdown();
572 static void __machine_emergency_restart(int emergency)
574 reboot_emergency = emergency;
575 machine_ops.emergency_restart();
578 static void native_machine_restart(char *__unused)
580 printk("machine restart\n");
584 __machine_emergency_restart(0);
587 static void native_machine_halt(void)
589 /* stop other cpus and apics */
592 tboot_shutdown(TB_SHUTDOWN_HALT);
598 static void native_machine_power_off(void)
605 /* a fallback in case there is no PM info available */
606 tboot_shutdown(TB_SHUTDOWN_HALT);
609 struct machine_ops machine_ops = {
610 .power_off = native_machine_power_off,
611 .shutdown = native_machine_shutdown,
612 .emergency_restart = native_machine_emergency_restart,
613 .restart = native_machine_restart,
614 .halt = native_machine_halt,
616 .crash_shutdown = native_machine_crash_shutdown,
620 void machine_power_off(void)
622 machine_ops.power_off();
625 void machine_shutdown(void)
627 machine_ops.shutdown();
630 void machine_emergency_restart(void)
632 __machine_emergency_restart(1);
635 void machine_restart(char *cmd)
637 machine_ops.restart(cmd);
640 void machine_halt(void)
646 void machine_crash_shutdown(struct pt_regs *regs)
648 machine_ops.crash_shutdown(regs);
653 #if defined(CONFIG_SMP)
655 /* This keeps a track of which one is crashing cpu. */
656 static int crashing_cpu;
657 static nmi_shootdown_cb shootdown_callback;
659 static atomic_t waiting_for_crash_ipi;
661 static int crash_nmi_callback(struct notifier_block *self,
662 unsigned long val, void *data)
666 if (val != DIE_NMI_IPI)
669 cpu = raw_smp_processor_id();
671 /* Don't do anything if this handler is invoked on crashing cpu.
672 * Otherwise, system will completely hang. Crashing cpu can get
673 * an NMI if system was initially booted with nmi_watchdog parameter.
675 if (cpu == crashing_cpu)
679 shootdown_callback(cpu, (struct die_args *)data);
681 atomic_dec(&waiting_for_crash_ipi);
682 /* Assume hlt works */
690 static void smp_send_nmi_allbutself(void)
692 apic->send_IPI_allbutself(NMI_VECTOR);
695 static struct notifier_block crash_nmi_nb = {
696 .notifier_call = crash_nmi_callback,
699 /* Halt all other CPUs, calling the specified function on each of them
701 * This function can be used to halt all other CPUs on crash
702 * or emergency reboot time. The function passed as parameter
703 * will be called inside a NMI handler on all CPUs.
705 void nmi_shootdown_cpus(nmi_shootdown_cb callback)
710 /* Make a note of crashing cpu. Will be used in NMI callback.*/
711 crashing_cpu = safe_smp_processor_id();
713 shootdown_callback = callback;
715 atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
716 /* Would it be better to replace the trap vector here? */
717 if (register_die_notifier(&crash_nmi_nb))
718 return; /* return what? */
719 /* Ensure the new callback function is set before sending
724 smp_send_nmi_allbutself();
726 msecs = 1000; /* Wait at most a second for the other cpus to stop */
727 while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) {
732 /* Leave the nmi callback set */
734 #else /* !CONFIG_SMP */
735 void nmi_shootdown_cpus(nmi_shootdown_cb callback)
737 /* No other CPUs to shoot down */