Pileus Git - ~andy/linux/blob - arch/x86/kernel/reboot.c

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