[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;
/*
 * Keyboard reset and triple fault may result in INIT, not RESET, which
 * doesn't work when we're in vmx root mode.  Try ACPI first.
 */
enum reboot_type reboot_type = BOOT_ACPI;
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;
c7ffa6c2 AK	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;
4d022e35	37	int reboot_force;
1da177e4	38
4d022e35	39	#if defined(CONFIG_X86_32) && defined(CONFIG_SMP)
1da177e4	40	static int reboot_cpu = -1;
1da177e4	41	#endif
4d022e35 MB	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	*/
1da177e4 LT	54	static int __init reboot_setup(char *str)
1da177e4 LT	55	{
4d022e35	56	for (;;) {
1da177e4	57	switch (*str) {
4d022e35	58	case 'w':
1da177e4 LT	59	reboot_mode = 0x1234;
1da177e4 LT	60	break;
4d022e35 MB	61
	62	case 'c':
	63	reboot_mode = 0;
1da177e4	64	break;
4d022e35 MB	65
4d022e35 MB	66	#ifdef CONFIG_X86_32
1da177e4	67	#ifdef CONFIG_SMP
4d022e35	68	case 's':
6f673d83	69	if (isdigit(*(str+1))) {
1da177e4	70	reboot_cpu = (int) (*(str+1) - '0');
6f673d83	71	if (isdigit(*(str+2)))
1da177e4 LT	72	reboot_cpu = reboot_cpu10 + (int)((str+2) - '0');
1da177e4 LT	73	}
4d022e35 MB	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 */
1da177e4	77	break;
4d022e35 MB	78	#endif /* CONFIG_SMP */
	79
	80	case 'b':
1da177e4	81	#endif
4d022e35 MB	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;
1da177e4	92	}
4d022e35 MB	93
	94	str = strchr(str, ',');
	95	if (str)
1da177e4 LT	96	str++;
	97	else
	98	break;
	99	}
	100	return 1;
	101	}
	102
	103	__setup("reboot=", reboot_setup);
	104
4d022e35 MB	105
4d022e35 MB	106	#ifdef CONFIG_X86_32
1da177e4 LT	107	/*
	108	* Reboot options and system auto-detection code provided by
	109	* Dell Inc. so their systems "just work". :-)
	110	*/
	111
	112	/*
4d022e35 MB	113	* Some machines require the "reboot=b" commandline option,
4d022e35 MB	114	* this quirk makes that automatic.
1da177e4	115	*/
1855256c	116	static int __init set_bios_reboot(const struct dmi_system_id *d)
1da177e4	117	{
4d022e35 MB	118	if (reboot_type != BOOT_BIOS) {
4d022e35 MB	119	reboot_type = BOOT_BIOS;
1da177e4 LT	120	printk(KERN_INFO "%s series board detected. Selecting BIOS-method for reboots.\n", d->ident);
	121	}
	122	return 0;
	123	}
	124
1da177e4	125	static struct dmi_system_id __initdata reboot_dmi_table[] = {
b9e82af8 TG	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	},
1da177e4	134	{ /* Handle problems with rebooting on Dell 1300's */
dd2a1305	135	.callback = set_bios_reboot,
1da177e4 LT	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	},
df2edcf3 JJ	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"),
df2edcf3 JJ	156	},
df2edcf3 JJ	157	},
fc115bf1 CK	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	},
fc1c8925 HAA	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	},
1da177e4 LT	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	},
fab3b58d IM	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	},
766c3f94	192	{ /* Handle problems with rebooting on HP laptops */
d91b14c4	193	.callback = set_bios_reboot,
766c3f94	194	.ident = "HP Compaq Laptop",
d91b14c4 TV	195	.matches = {
d91b14c4 TV	196	DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
766c3f94	197	DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"),
d91b14c4 TV	198	},
d91b14c4 TV	199	},
1da177e4 LT	200	{ }
	201	};
	202
	203	static int __init reboot_init(void)
	204	{
	205	dmi_check_system(reboot_dmi_table);
	206	return 0;
	207	}
1da177e4 LT	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. */
ebdd561a	216	static const unsigned long long
1da177e4 LT	217	real_mode_gdt_entries [3] =
	218	{
	219	0x0000000000000000ULL, /* Null descriptor */
ebdd561a JB	220	0x00009b000000ffffULL, /* 16-bit real-mode 64k code at 0x00000000 */
ebdd561a JB	221	0x000093000100ffffULL /* 16-bit real-mode 64k data at 0x00000100 */
1da177e4 LT	222	};
1da177e4 LT	223
ebdd561a	224	static const struct desc_ptr
05f4a3ec	225	real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, (long)real_mode_gdt_entries },
4d022e35	226	real_mode_idt = { 0x3ff, 0 };
1da177e4 LT	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. */
ebdd561a	246	static const unsigned char real_mode_switch [] =
1da177e4 LT	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	};
ebdd561a	260	static const unsigned char jump_to_bios [] =
1da177e4 LT	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	*/
ebdd561a	270	void machine_real_restart(const unsigned char *code, int length)
1da177e4	271	{
1da177e4 LT	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	*/
62dbc210	283	spin_lock(&rtc_lock);
1da177e4	284	CMOS_WRITE(0x00, 0x8f);
62dbc210	285	spin_unlock(&rtc_lock);
1da177e4 LT	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. */
68db065c	290	memcpy(swapper_pg_dir, swapper_pg_dir + KERNEL_PGD_BOUNDARY,
4d022e35	291	sizeof(swapper_pg_dir [0]) * KERNEL_PGD_PTRS);
1da177e4 LT	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. */
1da177e4 LT	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. */
4d022e35	310	memcpy((void *)(0x1000 - sizeof(real_mode_switch) - 100),
1da177e4	311	real_mode_switch, sizeof (real_mode_switch));
4d022e35	312	memcpy((void *)(0x1000 - 100), code, length);
1da177e4 LT	313
1da177e4 LT	314	/* Set up the IDT for real mode. */
4d37e7e3	315	load_idt(&real_mode_idt);
1da177e4 LT	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. */
4d37e7e3	320	load_gdt(&real_mode_gdt);
1da177e4 LT	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. */
1da177e4 LT	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. */
1da177e4 LT	337	__asm__ __volatile__ ("ljmp $0x0008,%0"
1da177e4 LT	338	:
4d022e35	339	: "i" ((void *)(0x1000 - sizeof (real_mode_switch) - 100)));
1da177e4	340	}
129f6946 AD	341	#ifdef CONFIG_APM_MODULE
	342	EXPORT_SYMBOL(machine_real_restart);
	343	#endif
