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 /* Sony */ 481 { /* Handle problems with rebooting on Sony VGN-Z540N */ 482 .callback = set_bios_reboot, 483 .ident = "Sony VGN-Z540N", 484 .matches = { 485 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), 486 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-Z540N"), 487 }, 488 }, 489 490 { } 491 }; 492 493 static int __init reboot_init(void) 494 { 495 int rv; 496 497 /* 498 * Only do the DMI check if reboot_type hasn't been overridden 499 * on the command line 500 */ 501 if (!reboot_default) 502 return 0; 503 504 /* 505 * The DMI quirks table takes precedence. If no quirks entry 506 * matches and the ACPI Hardware Reduced bit is set and EFI 507 * runtime services are enabled, force EFI reboot. 508 */ 509 rv = dmi_check_system(reboot_dmi_table); 510 511 if (!rv && efi_reboot_required() && !efi_runtime_disabled()) 512 reboot_type = BOOT_EFI; 513 514 return 0; 515 } 516 core_initcall(reboot_init); 517 518 static inline void kb_wait(void) 519 { 520 int i; 521 522 for (i = 0; i < 0x10000; i++) { 523 if ((inb(0x64) & 0x02) == 0) 524 break; 525 udelay(2); 526 } 527 } 528 529 static void vmxoff_nmi(int cpu, struct pt_regs *regs) 530 { 531 cpu_emergency_vmxoff(); 532 } 533 534 /* Use NMIs as IPIs to tell all CPUs to disable virtualization */ 535 static void emergency_vmx_disable_all(void) 536 { 537 /* Just make sure we won't change CPUs while doing this */ 538 local_irq_disable(); 539 540 /* 541 * We need to disable VMX on all CPUs before rebooting, otherwise 542 * we risk hanging up the machine, because the CPU ignores INIT 543 * signals when VMX is enabled. 544 * 545 * We can't take any locks and we may be on an inconsistent 546 * state, so we use NMIs as IPIs to tell the other CPUs to disable 547 * VMX and halt. 548 * 549 * For safety, we will avoid running the nmi_shootdown_cpus() 550 * stuff unnecessarily, but we don't have a way to check 551 * if other CPUs have VMX enabled. So we will call it only if the 552 * CPU we are running on has VMX enabled. 553 * 554 * We will miss cases where VMX is not enabled on all CPUs. This 555 * shouldn't do much harm because KVM always enable VMX on all 556 * CPUs anyway. But we can miss it on the small window where KVM 557 * is still enabling VMX. 558 */ 559 if (cpu_has_vmx() && cpu_vmx_enabled()) { 560 /* Disable VMX on this CPU. */ 561 cpu_vmxoff(); 562 563 /* Halt and disable VMX on the other CPUs */ 564 nmi_shootdown_cpus(vmxoff_nmi); 565 566 } 567 } 568 569 570 void __attribute__((weak)) mach_reboot_fixups(void) 571 { 572 } 573 574 /* 575 * To the best of our knowledge Windows compatible x86 hardware expects 576 * the following on reboot: 577 * 578 * 1) If the FADT has the ACPI reboot register flag set, try it 579 * 2) If still alive, write to the keyboard controller 580 * 3) If still alive, write to the ACPI reboot register again 581 * 4) If still alive, write to the keyboard controller again 582 * 5) If still alive, call the EFI runtime service to reboot 583 * 6) If no EFI runtime service, call the BIOS to do a reboot 584 * 585 * We default to following the same pattern. We also have 586 * two other reboot methods: 'triple fault' and 'PCI', which 587 * can be triggered via the reboot= kernel boot option or 588 * via quirks. 589 * 590 * This means that this function can never return, it can misbehave 591 * by not rebooting properly and hanging. 592 */ 593 static void native_machine_emergency_restart(void) 594 { 595 int i; 596 int attempt = 0; 597 int orig_reboot_type = reboot_type; 598 unsigned short mode; 599 600 if (reboot_emergency) 601 emergency_vmx_disable_all(); 602 603 tboot_shutdown(TB_SHUTDOWN_REBOOT); 604 605 /* Tell the BIOS if we want cold or warm reboot */ 606 mode = reboot_mode == REBOOT_WARM ? 0x1234 : 0; 607 *((unsigned short *)__va(0x472)) = mode; 608 609 /* 610 * If an EFI capsule has been registered with the firmware then 611 * override the reboot= parameter. 612 */ 613 if (efi_capsule_pending(NULL)) { 614 pr_info("EFI capsule is pending, forcing EFI reboot.\n"); 615 reboot_type = BOOT_EFI; 616 } 617 618 for (;;) { 619 /* Could also try the reset bit in the Hammer NB */ 620 switch (reboot_type) { 621 case BOOT_ACPI: 622 acpi_reboot(); 623 reboot_type = BOOT_KBD; 624 break; 625 626 case BOOT_KBD: 627 mach_reboot_fixups(); /* For board specific fixups */ 628 629 for (i = 0; i < 10; i++) { 630 kb_wait(); 631 udelay(50); 632 outb(0xfe, 0x64); /* Pulse reset low */ 633 udelay(50); 634 } 635 if (attempt == 0 && orig_reboot_type == BOOT_ACPI) { 636 attempt = 1; 637 reboot_type = BOOT_ACPI; 638 } else { 639 reboot_type = BOOT_EFI; 640 } 641 break; 642 643 case BOOT_EFI: 644 efi_reboot(reboot_mode, NULL); 645 reboot_type = BOOT_BIOS; 646 break; 647 648 case BOOT_BIOS: 649 machine_real_restart(MRR_BIOS); 650 651 /* We're probably dead after this, but... */ 652 reboot_type = BOOT_CF9_SAFE; 653 break; 654 655 case BOOT_CF9_FORCE: 656 port_cf9_safe = true; 657 fallthrough; 658 659 case BOOT_CF9_SAFE: 660 if (port_cf9_safe) { 661 u8 reboot_code = reboot_mode == REBOOT_WARM ? 0x06 : 0x0E; 662 u8 cf9 = inb(0xcf9) & ~reboot_code; 663 outb(cf9|2, 0xcf9); /* Request hard reset */ 664 udelay(50); 665 /* Actually do the reset */ 666 outb(cf9|reboot_code, 0xcf9); 667 udelay(50); 668 } 669 reboot_type = BOOT_TRIPLE; 670 break; 671 672 case BOOT_TRIPLE: 673 idt_invalidate(NULL); 674 __asm__ __volatile__("int3"); 675 676 /* We're probably dead after this, but... */ 677 reboot_type = BOOT_KBD; 678 break; 679 } 680 } 681 } 682 683 void native_machine_shutdown(void) 684 { 685 /* Stop the cpus and apics */ 686 #ifdef CONFIG_X86_IO_APIC 687 /* 688 * Disabling IO APIC before local APIC is a workaround for 689 * erratum AVR31 in "Intel Atom Processor C2000 Product Family 690 * Specification Update". In this situation, interrupts that target 691 * a Logical Processor whose Local APIC is either in the process of 692 * being hardware disabled or software disabled are neither delivered 693 * nor discarded. When this erratum occurs, the processor may hang. 694 * 695 * Even without the erratum, it still makes sense to quiet IO APIC 696 * before disabling Local APIC. 697 */ 698 clear_IO_APIC(); 699 #endif 700 701 #ifdef CONFIG_SMP 702 /* 703 * Stop all of the others. Also disable the local irq to 704 * not receive the per-cpu timer interrupt which may trigger 705 * scheduler's load balance. 706 */ 707 local_irq_disable(); 708 stop_other_cpus(); 709 #endif 710 711 lapic_shutdown(); 712 restore_boot_irq_mode(); 713 714 #ifdef CONFIG_HPET_TIMER 715 hpet_disable(); 716 #endif 717 718 #ifdef CONFIG_X86_64 719 x86_platform.iommu_shutdown(); 720 #endif 721 } 722 723 static void __machine_emergency_restart(int emergency) 724 { 725 reboot_emergency = emergency; 726 machine_ops.emergency_restart(); 727 } 728 729 static void native_machine_restart(char *__unused) 730 { 731 pr_notice("machine restart\n"); 732 733 if (!reboot_force) 734 machine_shutdown(); 735 __machine_emergency_restart(0); 736 } 737 738 static void native_machine_halt(void) 739 { 740 /* Stop other cpus and apics */ 741 machine_shutdown(); 742 743 tboot_shutdown(TB_SHUTDOWN_HALT); 744 745 stop_this_cpu(NULL); 746 } 747 748 static void native_machine_power_off(void) 749 { 750 if (pm_power_off) { 751 if (!reboot_force) 752 machine_shutdown(); 753 pm_power_off(); 754 } 755 /* A fallback in case there is no PM info available */ 756 tboot_shutdown(TB_SHUTDOWN_HALT); 757 } 758 759 struct machine_ops machine_ops __ro_after_init = { 760 .power_off = native_machine_power_off, 761 .shutdown = native_machine_shutdown, 762 .emergency_restart = native_machine_emergency_restart, 763 .restart = native_machine_restart, 764 .halt = native_machine_halt, 765 #ifdef CONFIG_KEXEC_CORE 766 .crash_shutdown = native_machine_crash_shutdown, 767 #endif 768 }; 769 770 void machine_power_off(void) 771 { 772 machine_ops.power_off(); 773 } 774 775 void machine_shutdown(void) 776 { 777 machine_ops.shutdown(); 778 } 779 780 void machine_emergency_restart(void) 781 { 782 __machine_emergency_restart(1); 783 } 784 785 void machine_restart(char *cmd) 786 { 787 machine_ops.restart(cmd); 788 } 789 790 void machine_halt(void) 791 { 792 machine_ops.halt(); 793 } 794 795 #ifdef CONFIG_KEXEC_CORE 796 void machine_crash_shutdown(struct pt_regs *regs) 797 { 798 machine_ops.crash_shutdown(regs); 799 } 800 #endif 801 802 803 /* This is the CPU performing the emergency shutdown work. */ 804 int crashing_cpu = -1; 805 806 #if defined(CONFIG_SMP) 807 808 static nmi_shootdown_cb shootdown_callback; 809 810 static atomic_t waiting_for_crash_ipi; 811 static int crash_ipi_issued; 812 813 static int crash_nmi_callback(unsigned int val, struct pt_regs *regs) 814 { 815 int cpu; 816 817 cpu = raw_smp_processor_id(); 818 819 /* 820 * Don't do anything if this handler is invoked on crashing cpu. 821 * Otherwise, system will completely hang. Crashing cpu can get 822 * an NMI if system was initially booted with nmi_watchdog parameter. 823 */ 824 if (cpu == crashing_cpu) 825 return NMI_HANDLED; 826 local_irq_disable(); 827 828 shootdown_callback(cpu, regs); 829 830 atomic_dec(&waiting_for_crash_ipi); 831 /* Assume hlt works */ 832 halt(); 833 for (;;) 834 cpu_relax(); 835 836 return NMI_HANDLED; 837 } 838 839 /* 840 * Halt all other CPUs, calling the specified function on each of them 841 * 842 * This function can be used to halt all other CPUs on crash 843 * or emergency reboot time. The function passed as parameter 844 * will be called inside a NMI handler on all CPUs. 845 */ 846 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 847 { 848 unsigned long msecs; 849 local_irq_disable(); 850 851 /* Make a note of crashing cpu. Will be used in NMI callback. */ 852 crashing_cpu = safe_smp_processor_id(); 853 854 shootdown_callback = callback; 855 856 atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1); 857 /* Would it be better to replace the trap vector here? */ 858 if (register_nmi_handler(NMI_LOCAL, crash_nmi_callback, 859 NMI_FLAG_FIRST, "crash")) 860 return; /* Return what? */ 861 /* 862 * Ensure the new callback function is set before sending 863 * out the NMI 864 */ 865 wmb(); 866 867 apic_send_IPI_allbutself(NMI_VECTOR); 868 869 /* Kick CPUs looping in NMI context. */ 870 WRITE_ONCE(crash_ipi_issued, 1); 871 872 msecs = 1000; /* Wait at most a second for the other cpus to stop */ 873 while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) { 874 mdelay(1); 875 msecs--; 876 } 877 878 /* Leave the nmi callback set */ 879 } 880 881 /* 882 * Check if the crash dumping IPI got issued and if so, call its callback 883 * directly. This function is used when we have already been in NMI handler. 884 * It doesn't return. 885 */ 886 void run_crash_ipi_callback(struct pt_regs *regs) 887 { 888 if (crash_ipi_issued) 889 crash_nmi_callback(0, regs); 890 } 891 892 /* Override the weak function in kernel/panic.c */ 893 void nmi_panic_self_stop(struct pt_regs *regs) 894 { 895 while (1) { 896 /* If no CPU is preparing crash dump, we simply loop here. */ 897 run_crash_ipi_callback(regs); 898 cpu_relax(); 899 } 900 } 901 902 #else /* !CONFIG_SMP */ 903 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 904 { 905 /* No other CPUs to shoot down */ 906 } 907 908 void run_crash_ipi_callback(struct pt_regs *regs) 909 { 910 } 911 #endif 912