[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 long no_idt[3];
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 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 unsigned long long
real_mode_gdt_entries [3] =
{
	0x0000000000000000ULL,	/* Null descriptor */
	0x00009a000000ffffULL,	/* 16-bit real-mode 64k code at 0x00000000 */
	0x000092000100ffffULL	/* 16-bit real-mode 64k data at 0x00000100 */
};

static 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 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 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(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((const struct desc_ptr *)&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
	int reboot_cpu_id;

	/* The boot cpu is always logical cpu 0 */
	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
4d022e35	30	static long no_idt[3];
1da177e4	31	static int reboot_mode;
4d022e35 MB	32	enum reboot_type reboot_type = BOOT_KBD;
4d022e35 MB	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	},
766c3f94	180	{ /* Handle problems with rebooting on HP laptops */
d91b14c4	181	.callback = set_bios_reboot,
766c3f94	182	.ident = "HP Compaq Laptop",
d91b14c4 TV	183	.matches = {
d91b14c4 TV	184	DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
766c3f94	185	DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"),
d91b14c4 TV	186	},
d91b14c4 TV	187	},
1da177e4 LT	188	{ }
	189	};
	190
	191	static int __init reboot_init(void)
	192	{
	193	dmi_check_system(reboot_dmi_table);
	194	return 0;
	195	}
1da177e4 LT	196	core_initcall(reboot_init);
	197
	198	/* The following code and data reboots the machine by switching to real
	199	mode and jumping to the BIOS reset entry point, as if the CPU has
	200	really been reset. The previous version asked the keyboard
	201	controller to pulse the CPU reset line, which is more thorough, but
	202	doesn't work with at least one type of 486 motherboard. It is easy
	203	to stop this code working; hence the copious comments. */
1da177e4 LT	204	static unsigned long long
	205	real_mode_gdt_entries [3] =
	206	{
	207	0x0000000000000000ULL, /* Null descriptor */
	208	0x00009a000000ffffULL, /* 16-bit real-mode 64k code at 0x00000000 */
	209	0x000092000100ffffULL /* 16-bit real-mode 64k data at 0x00000100 */
	210	};
	211
6b68f01b	212	static struct desc_ptr
05f4a3ec	213	real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, (long)real_mode_gdt_entries },
4d022e35	214	real_mode_idt = { 0x3ff, 0 };
1da177e4 LT	215
	216	/* This is 16-bit protected mode code to disable paging and the cache,
	217	switch to real mode and jump to the BIOS reset code.
	218
	219	The instruction that switches to real mode by writing to CR0 must be
	220	followed immediately by a far jump instruction, which set CS to a
	221	valid value for real mode, and flushes the prefetch queue to avoid
	222	running instructions that have already been decoded in protected
	223	mode.
	224
	225	Clears all the flags except ET, especially PG (paging), PE
	226	(protected-mode enable) and TS (task switch for coprocessor state
	227	save). Flushes the TLB after paging has been disabled. Sets CD and
	228	NW, to disable the cache on a 486, and invalidates the cache. This
	229	is more like the state of a 486 after reset. I don't know if
	230	something else should be done for other chips.
	231
	232	More could be done here to set up the registers as if a CPU reset had
	233	occurred; hopefully real BIOSs don't assume much. */
