arch/x86/kernel/reboot.c

   1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   2
   3 #include <linux/module.h>
   4 #include <linux/reboot.h>
   5 #include <linux/init.h>
   6 #include <linux/pm.h>
   7 #include <linux/efi.h>
   8 #include <linux/dmi.h>
   9 #include <linux/sched.h>
  10 #include <linux/tboot.h>
  11 #include <linux/delay.h>
  12 #include <acpi/reboot.h>
  13 #include <asm/io.h>
  14 #include <asm/apic.h>
  15 #include <asm/desc.h>
  16 #include <asm/hpet.h>
  17 #include <asm/pgtable.h>
  18 #include <asm/proto.h>
  19 #include <asm/reboot_fixups.h>
  20 #include <asm/reboot.h>
  21 #include <asm/pci_x86.h>
  22 #include <asm/virtext.h>
  23 #include <asm/cpu.h>
  24 #include <asm/nmi.h>
  25 #include <asm/smp.h>
  26
  27 #include <linux/ctype.h>
  28 #include <linux/mc146818rtc.h>
  29 #include <asm/realmode.h>
  30 #include <asm/x86_init.h>
  31
  32 /*
  33  * Power off function, if any
  34  */
  35 void (*pm_power_off)(void);
  36 EXPORT_SYMBOL(pm_power_off);
  37
  38 static const struct desc_ptr no_idt = {};
  39
  40 /*
  41  * This is set if we need to go through the 'emergency' path.
  42  * When machine_emergency_restart() is called, we may be on
  43  * an inconsistent state and won't be able to do a clean cleanup
  44  */
  45 static int reboot_emergency;
  46
  47 /* This is set by the PCI code if either type 1 or type 2 PCI is detected */
  48 bool port_cf9_safe = false;
  49
  50 /*
  51  * Reboot options and system auto-detection code provided by
  52  * Dell Inc. so their systems "just work". :-)
  53  */
  54
  55 /*
  56  * Some machines require the "reboot=b" or "reboot=k"  commandline options,
  57  * this quirk makes that automatic.
  58  */
  59 static int __init set_bios_reboot(const struct dmi_system_id *d)
  60 {
  61         if (reboot_type != BOOT_BIOS) {
  62                 reboot_type = BOOT_BIOS;
  63                 pr_info("%s series board detected. Selecting %s-method for reboots.\n",
  64                         d->ident, "BIOS");
  65         }
  66         return 0;
  67 }
  68
  69 void __noreturn machine_real_restart(unsigned int type)
  70 {
  71         local_irq_disable();
  72
  73         /*
  74          * Write zero to CMOS register number 0x0f, which the BIOS POST
  75          * routine will recognize as telling it to do a proper reboot.  (Well
  76          * that's what this book in front of me says -- it may only apply to
  77          * the Phoenix BIOS though, it's not clear).  At the same time,
  78          * disable NMIs by setting the top bit in the CMOS address register,
  79          * as we're about to do peculiar things to the CPU.  I'm not sure if
  80          * `outb_p' is needed instead of just `outb'.  Use it to be on the
  81          * safe side.  (Yes, CMOS_WRITE does outb_p's. -  Paul G.)
  82          */
  83         spin_lock(&rtc_lock);
  84         CMOS_WRITE(0x00, 0x8f);
  85         spin_unlock(&rtc_lock);
  86
  87         /*
  88          * Switch back to the initial page table.
  89          */
  90 #ifdef CONFIG_X86_32
  91         load_cr3(initial_page_table);
  92 #else
  93         write_cr3(real_mode_header->trampoline_pgd);
  94 #endif
  95
  96         /* Jump to the identity-mapped low memory code */
  97 #ifdef CONFIG_X86_32
  98         asm volatile("jmpl *%0" : :
  99                      "rm" (real_mode_header->machine_real_restart_asm),
 100                      "a" (type));
 101 #else
 102         asm volatile("ljmpl *%0" : :
 103                      "m" (real_mode_header->machine_real_restart_asm),
 104                      "D" (type));
 105 #endif
 106         unreachable();
 107 }
 108 #ifdef CONFIG_APM_MODULE
 109 EXPORT_SYMBOL(machine_real_restart);
 110 #endif
 111
 112 /*
 113  * Some Apple MacBook and MacBookPro's needs reboot=p to be able to reboot
 114  */
 115 static int __init set_pci_reboot(const struct dmi_system_id *d)
 116 {
 117         if (reboot_type != BOOT_CF9_FORCE) {
 118                 reboot_type = BOOT_CF9_FORCE;
 119                 pr_info("%s series board detected. Selecting %s-method for reboots.\n",
 120                         d->ident, "PCI");
 121         }
 122         return 0;
 123 }
 124
 125 static int __init set_kbd_reboot(const struct dmi_system_id *d)
 126 {
 127         if (reboot_type != BOOT_KBD) {
 128                 reboot_type = BOOT_KBD;
 129                 pr_info("%s series board detected. Selecting %s-method for reboot.\n",
 130                         d->ident, "KBD");
 131         }
 132         return 0;
 133 }
 134
 135 /*
 136  * This is a single dmi_table handling all reboot quirks.
 137  */
 138 static struct dmi_system_id __initdata reboot_dmi_table[] = {
 139
 140         /* Acer */
 141         {       /* Handle reboot issue on Acer Aspire one */
 142                 .callback = set_kbd_reboot,
 143                 .ident = "Acer Aspire One A110",
 144                 .matches = {
 145                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 146                         DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"),
 147                 },
 148         },
 149
 150         /* Apple */
 151         {       /* Handle problems with rebooting on Apple MacBook5 */
 152                 .callback = set_pci_reboot,
 153                 .ident = "Apple MacBook5",
 154                 .matches = {
 155                         DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
 156                         DMI_MATCH(DMI_PRODUCT_NAME, "MacBook5"),
 157                 },
 158         },
 159         {       /* Handle problems with rebooting on Apple MacBookPro5 */
 160                 .callback = set_pci_reboot,
 161                 .ident = "Apple MacBookPro5",
 162                 .matches = {
 163                         DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
 164                         DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5"),
 165                 },
 166         },
 167         {       /* Handle problems with rebooting on Apple Macmini3,1 */
 168                 .callback = set_pci_reboot,
 169                 .ident = "Apple Macmini3,1",
 170                 .matches = {
 171                         DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
 172                         DMI_MATCH(DMI_PRODUCT_NAME, "Macmini3,1"),
 173                 },
 174         },
 175         {       /* Handle problems with rebooting on the iMac9,1. */
 176                 .callback = set_pci_reboot,
 177                 .ident = "Apple iMac9,1",
 178                 .matches = {
 179                         DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
 180                         DMI_MATCH(DMI_PRODUCT_NAME, "iMac9,1"),
 181                 },
 182         },
 183
 184         /* ASUS */
 185         {       /* Handle problems with rebooting on ASUS P4S800 */
 186                 .callback = set_bios_reboot,
 187                 .ident = "ASUS P4S800",
 188                 .matches = {
 189                         DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
 190                         DMI_MATCH(DMI_BOARD_NAME, "P4S800"),
 191                 },
 192         },
 193
 194         /* Certec */
 195         {       /* Handle problems with rebooting on Certec BPC600 */
 196                 .callback = set_pci_reboot,
 197                 .ident = "Certec BPC600",
 198                 .matches = {
 199                         DMI_MATCH(DMI_SYS_VENDOR, "Certec"),
 200                         DMI_MATCH(DMI_PRODUCT_NAME, "BPC600"),
 201                 },
 202         },
 203
 204         /* Dell */
 205         {       /* Handle problems with rebooting on Dell DXP061 */
 206                 .callback = set_bios_reboot,
 207                 .ident = "Dell DXP061",
 208                 .matches = {
 209                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 210                         DMI_MATCH(DMI_PRODUCT_NAME, "Dell DXP061"),
 211                 },
 212         },
 213         {       /* Handle problems with rebooting on Dell E520's */
 214                 .callback = set_bios_reboot,
 215                 .ident = "Dell E520",
 216                 .matches = {
 217                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 218                         DMI_MATCH(DMI_PRODUCT_NAME, "Dell DM061"),
 219                 },
 220         },
 221         {       /* Handle problems with rebooting on the Latitude E5410. */
 222                 .callback = set_pci_reboot,
 223                 .ident = "Dell Latitude E5410",
 224                 .matches = {
 225                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 226                         DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E5410"),
 227                 },
 228         },
 229         {       /* Handle problems with rebooting on the Latitude E5420. */
 230                 .callback = set_pci_reboot,
 231                 .ident = "Dell Latitude E5420",
 232                 .matches = {
 233                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 234                         DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E5420"),
 235                 },
 236         },
 237         {       /* Handle problems with rebooting on the Latitude E6320. */
 238                 .callback = set_pci_reboot,
 239                 .ident = "Dell Latitude E6320",
 240                 .matches = {
 241                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 242                         DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6320"),
 243                 },
 244         },
 245         {       /* Handle problems with rebooting on the Latitude E6420. */
 246                 .callback = set_pci_reboot,
 247                 .ident = "Dell Latitude E6420",
 248                 .matches = {
 249                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 250                         DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6420"),
 251                 },
 252         },
 253         {       /* Handle problems with rebooting on Dell Optiplex 330 with 0KP561 */
 254                 .callback = set_bios_reboot,
 255                 .ident = "Dell OptiPlex 330",
 256                 .matches = {
 257                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 258                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 330"),
 259                         DMI_MATCH(DMI_BOARD_NAME, "0KP561"),
 260                 },
 261         },
 262         {       /* Handle problems with rebooting on Dell Optiplex 360 with 0T656F */
 263                 .callback = set_bios_reboot,
 264                 .ident = "Dell OptiPlex 360",
 265                 .matches = {
 266                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 267                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 360"),
 268                         DMI_MATCH(DMI_BOARD_NAME, "0T656F"),
 269                 },
 270         },
 271         {       /* Handle problems with rebooting on Dell Optiplex 745's SFF */
 272                 .callback = set_bios_reboot,
 273                 .ident = "Dell OptiPlex 745",
 274                 .matches = {
 275                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 276                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
 277                 },
 278         },
 279         {       /* Handle problems with rebooting on Dell Optiplex 745's DFF */
 280                 .callback = set_bios_reboot,
 281                 .ident = "Dell OptiPlex 745",
 282                 .matches = {
 283                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 284                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
 285                         DMI_MATCH(DMI_BOARD_NAME, "0MM599"),
 286                 },
 287         },
 288         {       /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */
 289                 .callback = set_bios_reboot,
 290                 .ident = "Dell OptiPlex 745",
 291                 .matches = {
 292                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 293                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
 294                         DMI_MATCH(DMI_BOARD_NAME, "0KW626"),
 295                 },
 296         },
 297         {       /* Handle problems with rebooting on Dell OptiPlex 760 with 0G919G */
 298                 .callback = set_bios_reboot,
 299                 .ident = "Dell OptiPlex 760",
 300                 .matches = {
 301                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 302                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 760"),
 303                         DMI_MATCH(DMI_BOARD_NAME, "0G919G"),
 304                 },
 305         },
 306         {       /* Handle problems with rebooting on the OptiPlex 990. */
 307                 .callback = set_pci_reboot,
 308                 .ident = "Dell OptiPlex 990",
 309                 .matches = {
 310                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 311                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 990"),
 312                 },
 313         },
 314         {       /* Handle problems with rebooting on Dell 300's */
 315                 .callback = set_bios_reboot,
 316                 .ident = "Dell PowerEdge 300",
 317                 .matches = {
 318                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
 319                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"),
 320                 },
 321         },
 322         {       /* Handle problems with rebooting on Dell 1300's */
 323                 .callback = set_bios_reboot,
 324                 .ident = "Dell PowerEdge 1300",
 325                 .matches = {
 326                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
 327                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1300/"),
 328                 },
 329         },
 330         {       /* Handle problems with rebooting on Dell 2400's */
 331                 .callback = set_bios_reboot,
 332                 .ident = "Dell PowerEdge 2400",
 333                 .matches = {
 334                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
 335                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"),
 336                 },
 337         },
 338         {       /* Handle problems with rebooting on the Dell PowerEdge C6100. */
 339                 .callback = set_pci_reboot,
 340                 .ident = "Dell PowerEdge C6100",
 341                 .matches = {
 342                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 343                         DMI_MATCH(DMI_PRODUCT_NAME, "C6100"),
 344                 },
 345         },
 346         {       /* Handle problems with rebooting on the Precision M6600. */
 347                 .callback = set_pci_reboot,
 348                 .ident = "Dell Precision M6600",
 349                 .matches = {
 350                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 351                         DMI_MATCH(DMI_PRODUCT_NAME, "Precision M6600"),
 352                 },
 353         },
 354         {       /* Handle problems with rebooting on Dell T5400's */
 355                 .callback = set_bios_reboot,
 356                 .ident = "Dell Precision T5400",
 357                 .matches = {
 358                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 359                         DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T5400"),
 360                 },
 361         },
 362         {       /* Handle problems with rebooting on Dell T7400's */
 363                 .callback = set_bios_reboot,
 364                 .ident = "Dell Precision T7400",
 365                 .matches = {
 366                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 367                         DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T7400"),
 368                 },
 369         },
 370         {       /* Handle problems with rebooting on Dell XPS710 */
 371                 .callback = set_bios_reboot,
 372                 .ident = "Dell XPS710",
 373                 .matches = {
 374                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 375                         DMI_MATCH(DMI_PRODUCT_NAME, "Dell XPS710"),
 376                 },
 377         },
 378
 379         /* Hewlett-Packard */
 380         {       /* Handle problems with rebooting on HP laptops */
 381                 .callback = set_bios_reboot,
 382                 .ident = "HP Compaq Laptop",
 383                 .matches = {
 384                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 385                         DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"),
 386                 },
 387         },
 388
 389         /* Sony */
 390         {       /* Handle problems with rebooting on Sony VGN-Z540N */
 391                 .callback = set_bios_reboot,
 392                 .ident = "Sony VGN-Z540N",
 393                 .matches = {
 394                         DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 395                         DMI_MATCH(DMI_PRODUCT_NAME, "VGN-Z540N"),
 396                 },
 397         },
 398
 399         { }
 400 };
 401
 402 static int __init reboot_init(void)
 403 {
 404         /*
 405          * Only do the DMI check if reboot_type hasn't been overridden
 406          * on the command line
 407          */
 408         if (reboot_default)
 409                 dmi_check_system(reboot_dmi_table);
 410         return 0;
 411 }
 412 core_initcall(reboot_init);
 413
 414 static inline void kb_wait(void)
 415 {
 416         int i;
 417
 418         for (i = 0; i < 0x10000; i++) {
 419                 if ((inb(0x64) & 0x02) == 0)
 420                         break;
 421                 udelay(2);
 422         }
 423 }
 424
 425 static void vmxoff_nmi(int cpu, struct pt_regs *regs)
 426 {
 427         cpu_emergency_vmxoff();
 428 }
 429
 430 /* Use NMIs as IPIs to tell all CPUs to disable virtualization */
 431 static void emergency_vmx_disable_all(void)
 432 {
 433         /* Just make sure we won't change CPUs while doing this */
 434         local_irq_disable();
 435
 436         /*
 437          * We need to disable VMX on all CPUs before rebooting, otherwise
 438          * we risk hanging up the machine, because the CPU ignore INIT
 439          * signals when VMX is enabled.
 440          *
 441          * We can't take any locks and we may be on an inconsistent
 442          * state, so we use NMIs as IPIs to tell the other CPUs to disable
 443          * VMX and halt.
 444          *
 445          * For safety, we will avoid running the nmi_shootdown_cpus()
 446          * stuff unnecessarily, but we don't have a way to check
 447          * if other CPUs have VMX enabled. So we will call it only if the
 448          * CPU we are running on has VMX enabled.
 449          *
 450          * We will miss cases where VMX is not enabled on all CPUs. This
 451          * shouldn't do much harm because KVM always enable VMX on all
 452          * CPUs anyway. But we can miss it on the small window where KVM
 453          * is still enabling VMX.
 454          */
 455         if (cpu_has_vmx() && cpu_vmx_enabled()) {
 456                 /* Disable VMX on this CPU. */
 457                 cpu_vmxoff();
 458
 459                 /* Halt and disable VMX on the other CPUs */
 460                 nmi_shootdown_cpus(vmxoff_nmi);
 461
 462         }
 463 }
 464
 465
 466 void __attribute__((weak)) mach_reboot_fixups(void)
 467 {
 468 }
 469
 470 /*
 471  * To the best of our knowledge Windows compatible x86 hardware expects
 472  * the following on reboot:
 473  *
 474  * 1) If the FADT has the ACPI reboot register flag set, try it
 475  * 2) If still alive, write to the keyboard controller
 476  * 3) If still alive, write to the ACPI reboot register again
 477  * 4) If still alive, write to the keyboard controller again
 478  * 5) If still alive, call the EFI runtime service to reboot
 479  * 6) If no EFI runtime service, call the BIOS to do a reboot
 480  *
 481  * We default to following the same pattern. We also have
 482  * two other reboot methods: 'triple fault' and 'PCI', which
 483  * can be triggered via the reboot= kernel boot option or
 484  * via quirks.
 485  *
 486  * This means that this function can never return, it can misbehave
 487  * by not rebooting properly and hanging.
 488  */
 489 static void native_machine_emergency_restart(void)
 490 {
 491         int i;
 492         int attempt = 0;
 493         int orig_reboot_type = reboot_type;
 494         unsigned short mode;
 495
 496         if (reboot_emergency)
 497                 emergency_vmx_disable_all();
 498
 499         tboot_shutdown(TB_SHUTDOWN_REBOOT);
 500
 501         /* Tell the BIOS if we want cold or warm reboot */
 502         mode = reboot_mode == REBOOT_WARM ? 0x1234 : 0;
 503         *((unsigned short *)__va(0x472)) = mode;
 504
 505         for (;;) {
 506                 /* Could also try the reset bit in the Hammer NB */
 507                 switch (reboot_type) {
 508                 case BOOT_ACPI:
 509                         acpi_reboot();
 510                         reboot_type = BOOT_KBD;
 511                         break;
 512
 513                 case BOOT_KBD:
 514                         mach_reboot_fixups(); /* For board specific fixups */
 515
 516                         for (i = 0; i < 10; i++) {
 517                                 kb_wait();
 518                                 udelay(50);
 519                                 outb(0xfe, 0x64); /* Pulse reset low */
 520                                 udelay(50);
 521                         }
 522                         if (attempt == 0 && orig_reboot_type == BOOT_ACPI) {
 523                                 attempt = 1;
 524                                 reboot_type = BOOT_ACPI;
 525                         } else {
 526                                 reboot_type = BOOT_EFI;
 527                         }
 528                         break;
 529
 530                 case BOOT_EFI:
 531                         if (efi_enabled(EFI_RUNTIME_SERVICES))
 532                                 efi.reset_system(reboot_mode == REBOOT_WARM ?
 533                                                  EFI_RESET_WARM :
 534                                                  EFI_RESET_COLD,
 535                                                  EFI_SUCCESS, 0, NULL);
 536                         reboot_type = BOOT_BIOS;
 537                         break;
 538
 539                 case BOOT_BIOS:
 540                         machine_real_restart(MRR_BIOS);
 541
 542                         /* We're probably dead after this, but... */
 543                         reboot_type = BOOT_CF9_SAFE;
 544                         break;
 545
 546                 case BOOT_CF9_FORCE:
 547                         port_cf9_safe = true;
 548                         /* Fall through */
 549
 550                 case BOOT_CF9_SAFE:
 551                         if (port_cf9_safe) {
 552                                 u8 reboot_code = reboot_mode == REBOOT_WARM ?  0x06 : 0x0E;
 553                                 u8 cf9 = inb(0xcf9) & ~reboot_code;
 554                                 outb(cf9|2, 0xcf9); /* Request hard reset */
 555                                 udelay(50);
 556                                 /* Actually do the reset */
 557                                 outb(cf9|reboot_code, 0xcf9);
 558                                 udelay(50);
 559                         }
 560                         reboot_type = BOOT_TRIPLE;
 561                         break;
 562
 563                 case BOOT_TRIPLE:
 564                         load_idt(&no_idt);
 565                         __asm__ __volatile__("int3");
 566
 567                         /* We're probably dead after this, but... */
 568                         reboot_type = BOOT_KBD;
 569                         break;
 570                 }
 571         }
 572 }
 573
 574 void native_machine_shutdown(void)
 575 {
 576         /* Stop the cpus and apics */
 577 #ifdef CONFIG_X86_IO_APIC
 578         /*
 579          * Disabling IO APIC before local APIC is a workaround for
 580          * erratum AVR31 in "Intel Atom Processor C2000 Product Family
 581          * Specification Update". In this situation, interrupts that target
 582          * a Logical Processor whose Local APIC is either in the process of
 583          * being hardware disabled or software disabled are neither delivered
 584          * nor discarded. When this erratum occurs, the processor may hang.
 585          *
 586          * Even without the erratum, it still makes sense to quiet IO APIC
 587          * before disabling Local APIC.
 588          */
 589         disable_IO_APIC();
 590 #endif
 591
 592 #ifdef CONFIG_SMP
 593         /*
 594          * Stop all of the others. Also disable the local irq to
 595          * not receive the per-cpu timer interrupt which may trigger
 596          * scheduler's load balance.
 597          */
 598         local_irq_disable();
 599         stop_other_cpus();
 600 #endif
 601
 602         lapic_shutdown();
 603
 604 #ifdef CONFIG_HPET_TIMER
 605         hpet_disable();
 606 #endif
 607
 608 #ifdef CONFIG_X86_64
 609         x86_platform.iommu_shutdown();
 610 #endif
 611 }
 612
 613 static void __machine_emergency_restart(int emergency)
 614 {
 615         reboot_emergency = emergency;
 616         machine_ops.emergency_restart();
 617 }
 618
 619 static void native_machine_restart(char *__unused)
 620 {
 621         pr_notice("machine restart\n");
 622
 623         if (!reboot_force)
 624                 machine_shutdown();
 625         __machine_emergency_restart(0);
 626 }
 627
 628 static void native_machine_halt(void)
 629 {
 630         /* Stop other cpus and apics */
 631         machine_shutdown();
 632
 633         tboot_shutdown(TB_SHUTDOWN_HALT);
 634
 635         stop_this_cpu(NULL);
 636 }
 637
 638 static void native_machine_power_off(void)
 639 {
 640         if (pm_power_off) {
 641                 if (!reboot_force)
 642                         machine_shutdown();
 643                 pm_power_off();
 644         }
 645         /* A fallback in case there is no PM info available */
 646         tboot_shutdown(TB_SHUTDOWN_HALT);
 647 }
 648
 649 struct machine_ops machine_ops = {
 650         .power_off = native_machine_power_off,
 651         .shutdown = native_machine_shutdown,
 652         .emergency_restart = native_machine_emergency_restart,
 653         .restart = native_machine_restart,
 654         .halt = native_machine_halt,
 655 #ifdef CONFIG_KEXEC
 656         .crash_shutdown = native_machine_crash_shutdown,
 657 #endif
 658 };
 659
 660 void machine_power_off(void)
 661 {
 662         machine_ops.power_off();
 663 }
 664
 665 void machine_shutdown(void)
 666 {
 667         machine_ops.shutdown();
 668 }
 669
 670 void machine_emergency_restart(void)
 671 {
 672         __machine_emergency_restart(1);
 673 }
 674
 675 void machine_restart(char *cmd)
 676 {
 677         machine_ops.restart(cmd);
 678 }
 679
 680 void machine_halt(void)
 681 {
 682         machine_ops.halt();
 683 }
 684
 685 #ifdef CONFIG_KEXEC
 686 void machine_crash_shutdown(struct pt_regs *regs)
 687 {
 688         machine_ops.crash_shutdown(regs);
 689 }
 690 #endif
 691
 692
 693 #if defined(CONFIG_SMP)
 694
 695 /* This keeps a track of which one is crashing cpu. */
 696 static int crashing_cpu;
 697 static nmi_shootdown_cb shootdown_callback;
 698
 699 static atomic_t waiting_for_crash_ipi;
 700
 701 static int crash_nmi_callback(unsigned int val, struct pt_regs *regs)
 702 {
 703         int cpu;
 704
 705         cpu = raw_smp_processor_id();
 706
 707         /*
 708          * Don't do anything if this handler is invoked on crashing cpu.
 709          * Otherwise, system will completely hang. Crashing cpu can get
 710          * an NMI if system was initially booted with nmi_watchdog parameter.
 711          */
 712         if (cpu == crashing_cpu)
 713                 return NMI_HANDLED;
 714         local_irq_disable();
 715
 716         shootdown_callback(cpu, regs);
 717
 718         atomic_dec(&waiting_for_crash_ipi);
 719         /* Assume hlt works */
 720         halt();
 721         for (;;)
 722                 cpu_relax();
 723
 724         return NMI_HANDLED;
 725 }
 726
 727 static void smp_send_nmi_allbutself(void)
 728 {
 729         apic->send_IPI_allbutself(NMI_VECTOR);
 730 }
 731
 732 /*
 733  * Halt all other CPUs, calling the specified function on each of them
 734  *
 735  * This function can be used to halt all other CPUs on crash
 736  * or emergency reboot time. The function passed as parameter
 737  * will be called inside a NMI handler on all CPUs.
 738  */
 739 void nmi_shootdown_cpus(nmi_shootdown_cb callback)
 740 {
 741         unsigned long msecs;
 742         local_irq_disable();
 743
 744         /* Make a note of crashing cpu. Will be used in NMI callback. */
 745         crashing_cpu = safe_smp_processor_id();
 746
 747         shootdown_callback = callback;
 748
 749         atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
 750         /* Would it be better to replace the trap vector here? */
 751         if (register_nmi_handler(NMI_LOCAL, crash_nmi_callback,
 752                                  NMI_FLAG_FIRST, "crash"))
 753                 return;         /* Return what? */
 754         /*
 755          * Ensure the new callback function is set before sending
 756          * out the NMI
 757          */
 758         wmb();
 759
 760         smp_send_nmi_allbutself();
 761
 762         msecs = 1000; /* Wait at most a second for the other cpus to stop */
 763         while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) {
 764                 mdelay(1);
 765                 msecs--;
 766         }
 767
 768         /* Leave the nmi callback set */
 769 }
 770 #else /* !CONFIG_SMP */
 771 void nmi_shootdown_cpus(nmi_shootdown_cb callback)
 772 {
 773         /* No other CPUs to shoot down */
 774 }
 775 #endif