[deliverable/linux.git] / arch / x86 / kernel / reboot.c

#include <linux/module.h>
#include <linux/reboot.h>
#include <linux/init.h>
#include <linux/pm.h>
#include <linux/efi.h>
#include <acpi/reboot.h>
#include <asm/io.h>
#include <asm/apic.h>
#include <asm/desc.h>
#include <asm/hpet.h>
#include <asm/pgtable.h>
#include <asm/proto.h>
#include <asm/reboot_fixups.h>
#include <asm/reboot.h>

#ifdef CONFIG_X86_32
# include <linux/dmi.h>
# include <linux/ctype.h>
# include <linux/mc146818rtc.h>
#else
# include <asm/iommu.h>
#endif

/*
 * Power off function, if any
 */
void (*pm_power_off)(void);
EXPORT_SYMBOL(pm_power_off);

static const struct desc_ptr no_idt = {};
static int reboot_mode;
enum reboot_type reboot_type = BOOT_KBD;
int reboot_force;

#if defined(CONFIG_X86_32) && defined(CONFIG_SMP)
static int reboot_cpu = -1;
#endif

/* reboot=b[ios] | s[mp] | t[riple] | k[bd] | e[fi] [, [w]arm | [c]old]
   warm   Don't set the cold reboot flag
   cold   Set the cold reboot flag
   bios   Reboot by jumping through the BIOS (only for X86_32)
   smp    Reboot by executing reset on BSP or other CPU (only for X86_32)
   triple Force a triple fault (init)
   kbd    Use the keyboard controller. cold reset (default)
   acpi   Use the RESET_REG in the FADT
   efi    Use efi reset_system runtime service
   force  Avoid anything that could hang.
 */
static int __init reboot_setup(char *str)
{
	for (;;) {
		switch (*str) {
		case 'w':
			reboot_mode = 0x1234;
			break;

		case 'c':
			reboot_mode = 0;
			break;

#ifdef CONFIG_X86_32
#ifdef CONFIG_SMP
		case 's':
			if (isdigit(*(str+1))) {
				reboot_cpu = (int) (*(str+1) - '0');
				if (isdigit(*(str+2)))
					reboot_cpu = reboot_cpu*10 + (int)(*(str+2) - '0');
			}
				/* we will leave sorting out the final value
				   when we are ready to reboot, since we might not
				   have set up boot_cpu_id or smp_num_cpu */
			break;
#endif /* CONFIG_SMP */

		case 'b':
#endif
		case 'a':
		case 'k':
		case 't':
		case 'e':
			reboot_type = *str;
			break;

		case 'f':
			reboot_force = 1;
			break;
		}

		str = strchr(str, ',');
		if (str)
			str++;
		else
			break;
	}
	return 1;
}

__setup("reboot=", reboot_setup);


#ifdef CONFIG_X86_32
/*
 * Reboot options and system auto-detection code provided by
 * Dell Inc. so their systems "just work". :-)
 */

/*
 * Some machines require the "reboot=b"  commandline option,
 * this quirk makes that automatic.
 */
static int __init set_bios_reboot(const struct dmi_system_id *d)
{
	if (reboot_type != BOOT_BIOS) {
		reboot_type = BOOT_BIOS;
		printk(KERN_INFO "%s series board detected. Selecting BIOS-method for reboots.\n", d->ident);
	}
	return 0;
}

