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