1da177e4 LT	234	static unsigned char real_mode_switch [] =
	235	{
	236	0x66, 0x0f, 0x20, 0xc0, /* movl %cr0,%eax */
	237	0x66, 0x83, 0xe0, 0x11, /* andl $0x00000011,%eax */
	238	0x66, 0x0d, 0x00, 0x00, 0x00, 0x60, /* orl $0x60000000,%eax */
	239	0x66, 0x0f, 0x22, 0xc0, /* movl %eax,%cr0 */
	240	0x66, 0x0f, 0x22, 0xd8, /* movl %eax,%cr3 */
	241	0x66, 0x0f, 0x20, 0xc3, /* movl %cr0,%ebx */
	242	0x66, 0x81, 0xe3, 0x00, 0x00, 0x00, 0x60, /* andl $0x60000000,%ebx */
	243	0x74, 0x02, /* jz f */
	244	0x0f, 0x09, /* wbinvd */
	245	0x24, 0x10, /* f: andb $0x10,al */
	246	0x66, 0x0f, 0x22, 0xc0 /* movl %eax,%cr0 */
	247	};
	248	static unsigned char jump_to_bios [] =
	249	{
	250	0xea, 0x00, 0x00, 0xff, 0xff /* ljmp $0xffff,$0x0000 */
	251	};
	252
	253	/*
	254	* Switch to real mode and then execute the code
	255	* specified by the code and length parameters.
	256	* We assume that length will aways be less that 100!
	257	*/
	258	void machine_real_restart(unsigned char *code, int length)
	259	{
1da177e4 LT	260	local_irq_disable();
	261
	262	/* Write zero to CMOS register number 0x0f, which the BIOS POST
	263	routine will recognize as telling it to do a proper reboot. (Well
	264	that's what this book in front of me says -- it may only apply to
	265	the Phoenix BIOS though, it's not clear). At the same time,
	266	disable NMIs by setting the top bit in the CMOS address register,
	267	as we're about to do peculiar things to the CPU. I'm not sure if
	268	`outb_p' is needed instead of just `outb'. Use it to be on the
	269	safe side. (Yes, CMOS_WRITE does outb_p's. - Paul G.)
	270	*/
62dbc210	271	spin_lock(&rtc_lock);
1da177e4	272	CMOS_WRITE(0x00, 0x8f);
62dbc210	273	spin_unlock(&rtc_lock);
1da177e4 LT	274
	275	/* Remap the kernel at virtual address zero, as well as offset zero
	276	from the kernel segment. This assumes the kernel segment starts at
	277	virtual address PAGE_OFFSET. */
68db065c	278	memcpy(swapper_pg_dir, swapper_pg_dir + KERNEL_PGD_BOUNDARY,
4d022e35	279	sizeof(swapper_pg_dir [0]) * KERNEL_PGD_PTRS);
1da177e4 LT	280
	281	/*
	282	* Use `swapper_pg_dir' as our page directory.
	283	*/
	284	load_cr3(swapper_pg_dir);
	285
	286	/* Write 0x1234 to absolute memory location 0x472. The BIOS reads
	287	this on booting to tell it to "Bypass memory test (also warm
	288	boot)". This seems like a fairly standard thing that gets set by
	289	REBOOT.COM programs, and the previous reset routine did this
	290	too. */
1da177e4 LT	291	((unsigned short )0x472) = reboot_mode;
	292
	293	/* For the switch to real mode, copy some code to low memory. It has
	294	to be in the first 64k because it is running in 16-bit mode, and it
	295	has to have the same physical and virtual address, because it turns
	296	off paging. Copy it near the end of the first page, out of the way
	297	of BIOS variables. */
4d022e35	298	memcpy((void *)(0x1000 - sizeof(real_mode_switch) - 100),
1da177e4	299	real_mode_switch, sizeof (real_mode_switch));
4d022e35	300	memcpy((void *)(0x1000 - 100), code, length);
1da177e4 LT	301
1da177e4 LT	302	/* Set up the IDT for real mode. */
4d37e7e3	303	load_idt(&real_mode_idt);
1da177e4 LT	304
	305	/* Set up a GDT from which we can load segment descriptors for real
	306	mode. The GDT is not used in real mode; it is just needed here to
	307	prepare the descriptors. */
4d37e7e3	308	load_gdt(&real_mode_gdt);
1da177e4 LT	309
	310	/* Load the data segment registers, and thus the descriptors ready for
	311	real mode. The base address of each segment is 0x100, 16 times the
	312	selector value being loaded here. This is so that the segment
	313	registers don't have to be reloaded after switching to real mode:
	314	the values are consistent for real mode operation already. */
1da177e4 LT	315	__asm__ __volatile__ ("movl $0x0010,%%eax\n"
	316	"\tmovl %%eax,%%ds\n"
	317	"\tmovl %%eax,%%es\n"
	318	"\tmovl %%eax,%%fs\n"
	319	"\tmovl %%eax,%%gs\n"
	320	"\tmovl %%eax,%%ss" : : : "eax");
	321
	322	/* Jump to the 16-bit code that we copied earlier. It disables paging
	323	and the cache, switches to real mode, and jumps to the BIOS reset
	324	entry point. */
1da177e4 LT	325	__asm__ __volatile__ ("ljmp $0x0008,%0"
1da177e4 LT	326	:
4d022e35	327	: "i" ((void *)(0x1000 - sizeof (real_mode_switch) - 100)));
1da177e4	328	}
129f6946 AD	329	#ifdef CONFIG_APM_MODULE
	330	EXPORT_SYMBOL(machine_real_restart);
	331	#endif
1da177e4	332
4d022e35 MB	333	#endif /* CONFIG_X86_32 */
	334
	335	static inline void kb_wait(void)
	336	{
	337	int i;
	338
c84d6af8 AC	339	for (i = 0; i < 0x10000; i++) {
c84d6af8 AC	340	if ((inb(0x64) & 0x02) == 0)
4d022e35	341	break;
c84d6af8 AC	342	udelay(2);
c84d6af8 AC	343	}
4d022e35 MB	344	}
4d022e35 MB	345
7432d149 IM	346	void __attribute__((weak)) mach_reboot_fixups(void)
	347	{
	348	}
	349
