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