arch/x86/kernel/reboot.c

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