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