416e2d63	350	static void native_machine_emergency_restart(void)
1da177e4	351	{
4d022e35 MB	352	int i;
	353
	354	/* Tell the BIOS if we want cold or warm reboot */
	355	((unsigned short )__va(0x472)) = reboot_mode;
	356
	357	for (;;) {
	358	/* Could also try the reset bit in the Hammer NB */
	359	switch (reboot_type) {
	360	case BOOT_KBD:
7432d149 IM	361	mach_reboot_fixups(); /* for board specific fixups */
7432d149 IM	362
4d022e35 MB	363	for (i = 0; i < 10; i++) {
	364	kb_wait();
	365	udelay(50);
	366	outb(0xfe, 0x64); /* pulse reset low */
	367	udelay(50);
	368	}
	369
	370	case BOOT_TRIPLE:
	371	load_idt((const struct desc_ptr *)&no_idt);
	372	__asm__ __volatile__("int3");
	373
	374	reboot_type = BOOT_KBD;
	375	break;
	376
	377	#ifdef CONFIG_X86_32
	378	case BOOT_BIOS:
	379	machine_real_restart(jump_to_bios, sizeof(jump_to_bios));
	380
	381	reboot_type = BOOT_KBD;
	382	break;
	383	#endif
	384
	385	case BOOT_ACPI:
	386	acpi_reboot();
	387	reboot_type = BOOT_KBD;
	388	break;
	389
	390
	391	case BOOT_EFI:
	392	if (efi_enabled)
	393	efi.reset_system(reboot_mode ? EFI_RESET_WARM : EFI_RESET_COLD,
	394	EFI_SUCCESS, 0, NULL);
	395
	396	reboot_type = BOOT_KBD;
	397	break;
	398	}
	399	}
	400	}
	401
3c62c625	402	void native_machine_shutdown(void)
4d022e35 MB	403	{
4d022e35 MB	404	/* Stop the cpus and apics */
1da177e4	405	#ifdef CONFIG_SMP
dd2a1305 EB	406	int reboot_cpu_id;
	407
	408	/* The boot cpu is always logical cpu 0 */
	409	reboot_cpu_id = 0;
	410
4d022e35	411	#ifdef CONFIG_X86_32
dd2a1305	412	/* See if there has been given a command line override */
d8e392e7	413	if ((reboot_cpu != -1) && (reboot_cpu < NR_CPUS) &&
6107a7c4	414	cpu_online(reboot_cpu))
dd2a1305	415	reboot_cpu_id = reboot_cpu;
4d022e35	416	#endif
1da177e4	417
4d022e35	418	/* Make certain the cpu I'm about to reboot on is online */
6107a7c4	419	if (!cpu_online(reboot_cpu_id))
dd2a1305	420	reboot_cpu_id = smp_processor_id();
dd2a1305 EB	421
dd2a1305 EB	422	/* Make certain I only run on the appropriate processor */
fc0e4748	423	set_cpus_allowed_ptr(current, &cpumask_of_cpu(reboot_cpu_id));
dd2a1305	424
4d022e35 MB	425	/* O.K Now that I'm on the appropriate processor,
4d022e35 MB	426	* stop all of the others.
1da177e4 LT	427	*/
1da177e4 LT	428	smp_send_stop();
4d022e35	429	#endif
1da177e4 LT	430
	431	lapic_shutdown();
	432
	433	#ifdef CONFIG_X86_IO_APIC
	434	disable_IO_APIC();
	435	#endif
4d022e35	436
c86c7fbc OH	437	#ifdef CONFIG_HPET_TIMER
	438	hpet_disable();
	439	#endif
dd2a1305	440
4d022e35 MB	441	#ifdef CONFIG_X86_64
	442	pci_iommu_shutdown();
	443	#endif
973efae2 JF	444	}
973efae2 JF	445
416e2d63	446	static void native_machine_restart(char *__unused)
dd2a1305	447	{
4d022e35	448	printk("machine restart\n");
1da177e4	449
4d022e35 MB	450	if (!reboot_force)
4d022e35 MB	451	machine_shutdown();
4a1421f8 EB	452	machine_emergency_restart();
	453	}
	454
416e2d63	455	static void native_machine_halt(void)
1da177e4 LT	456	{
	457	}
	458
416e2d63	459	static void native_machine_power_off(void)
1da177e4	460	{
6e3fbee5	461	if (pm_power_off) {
4d022e35 MB	462	if (!reboot_force)
4d022e35 MB	463	machine_shutdown();
1da177e4	464	pm_power_off();
6e3fbee5	465	}
1da177e4 LT	466	}
1da177e4 LT	467
07f3331c	468	struct machine_ops machine_ops = {
416e2d63 JB	469	.power_off = native_machine_power_off,
	470	.shutdown = native_machine_shutdown,
	471	.emergency_restart = native_machine_emergency_restart,
	472	.restart = native_machine_restart,
ed23dc6f GC	473	.halt = native_machine_halt,
	474	#ifdef CONFIG_KEXEC
	475	.crash_shutdown = native_machine_crash_shutdown,
	476	#endif
07f3331c	477	};
416e2d63 JB	478
	479	void machine_power_off(void)
	480	{
	481	machine_ops.power_off();
	482	}
	483
	484	void machine_shutdown(void)
	485	{
	486	machine_ops.shutdown();
	487	}
	488
	489	void machine_emergency_restart(void)
	490	{
	491	machine_ops.emergency_restart();
	492	}
	493
	494	void machine_restart(char *cmd)
	495	{
	496	machine_ops.restart(cmd);
	497	}
	498
	499	void machine_halt(void)
	500	{
	501	machine_ops.halt();
	502	}
	503
ed23dc6f GC	504	#ifdef CONFIG_KEXEC
	505	void machine_crash_shutdown(struct pt_regs *regs)
	506	{
	507	machine_ops.crash_shutdown(regs);
	508	}
	509	#endif