static struct dmi_system_id __initdata reboot_dmi_table[] = {
	{	/* Handle problems with rebooting on Dell E520's */
		.callback = set_bios_reboot,
		.ident = "Dell E520",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
			DMI_MATCH(DMI_PRODUCT_NAME, "Dell DM061"),
		},
	},
	{	/* Handle problems with rebooting on Dell 1300's */
		.callback = set_bios_reboot,
		.ident = "Dell PowerEdge 1300",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1300/"),
		},
	},
	{	/* Handle problems with rebooting on Dell 300's */
		.callback = set_bios_reboot,
		.ident = "Dell PowerEdge 300",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"),
		},
	},
	{       /* Handle problems with rebooting on Dell Optiplex 745's SFF*/
		.callback = set_bios_reboot,
		.ident = "Dell OptiPlex 745",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
			DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
		},
	},
	{       /* Handle problems with rebooting on Dell Optiplex 745's DFF*/
		.callback = set_bios_reboot,
		.ident = "Dell OptiPlex 745",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
			DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
			DMI_MATCH(DMI_BOARD_NAME, "0MM599"),
		},
	},
	{       /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */
		.callback = set_bios_reboot,
		.ident = "Dell OptiPlex 745",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
			DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
			DMI_MATCH(DMI_BOARD_NAME, "0KW626"),
		},
	},
	{	/* Handle problems with rebooting on Dell 2400's */
		.callback = set_bios_reboot,
		.ident = "Dell PowerEdge 2400",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"),
		},
	},
	{	/* Handle problems with rebooting on Dell T5400's */
		.callback = set_bios_reboot,
		.ident = "Dell Precision T5400",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
			DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T5400"),
		},
	},
	{	/* Handle problems with rebooting on HP laptops */
		.callback = set_bios_reboot,
		.ident = "HP Compaq Laptop",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
			DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"),
		},
	},
	{ }
};

static int __init reboot_init(void)
{
	dmi_check_system(reboot_dmi_table);
	return 0;
}
core_initcall(reboot_init);

/* The following code and data reboots the machine by switching to real
   mode and jumping to the BIOS reset entry point, as if the CPU has
   really been reset.  The previous version asked the keyboard
   controller to pulse the CPU reset line, which is more thorough, but
   doesn't work with at least one type of 486 motherboard.  It is easy
   to stop this code working; hence the copious comments. */
static const unsigned long long
real_mode_gdt_entries [3] =
{
	0x0000000000000000ULL,	/* Null descriptor */
	0x00009b000000ffffULL,	/* 16-bit real-mode 64k code at 0x00000000 */
	0x000093000100ffffULL	/* 16-bit real-mode 64k data at 0x00000100 */
};

static const struct desc_ptr
real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, (long)real_mode_gdt_entries },
real_mode_idt = { 0x3ff, 0 };

/* This is 16-bit protected mode code to disable paging and the cache,
   switch to real mode and jump to the BIOS reset code.

   The instruction that switches to real mode by writing to CR0 must be
   followed immediately by a far jump instruction, which set CS to a
   valid value for real mode, and flushes the prefetch queue to avoid
   running instructions that have already been decoded in protected
   mode.

   Clears all the flags except ET, especially PG (paging), PE
   (protected-mode enable) and TS (task switch for coprocessor state
   save).  Flushes the TLB after paging has been disabled.  Sets CD and
   NW, to disable the cache on a 486, and invalidates the cache.  This
   is more like the state of a 486 after reset.  I don't know if
   something else should be done for other chips.

   More could be done here to set up the registers as if a CPU reset had
   occurred; hopefully real BIOSs don't assume much. */
static const unsigned char real_mode_switch [] =
{
	0x66, 0x0f, 0x20, 0xc0,			/*    movl  %cr0,%eax        */
	0x66, 0x83, 0xe0, 0x11,			/*    andl  $0x00000011,%eax */
	0x66, 0x0d, 0x00, 0x00, 0x00, 0x60,	/*    orl   $0x60000000,%eax */
	0x66, 0x0f, 0x22, 0xc0,			/*    movl  %eax,%cr0        */
	0x66, 0x0f, 0x22, 0xd8,			/*    movl  %eax,%cr3        */
	0x66, 0x0f, 0x20, 0xc3,			/*    movl  %cr0,%ebx        */
	0x66, 0x81, 0xe3, 0x00, 0x00, 0x00, 0x60,	/*    andl  $0x60000000,%ebx */
	0x74, 0x02,				/*    jz    f                */
	0x0f, 0x09,				/*    wbinvd                 */
	0x24, 0x10,				/* f: andb  $0x10,al         */
	0x66, 0x0f, 0x22, 0xc0			/*    movl  %eax,%cr0        */
};
static const unsigned char jump_to_bios [] =
{
	0xea, 0x00, 0x00, 0xff, 0xff		/*    ljmp  $0xffff,$0x0000  */
};

