Merge remote-tracking branch 'origin/dev/sumit-linux-3.10.96' into TOT-merge
[linux-3.10.git] / arch / x86 / kernel / reboot.c
index 2aef36d..5208e5a 100644 (file)
@@ -1,8 +1,14 @@
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/pm.h>
 #include <linux/efi.h>
+#include <linux/dmi.h>
+#include <linux/sched.h>
+#include <linux/tboot.h>
+#include <linux/delay.h>
 #include <acpi/reboot.h>
 #include <asm/io.h>
 #include <asm/apic.h>
 #include <asm/pci_x86.h>
 #include <asm/virtext.h>
 #include <asm/cpu.h>
+#include <asm/nmi.h>
+#include <asm/smp.h>
 
-#ifdef CONFIG_X86_32
-# include <linux/dmi.h>
-# include <linux/ctype.h>
-# include <linux/mc146818rtc.h>
-#else
-# include <asm/iommu.h>
-#endif
+#include <linux/ctype.h>
+#include <linux/mc146818rtc.h>
+#include <asm/realmode.h>
+#include <asm/x86_init.h>
 
 /*
  * Power off function, if any
@@ -31,15 +36,25 @@ void (*pm_power_off)(void);
 EXPORT_SYMBOL(pm_power_off);
 
 static const struct desc_ptr no_idt = {};
-static int reboot_mode;
-enum reboot_type reboot_type = BOOT_KBD;
+static enum reboot_mode reboot_mode;
+enum reboot_type reboot_type = BOOT_ACPI;
 int reboot_force;
 
-#if defined(CONFIG_X86_32) && defined(CONFIG_SMP)
+/*
+ * This variable is used privately to keep track of whether or not
+ * reboot_type is still set to its default value (i.e., reboot= hasn't
+ * been set on the command line).  This is needed so that we can
+ * suppress DMI scanning for reboot quirks.  Without it, it's
+ * impossible to override a faulty reboot quirk without recompiling.
+ */
+static int reboot_default = 1;
+
+#ifdef CONFIG_SMP
 static int reboot_cpu = -1;
 #endif
 
-/* This is set if we need to go through the 'emergency' path.
+/*
+ * This is set if we need to go through the 'emergency' path.
  * When machine_emergency_restart() is called, we may be on
  * an inconsistent state and won't be able to do a clean cleanup
  */
@@ -48,31 +63,38 @@ static int reboot_emergency;
 /* This is set by the PCI code if either type 1 or type 2 PCI is detected */
 bool port_cf9_safe = false;
 