1da177e4	344
4d022e35 MB	345	#endif /* CONFIG_X86_32 */
	346
	347	static inline void kb_wait(void)
	348	{
	349	int i;
	350
c84d6af8 AC	351	for (i = 0; i < 0x10000; i++) {
c84d6af8 AC	352	if ((inb(0x64) & 0x02) == 0)
4d022e35	353	break;
c84d6af8 AC	354	udelay(2);
c84d6af8 AC	355	}
4d022e35 MB	356	}
4d022e35 MB	357
7432d149 IM	358	void __attribute__((weak)) mach_reboot_fixups(void)
	359	{
	360	}
	361
416e2d63	362	static void native_machine_emergency_restart(void)
1da177e4	363	{
4d022e35 MB	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:
7432d149 IM	373	mach_reboot_fixups(); /* for board specific fixups */
7432d149 IM	374
4d022e35 MB	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:
ebdd561a	383	load_idt(&no_idt);
4d022e35 MB	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
3c62c625	414	void native_machine_shutdown(void)
4d022e35 MB	415	{
4d022e35 MB	416	/* Stop the cpus and apics */
1da177e4	417	#ifdef CONFIG_SMP
dd2a1305 EB	418
dd2a1305 EB	419	/* The boot cpu is always logical cpu 0 */
65c01184	420	int reboot_cpu_id = 0;
dd2a1305	421
4d022e35	422	#ifdef CONFIG_X86_32
dd2a1305	423	/* See if there has been given a command line override */
d8e392e7	424	if ((reboot_cpu != -1) && (reboot_cpu < NR_CPUS) &&
0bc3cc03	425	cpu_online(reboot_cpu))
dd2a1305	426	reboot_cpu_id = reboot_cpu;
4d022e35	427	#endif
1da177e4	428
4d022e35	429	/* Make certain the cpu I'm about to reboot on is online */
0bc3cc03	430	if (!cpu_online(reboot_cpu_id))
dd2a1305	431	reboot_cpu_id = smp_processor_id();
dd2a1305 EB	432
dd2a1305 EB	433	/* Make certain I only run on the appropriate processor */
0bc3cc03	434	set_cpus_allowed_ptr(current, &cpumask_of_cpu(reboot_cpu_id));
dd2a1305	435
4d022e35 MB	436	/* O.K Now that I'm on the appropriate processor,
4d022e35 MB	437	* stop all of the others.
1da177e4 LT	438	*/
1da177e4 LT	439	smp_send_stop();
4d022e35	440	#endif
1da177e4 LT	441
	442	lapic_shutdown();
	443
	444	#ifdef CONFIG_X86_IO_APIC
	445	disable_IO_APIC();
	446	#endif
4d022e35	447
c86c7fbc OH	448	#ifdef CONFIG_HPET_TIMER
	449	hpet_disable();
	450	#endif
dd2a1305	451
4d022e35 MB	452	#ifdef CONFIG_X86_64
	453	pci_iommu_shutdown();
	454	#endif
973efae2 JF	455	}
973efae2 JF	456
416e2d63	457	static void native_machine_restart(char *__unused)
dd2a1305	458	{
4d022e35	459	printk("machine restart\n");
1da177e4	460
4d022e35 MB	461	if (!reboot_force)
4d022e35 MB	462	machine_shutdown();
4a1421f8 EB	463	machine_emergency_restart();
	464	}
	465
416e2d63	466	static void native_machine_halt(void)
1da177e4 LT	467	{
	468	}
	469
416e2d63	470	static void native_machine_power_off(void)
1da177e4	471	{
6e3fbee5	472	if (pm_power_off) {
4d022e35 MB	473	if (!reboot_force)
4d022e35 MB	474	machine_shutdown();
1da177e4	475	pm_power_off();
6e3fbee5	476	}
1da177e4 LT	477	}
1da177e4 LT	478
07f3331c	479	struct machine_ops machine_ops = {
416e2d63 JB	480	.power_off = native_machine_power_off,
	481	.shutdown = native_machine_shutdown,
	482	.emergency_restart = native_machine_emergency_restart,
	483	.restart = native_machine_restart,
ed23dc6f GC	484	.halt = native_machine_halt,
	485	#ifdef CONFIG_KEXEC
	486	.crash_shutdown = native_machine_crash_shutdown,
	487	#endif
07f3331c	488	};
416e2d63 JB	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
ed23dc6f GC	515	#ifdef CONFIG_KEXEC
	516	void machine_crash_shutdown(struct pt_regs *regs)
	517	{
	518	machine_ops.crash_shutdown(regs);
	519	}
	520	#endif