/*
 * Switch to real mode and then execute the code
 * specified by the code and length parameters.
 * We assume that length will aways be less that 100!
 */
void machine_real_restart(const unsigned char *code, int length)
{
	local_irq_disable();

	/* Write zero to CMOS register number 0x0f, which the BIOS POST
	   routine will recognize as telling it to do a proper reboot.  (Well
	   that's what this book in front of me says -- it may only apply to
	   the Phoenix BIOS though, it's not clear).  At the same time,
	   disable NMIs by setting the top bit in the CMOS address register,
	   as we're about to do peculiar things to the CPU.  I'm not sure if
	   `outb_p' is needed instead of just `outb'.  Use it to be on the
	   safe side.  (Yes, CMOS_WRITE does outb_p's. -  Paul G.)
	 */
	spin_lock(&rtc_lock);
	CMOS_WRITE(0x00, 0x8f);
	spin_unlock(&rtc_lock);

	/* Remap the kernel at virtual address zero, as well as offset zero
	   from the kernel segment.  This assumes the kernel segment starts at
	   virtual address PAGE_OFFSET. */
	memcpy(swapper_pg_dir, swapper_pg_dir + KERNEL_PGD_BOUNDARY,
		sizeof(swapper_pg_dir [0]) * KERNEL_PGD_PTRS);

	/*
	 * Use `swapper_pg_dir' as our page directory.
	 */
	load_cr3(swapper_pg_dir);

	/* Write 0x1234 to absolute memory location 0x472.  The BIOS reads
	   this on booting to tell it to "Bypass memory test (also warm
	   boot)".  This seems like a fairly standard thing that gets set by
	   REBOOT.COM programs, and the previous reset routine did this
	   too. */
	*((unsigned short *)0x472) = reboot_mode;

	/* For the switch to real mode, copy some code to low memory.  It has
	   to be in the first 64k because it is running in 16-bit mode, and it
	   has to have the same physical and virtual address, because it turns
	   off paging.  Copy it near the end of the first page, out of the way
	   of BIOS variables. */
	memcpy((void *)(0x1000 - sizeof(real_mode_switch) - 100),
		real_mode_switch, sizeof (real_mode_switch));
	memcpy((void *)(0x1000 - 100), code, length);

	/* Set up the IDT for real mode. */
	load_idt(&real_mode_idt);

	/* Set up a GDT from which we can load segment descriptors for real
	   mode.  The GDT is not used in real mode; it is just needed here to
	   prepare the descriptors. */
	load_gdt(&real_mode_gdt);

	/* Load the data segment registers, and thus the descriptors ready for
	   real mode.  The base address of each segment is 0x100, 16 times the
	   selector value being loaded here.  This is so that the segment
	   registers don't have to be reloaded after switching to real mode:
	   the values are consistent for real mode operation already. */
	__asm__ __volatile__ ("movl $0x0010,%%eax\n"
				"\tmovl %%eax,%%ds\n"
				"\tmovl %%eax,%%es\n"
				"\tmovl %%eax,%%fs\n"
				"\tmovl %%eax,%%gs\n"
				"\tmovl %%eax,%%ss" : : : "eax");

	/* Jump to the 16-bit code that we copied earlier.  It disables paging
	   and the cache, switches to real mode, and jumps to the BIOS reset
	   entry point. */
	__asm__ __volatile__ ("ljmp $0x0008,%0"
				:
				: "i" ((void *)(0x1000 - sizeof (real_mode_switch) - 100)));
}
#ifdef CONFIG_APM_MODULE
EXPORT_SYMBOL(machine_real_restart);
#endif

#endif /* CONFIG_X86_32 */