-/* reboot=b[ios] | s[mp] | t[riple] | k[bd] | e[fi] [, [w]arm | [c]old] | p[ci]
-   warm   Don't set the cold reboot flag
-   cold   Set the cold reboot flag
-   bios   Reboot by jumping through the BIOS (only for X86_32)
-   smp    Reboot by executing reset on BSP or other CPU (only for X86_32)
-   triple Force a triple fault (init)
-   kbd    Use the keyboard controller. cold reset (default)
-   acpi   Use the RESET_REG in the FADT
-   efi    Use efi reset_system runtime service
-   pci    Use the so-called "PCI reset register", CF9
-   force  Avoid anything that could hang.
+/*
+ * reboot=b[ios] | s[mp] | t[riple] | k[bd] | e[fi] [, [w]arm | [c]old] | p[ci]
+ * warm   Don't set the cold reboot flag
+ * cold   Set the cold reboot flag
+ * bios   Reboot by jumping through the BIOS
+ * smp    Reboot by executing reset on BSP or other CPU
+ * triple Force a triple fault (init)
+ * kbd    Use the keyboard controller. cold reset (default)
+ * acpi   Use the RESET_REG in the FADT
+ * efi    Use efi reset_system runtime service
+ * pci    Use the so-called "PCI reset register", CF9
+ * force  Avoid anything that could hang.
  */
 static int __init reboot_setup(char *str)
 {
        for (;;) {
+               /*
+                * Having anything passed on the command line via
+                * reboot= will cause us to disable DMI checking
+                * below.
+                */
+               reboot_default = 0;
+
                switch (*str) {
                case 'w':
-                       reboot_mode = 0x1234;
+                       reboot_mode = REBOOT_WARM;
                        break;
 
                case 'c':
-                       reboot_mode = 0;
+                       reboot_mode = REBOOT_COLD;
                        break;
 
-#ifdef CONFIG_X86_32
 #ifdef CONFIG_SMP
                case 's':
                        if (isdigit(*(str+1))) {
@@ -80,14 +102,15 @@ static int __init reboot_setup(char *str)
                                if (isdigit(*(str+2)))
                                        reboot_cpu = reboot_cpu*10 + (int)(*(str+2) - '0');
                        }
-                               /* we will leave sorting out the final value
-                                  when we are ready to reboot, since we might not
-                                  have set up boot_cpu_id or smp_num_cpu */
+                       /*
+                        * We will leave sorting out the final value
+                        * when we are ready to reboot, since we might not
+                        * have detected BSP APIC ID or smp_num_cpu
+                        */
                        break;
 #endif /* CONFIG_SMP */
 
                case 'b':
-#endif
                case 'a':
                case 'k':
                case 't':
@@ -113,25 +136,94 @@ static int __init reboot_setup(char *str)
 __setup("reboot=", reboot_setup);
 
 
-#ifdef CONFIG_X86_32
 /*
  * Reboot options and system auto-detection code provided by
  * Dell Inc. so their systems "just work". :-)
  */
 
 /*
- * Some machines require the "reboot=b"  commandline option,
+ * Some machines require the "reboot=b" or "reboot=k"  commandline options,
  * this quirk makes that automatic.
  */
 static int __init set_bios_reboot(const struct dmi_system_id *d)
 {
        if (reboot_type != BOOT_BIOS) {
                reboot_type = BOOT_BIOS;
-               printk(KERN_INFO "%s series board detected. Selecting BIOS-method for reboots.\n", d->ident);
+               pr_info("%s series board detected. Selecting %s-method for reboots.\n",
+                       "BIOS", d->ident);
+       }
+       return 0;
+}
+
+void __noreturn machine_real_restart(unsigned int type)
+{
+       local_irq_disable();
+
+       /*
+        * Write zero to CMOS register number 0x0f, which the BIOS POST
+        * routine will recognize as telling it to do a proper reboot.  (Well
+        * that's what this book in front of me says -- it may only apply to
+        * the Phoenix BIOS though, it's not clear).  At the same time,
+        * disable NMIs by setting the top bit in the CMOS address register,
+        * as we're about to do peculiar things to the CPU.  I'm not sure if
+        * `outb_p' is needed instead of just `outb'.  Use it to be on the
+        * safe side.  (Yes, CMOS_WRITE does outb_p's. -  Paul G.)
+        */
+       spin_lock(&rtc_lock);
+       CMOS_WRITE(0x00, 0x8f);
+       spin_unlock(&rtc_lock);
+
+       /*
+        * Switch back to the initial page table.
+        */
+#ifdef CONFIG_X86_32
+       load_cr3(initial_page_table);
+#else
+       write_cr3(real_mode_header->trampoline_pgd);
+#endif
+
+       /* Jump to the identity-mapped low memory code */
+#ifdef CONFIG_X86_32
+       asm volatile("jmpl *%0" : :
+                    "rm" (real_mode_header->machine_real_restart_asm),
+                    "a" (type));
+#else
+       asm volatile("ljmpl *%0" : :
+                    "m" (real_mode_header->machine_real_restart_asm),
+                    "D" (type));
+#endif
+       unreachable();
+}
+#ifdef CONFIG_APM_MODULE
+EXPORT_SYMBOL(machine_real_restart);
+#endif
+
+/*
+ * Some Apple MacBook and MacBookPro's needs reboot=p to be able to reboot
+ */
+static int __init set_pci_reboot(const struct dmi_system_id *d)
+{
+       if (reboot_type != BOOT_CF9) {
+               reboot_type = BOOT_CF9;
+               pr_info("%s series board detected. Selecting %s-method for reboots.\n",
+                       "PCI", d->ident);
+       }
+       return 0;
+}
+
+static int __init set_kbd_reboot(const struct dmi_system_id *d)
+{
+       if (reboot_type != BOOT_KBD) {
+               reboot_type = BOOT_KBD;
+               pr_info("%s series board detected. Selecting %s-method for reboot.\n",
+                       "KBD", d->ident);
        }
        return 0;
 }
 
+/*
+ * This is a single dmi_table handling all reboot quirks.
+ */
 static struct dmi_system_id __initdata reboot_dmi_table[] = {
        {       /* Handle problems with rebooting on Dell E520's */
                .callback = set_bios_reboot,
@@ -157,7 +249,7 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"),
                },
        },
-       {       /* Handle problems with rebooting on Dell Optiplex 745's SFF*/
+       {       /* Handle problems with rebooting on Dell Optiplex 745's SFF */
                .callback = set_bios_reboot,
                .ident = "Dell OptiPlex 745",
                .matches = {
@@ -165,7 +257,7 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
                },
        },
-       {       /* Handle problems with rebooting on Dell Optiplex 745's DFF*/
+       {       /* Handle problems with rebooting on Dell Optiplex 745's DFF */
                .callback = set_bios_reboot,
                .ident = "Dell OptiPlex 745",
                .matches = {
@@ -174,7 +266,7 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
                        DMI_MATCH(DMI_BOARD_NAME, "0MM599"),
                },
        },
-       {       /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */
+       {       /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */
                .callback = set_bios_reboot,
                .ident = "Dell OptiPlex 745",
                .matches = {
@@ -183,7 +275,7 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
                        DMI_MATCH(DMI_BOARD_NAME, "0KW626"),
                },
        },
-       {   /* Handle problems with rebooting on Dell Optiplex 330 with 0KP561 */
+       {       /* Handle problems with rebooting on Dell Optiplex 330 with 0KP561 */
                .callback = set_bios_reboot,
                .ident = "Dell OptiPlex 330",
                .matches = {
@@ -192,6 +284,24 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
                        DMI_MATCH(DMI_BOARD_NAME, "0KP561"),
                },
        },
+       {       /* Handle problems with rebooting on Dell Optiplex 360 with 0T656F */
+               .callback = set_bios_reboot,
+               .ident = "Dell OptiPlex 360",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 360"),
+                       DMI_MATCH(DMI_BOARD_NAME, "0T656F"),
+               },
+       },
+       {       /* Handle problems with rebooting on Dell OptiPlex 760 with 0G919G */
+               .callback = set_bios_reboot,
+               .ident = "Dell OptiPlex 760",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 760"),
+                       DMI_MATCH(DMI_BOARD_NAME, "0G919G"),
+               },
+       },
        {       /* Handle problems with rebooting on Dell 2400's */
                .callback = set_bios_reboot,
                .ident = "Dell PowerEdge 2400",
@@ -208,6 +318,14 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T5400"),
                },
        },
+       {       /* Handle problems with rebooting on Dell T7400's */
+               .callback = set_bios_reboot,
+               .ident = "Dell Precision T7400",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T7400"),
+               },
+       },
        {       /* Handle problems with rebooting on HP laptops */
                .callback = set_bios_reboot,
                .ident = "HP Compaq Laptop",
@@ -224,152 +342,149 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "Dell XPS710"),
                },
        },
+       {       /* Handle problems with rebooting on Dell DXP061 */
+               .callback = set_bios_reboot,
+               .ident = "Dell DXP061",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "Dell DXP061"),
+               },
+       },
+       {       /* Handle problems with rebooting on Sony VGN-Z540N */
+               .callback = set_bios_reboot,
+               .ident = "Sony VGN-Z540N",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "VGN-Z540N"),
+               },
+       },
+       {       /* Handle problems with rebooting on ASUS P4S800 */
+               .callback = set_bios_reboot,
+               .ident = "ASUS P4S800",
+               .matches = {
+                       DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
+                       DMI_MATCH(DMI_BOARD_NAME, "P4S800"),
+               },
+       },
+       {       /* Handle problems with rebooting on the iMac10,1. */
+               .callback = set_pci_reboot,
+               .ident = "Apple iMac10,1",
+               .matches = {
+                   DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                   DMI_MATCH(DMI_PRODUCT_NAME, "iMac10,1"),
+               },
+       },
+
+       {       /* Handle reboot issue on Acer Aspire one */
+               .callback = set_kbd_reboot,
+               .ident = "Acer Aspire One A110",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"),
+               },
+       },
+       {       /* Handle problems with rebooting on Apple MacBook5 */
+               .callback = set_pci_reboot,
+               .ident = "Apple MacBook5",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "MacBook5"),
+               },
+       },
+       {       /* Handle problems with rebooting on Apple MacBookPro5 */
+               .callback = set_pci_reboot,
+               .ident = "Apple MacBookPro5",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5"),
+               },
+       },
+       {       /* Handle problems with rebooting on Apple Macmini3,1 */
+               .callback = set_pci_reboot,
+               .ident = "Apple Macmini3,1",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "Macmini3,1"),
+               },
+       },
+       {       /* Handle problems with rebooting on the iMac9,1. */
+               .callback = set_pci_reboot,
+               .ident = "Apple iMac9,1",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "iMac9,1"),
+               },
+       },
+       {       /* Handle problems with rebooting on the Latitude E6320. */
+               .callback = set_pci_reboot,
+               .ident = "Dell Latitude E6320",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6320"),
+               },
+       },
+       {       /* Handle problems with rebooting on the Latitude E5420. */
+               .callback = set_pci_reboot,
+               .ident = "Dell Latitude E5420",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E5420"),
+               },
+       },
+       {       /* Handle problems with rebooting on the Latitude E6420. */
+               .callback = set_pci_reboot,
+               .ident = "Dell Latitude E6420",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6420"),
+               },
+       },
+       {       /* Handle problems with rebooting on the OptiPlex 990. */
+               .callback = set_pci_reboot,
+               .ident = "Dell OptiPlex 990",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 990"),
+               },
+       },
+       {       /* Handle problems with rebooting on the Precision M6600. */
+               .callback = set_pci_reboot,
+               .ident = "Dell OptiPlex 990",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "Precision M6600"),
+               },
+       },
+       {       /* Handle problems with rebooting on the Dell PowerEdge C6100. */
+               .callback = set_pci_reboot,
+               .ident = "Dell PowerEdge C6100",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "C6100"),
+               },
+       },
+       {       /* Some C6100 machines were shipped with vendor being 'Dell'. */
+               .callback = set_pci_reboot,
+               .ident = "Dell PowerEdge C6100",
+               .matches = {
+                       DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
+                       DMI_MATCH(DMI_PRODUCT_NAME, "C6100"),
+               },
+       },
        { }
 };
 
 static int __init reboot_init(void)
 {
-       dmi_check_system(reboot_dmi_table);
-       return 0;
-}
-core_initcall(reboot_init);
-
-/* The following code and data reboots the machine by switching to real
-   mode and jumping to the BIOS reset entry point, as if the CPU has
-   really been reset.  The previous version asked the keyboard
-   controller to pulse the CPU reset line, which is more thorough, but
-   doesn't work with at least one type of 486 motherboard.  It is easy
-   to stop this code working; hence the copious comments. */
-static const unsigned long long
-real_mode_gdt_entries [3] =
-{
-       0x0000000000000000ULL,  /* Null descriptor */
-       0x00009b000000ffffULL,  /* 16-bit real-mode 64k code at 0x00000000 */
-       0x000093000100ffffULL   /* 16-bit real-mode 64k data at 0x00000100 */
-};
-
-static const struct desc_ptr
-real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, (long)real_mode_gdt_entries },
-real_mode_idt = { 0x3ff, 0 };
-
-/* This is 16-bit protected mode code to disable paging and the cache,
-   switch to real mode and jump to the BIOS reset code.
-
-   The instruction that switches to real mode by writing to CR0 must be
-   followed immediately by a far jump instruction, which set CS to a
-   valid value for real mode, and flushes the prefetch queue to avoid
-   running instructions that have already been decoded in protected
-   mode.
-
-   Clears all the flags except ET, especially PG (paging), PE
-   (protected-mode enable) and TS (task switch for coprocessor state
-   save).  Flushes the TLB after paging has been disabled.  Sets CD and
-   NW, to disable the cache on a 486, and invalidates the cache.  This
-   is more like the state of a 486 after reset.  I don't know if
-   something else should be done for other chips.
-
-   More could be done here to set up the registers as if a CPU reset had
-   occurred; hopefully real BIOSs don't assume much. */
-static const unsigned char real_mode_switch [] =
-{
-       0x66, 0x0f, 0x20, 0xc0,                 /*    movl  %cr0,%eax        */
-       0x66, 0x83, 0xe0, 0x11,                 /*    andl  $0x00000011,%eax */
-       0x66, 0x0d, 0x00, 0x00, 0x00, 0x60,     /*    orl   $0x60000000,%eax */
-       0x66, 0x0f, 0x22, 0xc0,                 /*    movl  %eax,%cr0        */
-       0x66, 0x0f, 0x22, 0xd8,                 /*    movl  %eax,%cr3        */
-       0x66, 0x0f, 0x20, 0xc3,                 /*    movl  %cr0,%ebx        */
-       0x66, 0x81, 0xe3, 0x00, 0x00, 0x00, 0x60,       /*    andl  $0x60000000,%ebx */
-       0x74, 0x02,                             /*    jz    f                */
-       0x0f, 0x09,                             /*    wbinvd                 */
-       0x24, 0x10,                             /* f: andb  $0x10,al         */
-       0x66, 0x0f, 0x22, 0xc0                  /*    movl  %eax,%cr0        */
-};
-static const unsigned char jump_to_bios [] =
-{
-       0xea, 0x00, 0x00, 0xff, 0xff            /*    ljmp  $0xffff,$0x0000  */
-};
-
-/*
- * Switch to real mode and then execute the code
- * specified by the code and length parameters.
- * We assume that length will aways be less that 100!
- */
-void machine_real_restart(const unsigned char *code, int length)
-{
-       local_irq_disable();
-
-       /* Write zero to CMOS register number 0x0f, which the BIOS POST
-          routine will recognize as telling it to do a proper reboot.  (Well
-          that's what this book in front of me says -- it may only apply to
-          the Phoenix BIOS though, it's not clear).  At the same time,
-          disable NMIs by setting the top bit in the CMOS address register,
-          as we're about to do peculiar things to the CPU.  I'm not sure if
-          `outb_p' is needed instead of just `outb'.  Use it to be on the
-          safe side.  (Yes, CMOS_WRITE does outb_p's. -  Paul G.)
-        */
-       spin_lock(&rtc_lock);
-       CMOS_WRITE(0x00, 0x8f);
-       spin_unlock(&rtc_lock);
-
-       /* Remap the kernel at virtual address zero, as well as offset zero
-          from the kernel segment.  This assumes the kernel segment starts at
-          virtual address PAGE_OFFSET. */
-       memcpy(swapper_pg_dir, swapper_pg_dir + KERNEL_PGD_BOUNDARY,
-               sizeof(swapper_pg_dir [0]) * KERNEL_PGD_PTRS);
-
        /*
-        * Use `swapper_pg_dir' as our page directory.
+        * Only do the DMI check if reboot_type hasn't been overridden
+        * on the command line
         */
-       load_cr3(swapper_pg_dir);
-
-       /* Write 0x1234 to absolute memory location 0x472.  The BIOS reads
-          this on booting to tell it to "Bypass memory test (also warm
-          boot)".  This seems like a fairly standard thing that gets set by
-          REBOOT.COM programs, and the previous reset routine did this
-          too. */
-       *((unsigned short *)0x472) = reboot_mode;
-
-       /* For the switch to real mode, copy some code to low memory.  It has
-          to be in the first 64k because it is running in 16-bit mode, and it
-          has to have the same physical and virtual address, because it turns
-          off paging.  Copy it near the end of the first page, out of the way
-          of BIOS variables. */
-       memcpy((void *)(0x1000 - sizeof(real_mode_switch) - 100),
-               real_mode_switch, sizeof (real_mode_switch));
-       memcpy((void *)(0x1000 - 100), code, length);
-
-       /* Set up the IDT for real mode. */
-       load_idt(&real_mode_idt);
-
-       /* Set up a GDT from which we can load segment descriptors for real
-          mode.  The GDT is not used in real mode; it is just needed here to
-          prepare the descriptors. */
-       load_gdt(&real_mode_gdt);
-
-       /* Load the data segment registers, and thus the descriptors ready for
-          real mode.  The base address of each segment is 0x100, 16 times the
-          selector value being loaded here.  This is so that the segment
-          registers don't have to be reloaded after switching to real mode:
-          the values are consistent for real mode operation already. */
-       __asm__ __volatile__ ("movl $0x0010,%%eax\n"
-                               "\tmovl %%eax,%%ds\n"
-                               "\tmovl %%eax,%%es\n"
-                               "\tmovl %%eax,%%fs\n"
-                               "\tmovl %%eax,%%gs\n"
-                               "\tmovl %%eax,%%ss" : : : "eax");
-
-       /* Jump to the 16-bit code that we copied earlier.  It disables paging
-          and the cache, switches to real mode, and jumps to the BIOS reset
-          entry point. */
-       __asm__ __volatile__ ("ljmp $0x0008,%0"
-                               :
-                               : "i" ((void *)(0x1000 - sizeof (real_mode_switch) - 100)));
+       if (reboot_default)
+               dmi_check_system(reboot_dmi_table);
+       return 0;
 }
