arch/x86/kernel/reboot.c

   1 #include <linux/module.h>
   2 #include <linux/reboot.h>
   3 #include <linux/init.h>
   4 #include <linux/pm.h>
   5 #include <linux/efi.h>
   6 #include <acpi/reboot.h>
   7 #include <asm/io.h>
   8 #include <asm/apic.h>
   9 #include <asm/desc.h>
  10 #include <asm/hpet.h>
  11 #include <asm/pgtable.h>
  12 #include <asm/proto.h>
  13 #include <asm/reboot_fixups.h>
  14 #include <asm/reboot.h>
  15
  16 #ifdef CONFIG_X86_32
  17 # include <linux/dmi.h>
  18 # include <linux/ctype.h>
  19 # include <linux/mc146818rtc.h>
  20 #else
  21 # include <asm/iommu.h>
  22 #endif
  23
  24 /*
  25  * Power off function, if any
  26  */
  27 void (*pm_power_off)(void);
  28 EXPORT_SYMBOL(pm_power_off);
  29
  30 static const struct desc_ptr no_idt = {};
  31 static int reboot_mode;
  32 /*
  33  * Keyboard reset and triple fault may result in INIT, not RESET, which
  34  * doesn't work when we're in vmx root mode.  Try ACPI first.
  35  */
  36 enum reboot_type reboot_type = BOOT_ACPI;
  37 int reboot_force;
  38
  39 #if defined(CONFIG_X86_32) && defined(CONFIG_SMP)
  40 static int reboot_cpu = -1;
  41 #endif
  42
  43 /* reboot=b[ios] | s[mp] | t[riple] | k[bd] | e[fi] [, [w]arm | [c]old]
  44    warm   Don't set the cold reboot flag
  45    cold   Set the cold reboot flag
  46    bios   Reboot by jumping through the BIOS (only for X86_32)
  47    smp    Reboot by executing reset on BSP or other CPU (only for X86_32)
  48    triple Force a triple fault (init)
  49    kbd    Use the keyboard controller. cold reset (default)
  50    acpi   Use the RESET_REG in the FADT
  51    efi    Use efi reset_system runtime service
  52    force  Avoid anything that could hang.
  53  */
  54 static int __init reboot_setup(char *str)
  55 {
  56         for (;;) {
  57                 switch (*str) {
  58                 case 'w':
  59                         reboot_mode = 0x1234;
  60                         break;
  61
  62                 case 'c':
  63                         reboot_mode = 0;
  64                         break;
  65
  66 #ifdef CONFIG_X86_32
  67 #ifdef CONFIG_SMP
  68                 case 's':
  69                         if (isdigit(*(str+1))) {
  70                                 reboot_cpu = (int) (*(str+1) - '0');
  71                                 if (isdigit(*(str+2)))
  72                                         reboot_cpu = reboot_cpu*10 + (int)(*(str+2) - '0');
  73                         }
  74                                 /* we will leave sorting out the final value
  75                                    when we are ready to reboot, since we might not
  76                                    have set up boot_cpu_id or smp_num_cpu */
  77                         break;
  78 #endif /* CONFIG_SMP */
  79
  80                 case 'b':
  81 #endif
  82                 case 'a':
  83                 case 'k':
  84                 case 't':
  85                 case 'e':
  86                         reboot_type = *str;
  87                         break;
  88
  89                 case 'f':
  90                         reboot_force = 1;
  91                         break;
  92                 }
  93
  94                 str = strchr(str, ',');
  95                 if (str)
  96                         str++;
  97                 else
  98                         break;
  99         }
 100         return 1;
 101 }
 102
 103 __setup("reboot=", reboot_setup);
 104
 105
 106 #ifdef CONFIG_X86_32
 107 /*
 108  * Reboot options and system auto-detection code provided by
 109  * Dell Inc. so their systems "just work". :-)
 110  */
 111
 112 /*
 113  * Some machines require the "reboot=b"  commandline option,
 114  * this quirk makes that automatic.
 115  */
 116 static int __init set_bios_reboot(const struct dmi_system_id *d)
 117 {
 118         if (reboot_type != BOOT_BIOS) {
 119                 reboot_type = BOOT_BIOS;
 120                 printk(KERN_INFO "%s series board detected. Selecting BIOS-method for reboots.\n", d->ident);
 121         }
 122         return 0;
 123 }
 124
 125 static struct dmi_system_id __initdata reboot_dmi_table[] = {
 126         {       /* Handle problems with rebooting on Dell E520's */
 127                 .callback = set_bios_reboot,
 128                 .ident = "Dell E520",
 129                 .matches = {
 130                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 131                         DMI_MATCH(DMI_PRODUCT_NAME, "Dell DM061"),
 132                 },
 133         },
 134         {       /* Handle problems with rebooting on Dell 1300's */
 135                 .callback = set_bios_reboot,
 136                 .ident = "Dell PowerEdge 1300",
 137                 .matches = {
 138                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
 139                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1300/"),
 140                 },
 141         },
 142         {       /* Handle problems with rebooting on Dell 300's */
 143                 .callback = set_bios_reboot,
 144                 .ident = "Dell PowerEdge 300",
 145                 .matches = {
 146                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
 147                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"),
 148                 },
 149         },
 150         {       /* Handle problems with rebooting on Dell Optiplex 745's SFF*/
 151                 .callback = set_bios_reboot,
 152                 .ident = "Dell OptiPlex 745",
 153                 .matches = {
 154                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 155                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
 156                 },
 157         },
 158         {       /* Handle problems with rebooting on Dell Optiplex 745's DFF*/
 159                 .callback = set_bios_reboot,
 160                 .ident = "Dell OptiPlex 745",
 161                 .matches = {
 162                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 163                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
 164                         DMI_MATCH(DMI_BOARD_NAME, "0MM599"),
 165                 },
 166         },
 167         {       /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */
 168                 .callback = set_bios_reboot,
 169                 .ident = "Dell OptiPlex 745",
 170                 .matches = {
 171                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 172                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
 173                         DMI_MATCH(DMI_BOARD_NAME, "0KW626"),
 174                 },
 175         },
 176         {       /* Handle problems with rebooting on Dell 2400's */
 177                 .callback = set_bios_reboot,
 178                 .ident = "Dell PowerEdge 2400",
 179                 .matches = {
 180                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
 181                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"),
 182                 },
 183         },
 184         {       /* Handle problems with rebooting on Dell T5400's */
 185                 .callback = set_bios_reboot,
 186                 .ident = "Dell Precision T5400",
 187                 .matches = {
 188                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 189                         DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T5400"),
 190                 },
 191         },
 192         {       /* Handle problems with rebooting on HP laptops */
 193                 .callback = set_bios_reboot,
 194                 .ident = "HP Compaq Laptop",
 195                 .matches = {
 196                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 197                         DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"),
 198                 },
 199         },
 200         { }
 201 };
 202
 203 static int __init reboot_init(void)
 204 {
 205         dmi_check_system(reboot_dmi_table);
 206         return 0;
 207 }
 208 core_initcall(reboot_init);
 209
 210 /* The following code and data reboots the machine by switching to real
 211    mode and jumping to the BIOS reset entry point, as if the CPU has
 212    really been reset.  The previous version asked the keyboard
 213    controller to pulse the CPU reset line, which is more thorough, but
 214    doesn't work with at least one type of 486 motherboard.  It is easy
 215    to stop this code working; hence the copious comments. */
 216 static const unsigned long long
 217 real_mode_gdt_entries [3] =
 218 {
 219         0x0000000000000000ULL,  /* Null descriptor */
 220         0x00009b000000ffffULL,  /* 16-bit real-mode 64k code at 0x00000000 */
 221         0x000093000100ffffULL   /* 16-bit real-mode 64k data at 0x00000100 */
 222 };
 223
 224 static const struct desc_ptr
 225 real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, (long)real_mode_gdt_entries },
 226 real_mode_idt = { 0x3ff, 0 };
 227
 228 /* This is 16-bit protected mode code to disable paging and the cache,
 229    switch to real mode and jump to the BIOS reset code.
 230
 231    The instruction that switches to real mode by writing to CR0 must be
 232    followed immediately by a far jump instruction, which set CS to a
 233    valid value for real mode, and flushes the prefetch queue to avoid
 234    running instructions that have already been decoded in protected
 235    mode.
 236
 237    Clears all the flags except ET, especially PG (paging), PE
 238    (protected-mode enable) and TS (task switch for coprocessor state
 239    save).  Flushes the TLB after paging has been disabled.  Sets CD and
 240    NW, to disable the cache on a 486, and invalidates the cache.  This
 241    is more like the state of a 486 after reset.  I don't know if
 242    something else should be done for other chips.
 243
 244    More could be done here to set up the registers as if a CPU reset had
 245    occurred; hopefully real BIOSs don't assume much. */
 246 static const unsigned char real_mode_switch [] =
 247 {
 248         0x66, 0x0f, 0x20, 0xc0,                 /*    movl  %cr0,%eax        */
 249         0x66, 0x83, 0xe0, 0x11,                 /*    andl  $0x00000011,%eax */
 250         0x66, 0x0d, 0x00, 0x00, 0x00, 0x60,     /*    orl   $0x60000000,%eax */
 251         0x66, 0x0f, 0x22, 0xc0,                 /*    movl  %eax,%cr0        */
 252         0x66, 0x0f, 0x22, 0xd8,                 /*    movl  %eax,%cr3        */
 253         0x66, 0x0f, 0x20, 0xc3,                 /*    movl  %cr0,%ebx        */
 254         0x66, 0x81, 0xe3, 0x00, 0x00, 0x00, 0x60,       /*    andl  $0x60000000,%ebx */
 255         0x74, 0x02,                             /*    jz    f                */
 256         0x0f, 0x09,                             /*    wbinvd                 */
 257         0x24, 0x10,                             /* f: andb  $0x10,al         */
 258         0x66, 0x0f, 0x22, 0xc0                  /*    movl  %eax,%cr0        */
 259 };
 260 static const unsigned char jump_to_bios [] =
 261 {
 262         0xea, 0x00, 0x00, 0xff, 0xff            /*    ljmp  $0xffff,$0x0000  */
 263 };
 264
 265 /*
 266  * Switch to real mode and then execute the code
 267  * specified by the code and length parameters.
 268  * We assume that length will aways be less that 100!
 269  */
 270 void machine_real_restart(const unsigned char *code, int length)
 271 {
 272         local_irq_disable();
 273
 274         /* Write zero to CMOS register number 0x0f, which the BIOS POST
 275            routine will recognize as telling it to do a proper reboot.  (Well
 276            that's what this book in front of me says -- it may only apply to
 277            the Phoenix BIOS though, it's not clear).  At the same time,
 278            disable NMIs by setting the top bit in the CMOS address register,
 279            as we're about to do peculiar things to the CPU.  I'm not sure if
 280            `outb_p' is needed instead of just `outb'.  Use it to be on the
 281            safe side.  (Yes, CMOS_WRITE does outb_p's. -  Paul G.)
 282          */
 283         spin_lock(&rtc_lock);
 284         CMOS_WRITE(0x00, 0x8f);
 285         spin_unlock(&rtc_lock);
 286
 287         /* Remap the kernel at virtual address zero, as well as offset zero
 288            from the kernel segment.  This assumes the kernel segment starts at
 289            virtual address PAGE_OFFSET. */
 290         memcpy(swapper_pg_dir, swapper_pg_dir + KERNEL_PGD_BOUNDARY,
 291                 sizeof(swapper_pg_dir [0]) * KERNEL_PGD_PTRS);
 292
 293         /*
 294          * Use `swapper_pg_dir' as our page directory.
 295          */
 296         load_cr3(swapper_pg_dir);
 297
 298         /* Write 0x1234 to absolute memory location 0x472.  The BIOS reads
 299            this on booting to tell it to "Bypass memory test (also warm
 300            boot)".  This seems like a fairly standard thing that gets set by
 301            REBOOT.COM programs, and the previous reset routine did this
 302            too. */
 303         *((unsigned short *)0x472) = reboot_mode;
 304
 305         /* For the switch to real mode, copy some code to low memory.  It has
 306            to be in the first 64k because it is running in 16-bit mode, and it
 307            has to have the same physical and virtual address, because it turns
 308            off paging.  Copy it near the end of the first page, out of the way
 309            of BIOS variables. */
 310         memcpy((void *)(0x1000 - sizeof(real_mode_switch) - 100),
 311                 real_mode_switch, sizeof (real_mode_switch));
 312         memcpy((void *)(0x1000 - 100), code, length);
 313
 314         /* Set up the IDT for real mode. */
 315         load_idt(&real_mode_idt);
 316
 317         /* Set up a GDT from which we can load segment descriptors for real
 318            mode.  The GDT is not used in real mode; it is just needed here to
 319            prepare the descriptors. */
 320         load_gdt(&real_mode_gdt);
 321
 322         /* Load the data segment registers, and thus the descriptors ready for
 323            real mode.  The base address of each segment is 0x100, 16 times the
 324            selector value being loaded here.  This is so that the segment
 325            registers don't have to be reloaded after switching to real mode:
 326            the values are consistent for real mode operation already. */
 327         __asm__ __volatile__ ("movl $0x0010,%%eax\n"
 328                                 "\tmovl %%eax,%%ds\n"
 329                                 "\tmovl %%eax,%%es\n"
 330                                 "\tmovl %%eax,%%fs\n"
 331                                 "\tmovl %%eax,%%gs\n"
 332                                 "\tmovl %%eax,%%ss" : : : "eax");
 333
 334         /* Jump to the 16-bit code that we copied earlier.  It disables paging
 335            and the cache, switches to real mode, and jumps to the BIOS reset
 336            entry point. */
 337         __asm__ __volatile__ ("ljmp $0x0008,%0"
 338                                 :
 339                                 : "i" ((void *)(0x1000 - sizeof (real_mode_switch) - 100)));
 340 }
 341 #ifdef CONFIG_APM_MODULE
 342 EXPORT_SYMBOL(machine_real_restart);
 343 #endif
 344
 345 #endif /* CONFIG_X86_32 */
 346
 347 static inline void kb_wait(void)
 348 {
 349         int i;
 350
 351         for (i = 0; i < 0x10000; i++) {
 352                 if ((inb(0x64) & 0x02) == 0)
 353                         break;
 354                 udelay(2);
 355         }
 356 }
 357
 358 void __attribute__((weak)) mach_reboot_fixups(void)
 359 {
 360 }
 361
 362 static void native_machine_emergency_restart(void)
 363 {
 364         int i;
 365
 366         /* Tell the BIOS if we want cold or warm reboot */
 367         *((unsigned short *)__va(0x472)) = reboot_mode;
 368
 369         for (;;) {
 370                 /* Could also try the reset bit in the Hammer NB */
 371                 switch (reboot_type) {
 372                 case BOOT_KBD:
 373                         mach_reboot_fixups(); /* for board specific fixups */
 374
 375                         for (i = 0; i < 10; i++) {
 376                                 kb_wait();
 377                                 udelay(50);
 378                                 outb(0xfe, 0x64); /* pulse reset low */
 379                                 udelay(50);
 380                         }
 381
 382                 case BOOT_TRIPLE:
 383                         load_idt(&no_idt);
 384                         __asm__ __volatile__("int3");
 385
 386                         reboot_type = BOOT_KBD;
 387                         break;
 388
 389 #ifdef CONFIG_X86_32
 390                 case BOOT_BIOS:
 391                         machine_real_restart(jump_to_bios, sizeof(jump_to_bios));
 392
 393                         reboot_type = BOOT_KBD;
 394                         break;
 395 #endif
 396
 397                 case BOOT_ACPI:
 398                         acpi_reboot();
 399                         reboot_type = BOOT_KBD;
 400                         break;
 401
 402
 403                 case BOOT_EFI:
 404                         if (efi_enabled)
 405                                 efi.reset_system(reboot_mode ? EFI_RESET_WARM : EFI_RESET_COLD,
 406                                                  EFI_SUCCESS, 0, NULL);
 407
 408                         reboot_type = BOOT_KBD;
 409                         break;
 410                 }
 411         }
 412 }
 413
 414 void native_machine_shutdown(void)
 415 {
 416         /* Stop the cpus and apics */
 417 #ifdef CONFIG_SMP
 418
 419         /* The boot cpu is always logical cpu 0 */
 420         int reboot_cpu_id = 0;
 421
 422 #ifdef CONFIG_X86_32
 423         /* See if there has been given a command line override */
 424         if ((reboot_cpu != -1) && (reboot_cpu < NR_CPUS) &&
 425                 cpu_online(reboot_cpu))
 426                 reboot_cpu_id = reboot_cpu;
 427 #endif
 428
 429         /* Make certain the cpu I'm about to reboot on is online */
 430         if (!cpu_online(reboot_cpu_id))
 431                 reboot_cpu_id = smp_processor_id();
 432
 433         /* Make certain I only run on the appropriate processor */
 434         set_cpus_allowed_ptr(current, &cpumask_of_cpu(reboot_cpu_id));
 435
 436         /* O.K Now that I'm on the appropriate processor,
 437          * stop all of the others.
 438          */
 439         smp_send_stop();
 440 #endif
 441
 442         lapic_shutdown();
 443
 444 #ifdef CONFIG_X86_IO_APIC
 445         disable_IO_APIC();
 446 #endif
 447
 448 #ifdef CONFIG_HPET_TIMER
 449         hpet_disable();
 450 #endif
 451
 452 #ifdef CONFIG_X86_64
 453         pci_iommu_shutdown();
 454 #endif
 455 }
 456
 457 static void native_machine_restart(char *__unused)
 458 {
 459         printk("machine restart\n");
 460
 461         if (!reboot_force)
 462                 machine_shutdown();
 463         machine_emergency_restart();
 464 }
 465
 466 static void native_machine_halt(void)
 467 {
 468 }
 469
 470 static void native_machine_power_off(void)
 471 {
 472         if (pm_power_off) {
 473                 if (!reboot_force)
 474                         machine_shutdown();
 475                 pm_power_off();
 476         }
 477 }
 478
 479 struct machine_ops machine_ops = {
 480         .power_off = native_machine_power_off,
 481         .shutdown = native_machine_shutdown,
 482         .emergency_restart = native_machine_emergency_restart,
 483         .restart = native_machine_restart,
 484         .halt = native_machine_halt,
 485 #ifdef CONFIG_KEXEC
 486         .crash_shutdown = native_machine_crash_shutdown,
 487 #endif
 488 };
 489
 490 void machine_power_off(void)
 491 {
 492         machine_ops.power_off();
 493 }
 494
 495 void machine_shutdown(void)
 496 {
 497         machine_ops.shutdown();
 498 }
 499
 500 void machine_emergency_restart(void)
 501 {
 502         machine_ops.emergency_restart();
 503 }
 504
 505 void machine_restart(char *cmd)
 506 {
 507         machine_ops.restart(cmd);
 508 }
 509
 510 void machine_halt(void)
 511 {
 512         machine_ops.halt();
 513 }
 514
 515 #ifdef CONFIG_KEXEC
 516 void machine_crash_shutdown(struct pt_regs *regs)
 517 {
 518         machine_ops.crash_shutdown(regs);
 519 }
 520 #endif