static inline void kb_wait(void)
{
	int i;

	for (i = 0; i < 0x10000; i++) {
		if ((inb(0x64) & 0x02) == 0)
			break;
		udelay(2);
	}
}

void __attribute__((weak)) mach_reboot_fixups(void)
{
}

static void native_machine_emergency_restart(void)
{
	int i;

	/* Tell the BIOS if we want cold or warm reboot */
	*((unsigned short *)__va(0x472)) = reboot_mode;

	for (;;) {
		/* Could also try the reset bit in the Hammer NB */
		switch (reboot_type) {
		case BOOT_KBD:
			mach_reboot_fixups(); /* for board specific fixups */

			for (i = 0; i < 10; i++) {
				kb_wait();
				udelay(50);
				outb(0xfe, 0x64); /* pulse reset low */
				udelay(50);
			}

		case BOOT_TRIPLE:
			load_idt(&no_idt);
			__asm__ __volatile__("int3");

			reboot_type = BOOT_KBD;
			break;

#ifdef CONFIG_X86_32
		case BOOT_BIOS:
			machine_real_restart(jump_to_bios, sizeof(jump_to_bios));

			reboot_type = BOOT_KBD;
			break;
#endif

		case BOOT_ACPI:
			acpi_reboot();
			reboot_type = BOOT_KBD;
			break;


		case BOOT_EFI:
			if (efi_enabled)
				efi.reset_system(reboot_mode ? EFI_RESET_WARM : EFI_RESET_COLD,
						 EFI_SUCCESS, 0, NULL);

			reboot_type = BOOT_KBD;
			break;
		}
	}
}

void native_machine_shutdown(void)
{
	/* Stop the cpus and apics */
#ifdef CONFIG_SMP

	/* The boot cpu is always logical cpu 0 */
	int reboot_cpu_id = 0;

#ifdef CONFIG_X86_32
	/* See if there has been given a command line override */
	if ((reboot_cpu != -1) && (reboot_cpu < NR_CPUS) &&
		cpu_online(reboot_cpu))
		reboot_cpu_id = reboot_cpu;
#endif

	/* Make certain the cpu I'm about to reboot on is online */
	if (!cpu_online(reboot_cpu_id))
		reboot_cpu_id = smp_processor_id();

	/* Make certain I only run on the appropriate processor */
	set_cpus_allowed_ptr(current, &cpumask_of_cpu(reboot_cpu_id));

	/* O.K Now that I'm on the appropriate processor,
	 * stop all of the others.
	 */
	smp_send_stop();
#endif

	lapic_shutdown();

#ifdef CONFIG_X86_IO_APIC
	disable_IO_APIC();
#endif

#ifdef CONFIG_HPET_TIMER
	hpet_disable();
#endif

#ifdef CONFIG_X86_64
	pci_iommu_shutdown();
#endif
}

static void native_machine_restart(char *__unused)
{
	printk("machine restart\n");

	if (!reboot_force)
		machine_shutdown();
	machine_emergency_restart();
}

static void native_machine_halt(void)
{
}

static void native_machine_power_off(void)
{
	if (pm_power_off) {
		if (!reboot_force)
			machine_shutdown();
		pm_power_off();
	}
}

struct machine_ops machine_ops = {
	.power_off = native_machine_power_off,
	.shutdown = native_machine_shutdown,
	.emergency_restart = native_machine_emergency_restart,
	.restart = native_machine_restart,
	.halt = native_machine_halt,
#ifdef CONFIG_KEXEC
	.crash_shutdown = native_machine_crash_shutdown,
#endif
};

void machine_power_off(void)
{
	machine_ops.power_off();
}

void machine_shutdown(void)
{
	machine_ops.shutdown();
}

void machine_emergency_restart(void)
{
	machine_ops.emergency_restart();
}

void machine_restart(char *cmd)
{
	machine_ops.restart(cmd);
}

void machine_halt(void)
{
	machine_ops.halt();
}

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