-#ifdef CONFIG_APM_MODULE
-EXPORT_SYMBOL(machine_real_restart);
-#endif
-
-#endif /* CONFIG_X86_32 */
+core_initcall(reboot_init);
 
 static inline void kb_wait(void)
 {
@@ -382,19 +497,19 @@ static inline void kb_wait(void)
        }
 }
 
-static void vmxoff_nmi(int cpu, struct die_args *args)
+static void vmxoff_nmi(int cpu, struct pt_regs *regs)
 {
        cpu_emergency_vmxoff();
 }
 
-/* Use NMIs as IPIs to tell all CPUs to disable virtualization
- */
+/* Use NMIs as IPIs to tell all CPUs to disable virtualization */
 static void emergency_vmx_disable_all(void)
 {
        /* Just make sure we won't change CPUs while doing this */
        local_irq_disable();
 
-       /* We need to disable VMX on all CPUs before rebooting, otherwise
+       /*
+        * We need to disable VMX on all CPUs before rebooting, otherwise
         * we risk hanging up the machine, because the CPU ignore INIT
         * signals when VMX is enabled.
         *
@@ -413,8 +528,7 @@ static void emergency_vmx_disable_all(void)
         * is still enabling VMX.
         */
        if (cpu_has_vmx() && cpu_vmx_enabled()) {
-               /* Disable VMX on this CPU.
-                */
+               /* Disable VMX on this CPU. */
                cpu_vmxoff();
 
                /* Halt and disable VMX on the other CPUs */
@@ -428,28 +542,54 @@ void __attribute__((weak)) mach_reboot_fixups(void)
 {
 }
 
+/*
+ * Windows compatible x86 hardware expects the following on reboot:
+ *
+ * 1) If the FADT has the ACPI reboot register flag set, try it
+ * 2) If still alive, write to the keyboard controller
+ * 3) If still alive, write to the ACPI reboot register again
+ * 4) If still alive, write to the keyboard controller again
+ *
+ * If the machine is still alive at this stage, it gives up. We default to
+ * following the same pattern, except that if we're still alive after (4) we'll
+ * try to force a triple fault and then cycle between hitting the keyboard
+ * controller and doing that
+ */
 static void native_machine_emergency_restart(void)
 {
        int i;
+       int attempt = 0;
+       int orig_reboot_type = reboot_type;
+       unsigned short mode;
 
        if (reboot_emergency)
                emergency_vmx_disable_all();
 
+       tboot_shutdown(TB_SHUTDOWN_REBOOT);
+
        /* Tell the BIOS if we want cold or warm reboot */
-       *((unsigned short *)__va(0x472)) = reboot_mode;
+       mode = reboot_mode == REBOOT_WARM ? 0x1234 : 0;
+       *((unsigned short *)__va(0x472)) = mode;
 
        for (;;) {
                /* Could also try the reset bit in the Hammer NB */
                switch (reboot_type) {
                case BOOT_KBD:
-                       mach_reboot_fixups(); /* for board specific fixups */
+                       mach_reboot_fixups(); /* For board specific fixups */
 
                        for (i = 0; i < 10; i++) {
                                kb_wait();
                                udelay(50);
-                               outb(0xfe, 0x64); /* pulse reset low */
+                               outb(0xfe, 0x64); /* Pulse reset low */
                                udelay(50);
                        }
+                       if (attempt == 0 && orig_reboot_type == BOOT_ACPI) {
+                               attempt = 1;
+                               reboot_type = BOOT_ACPI;
+                       } else {
+                               reboot_type = BOOT_TRIPLE;
+                       }
+                       break;
 
                case BOOT_TRIPLE:
                        load_idt(&no_idt);
@@ -458,13 +598,11 @@ static void native_machine_emergency_restart(void)
                        reboot_type = BOOT_KBD;
                        break;
 
-#ifdef CONFIG_X86_32
                case BOOT_BIOS:
-                       machine_real_restart(jump_to_bios, sizeof(jump_to_bios));
+                       machine_real_restart(MRR_BIOS);
 
                        reboot_type = BOOT_KBD;
                        break;
-#endif
 
                case BOOT_ACPI:
                        acpi_reboot();
@@ -472,8 +610,8 @@ static void native_machine_emergency_restart(void)
                        break;
 
                case BOOT_EFI:
-                       if (efi_enabled)
-                               efi.reset_system(reboot_mode ?
+                       if (efi_enabled(EFI_RUNTIME_SERVICES))
+                               efi.reset_system(reboot_mode == REBOOT_WARM ?
                                                 EFI_RESET_WARM :
                                                 EFI_RESET_COLD,
                                                 EFI_SUCCESS, 0, NULL);
@@ -482,7 +620,7 @@ static void native_machine_emergency_restart(void)
 
                case BOOT_CF9:
                        port_cf9_safe = true;
-                       /* fall through */
+                       /* Fall through */
 
                case BOOT_CF9_COND:
                        if (port_cf9_safe) {
@@ -502,28 +640,13 @@ void native_machine_shutdown(void)
 {
        /* Stop the cpus and apics */
 #ifdef CONFIG_SMP
-
-       /* The boot cpu is always logical cpu 0 */
-       int reboot_cpu_id = 0;
-
-#ifdef CONFIG_X86_32
-       /* See if there has been given a command line override */
-       if ((reboot_cpu != -1) && (reboot_cpu < nr_cpu_ids) &&
-               cpu_online(reboot_cpu))
-               reboot_cpu_id = reboot_cpu;
-#endif
-
-       /* Make certain the cpu I'm about to reboot on is online */
-       if (!cpu_online(reboot_cpu_id))
-               reboot_cpu_id = smp_processor_id();
-
-       /* Make certain I only run on the appropriate processor */
-       set_cpus_allowed_ptr(current, cpumask_of(reboot_cpu_id));
-
-       /* O.K Now that I'm on the appropriate processor,
-        * stop all of the others.
+       /*
+        * Stop all of the others. Also disable the local irq to
+        * not receive the per-cpu timer interrupt which may trigger
+        * scheduler's load balance.
         */
-       smp_send_stop();
+       local_irq_disable();
+       stop_other_cpus();
 #endif
 
        lapic_shutdown();
@@ -537,7 +660,7 @@ void native_machine_shutdown(void)
 #endif
 
 #ifdef CONFIG_X86_64
-       pci_iommu_shutdown();
+       x86_platform.iommu_shutdown();
 #endif
 }
 
@@ -549,7 +672,7 @@ static void __machine_emergency_restart(int emergency)
 
 static void native_machine_restart(char *__unused)
 {
-       printk("machine restart\n");
+       pr_notice("machine restart\n");
 
        if (!reboot_force)
                machine_shutdown();
@@ -558,10 +681,11 @@ static void native_machine_restart(char *__unused)
 
 static void native_machine_halt(void)
 {
-       /* stop other cpus and apics */
+       /* Stop other cpus and apics */
        machine_shutdown();
 
-       /* stop this cpu */
+       tboot_shutdown(TB_SHUTDOWN_HALT);
+
        stop_this_cpu(NULL);
 }
 
@@ -572,6 +696,8 @@ static void native_machine_power_off(void)
                        machine_shutdown();
                pm_power_off();
        }
+       /* A fallback in case there is no PM info available */
+       tboot_shutdown(TB_SHUTDOWN_HALT);
 }
 
 struct machine_ops machine_ops = {
@@ -626,25 +752,22 @@ static nmi_shootdown_cb shootdown_callback;
 
 static atomic_t waiting_for_crash_ipi;
 
-static int crash_nmi_callback(struct notifier_block *self,
-                       unsigned long val, void *data)
+static int crash_nmi_callback(unsigned int val, struct pt_regs *regs)
 {
        int cpu;
 
-       if (val != DIE_NMI_IPI)
-               return NOTIFY_OK;
-
        cpu = raw_smp_processor_id();
 
-       /* Don't do anything if this handler is invoked on crashing cpu.
+       /*
+        * Don't do anything if this handler is invoked on crashing cpu.
         * Otherwise, system will completely hang. Crashing cpu can get
         * an NMI if system was initially booted with nmi_watchdog parameter.
         */
        if (cpu == crashing_cpu)
-               return NOTIFY_STOP;
+               return NMI_HANDLED;
        local_irq_disable();
 
-       shootdown_callback(cpu, (struct die_args *)data);
+       shootdown_callback(cpu, regs);
 
        atomic_dec(&waiting_for_crash_ipi);
        /* Assume hlt works */
@@ -652,7 +775,7 @@ static int crash_nmi_callback(struct notifier_block *self,
        for (;;)
                cpu_relax();
 
-       return 1;
+       return NMI_HANDLED;
 }
 
 static void smp_send_nmi_allbutself(void)
@@ -660,11 +783,8 @@ static void smp_send_nmi_allbutself(void)
        apic->send_IPI_allbutself(NMI_VECTOR);
 }
 
-static struct notifier_block crash_nmi_nb = {
-       .notifier_call = crash_nmi_callback,
-};
-
-/* Halt all other CPUs, calling the specified function on each of them
+/*
+ * Halt all other CPUs, calling the specified function on each of them
  *
  * This function can be used to halt all other CPUs on crash
  * or emergency reboot time. The function passed as parameter
@@ -675,16 +795,18 @@ void nmi_shootdown_cpus(nmi_shootdown_cb callback)
        unsigned long msecs;
        local_irq_disable();
 
-       /* Make a note of crashing cpu. Will be used in NMI callback.*/
+       /* Make a note of crashing cpu. Will be used in NMI callback. */
        crashing_cpu = safe_smp_processor_id();
 
        shootdown_callback = callback;
 
        atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
        /* Would it be better to replace the trap vector here? */
-       if (register_die_notifier(&crash_nmi_nb))
-               return;         /* return what? */
-       /* Ensure the new callback function is set before sending
+       if (register_nmi_handler(NMI_LOCAL, crash_nmi_callback,
+                                NMI_FLAG_FIRST, "crash"))
+               return;         /* Return what? */
+       /*
+        * Ensure the new callback function is set before sending
         * out the NMI
         */
        wmb();