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

#include <linux/mm.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/mc146818rtc.h>
#include <linux/efi.h>
#include <linux/dmi.h>
#include <linux/ctype.h>
#include <linux/pm.h>
#include <linux/reboot.h>
#include <asm/uaccess.h>
#include <asm/apic.h>
#include <asm/desc.h>
#include "mach_reboot.h"
#include <asm/reboot_fixups.h>
#include <asm/reboot.h>

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

static int reboot_mode;
static int reboot_thru_bios;

#ifdef CONFIG_SMP
static int reboot_cpu = -1;
#endif
static int __init reboot_setup(char *str)
{
	while(1) {
		switch (*str) {
		case 'w': /* "warm" reboot (no memory testing etc) */
			reboot_mode = 0x1234;
			break;
		case 'c': /* "cold" reboot (with memory testing etc) */
			reboot_mode = 0x0;
			break;
		case 'b': /* "bios" reboot by jumping through the BIOS */
			reboot_thru_bios = 1;
			break;
		case 'h': /* "hard" reboot by toggling RESET and/or crashing the CPU */
			reboot_thru_bios = 0;
			break;
#ifdef CONFIG_SMP
		case 's': /* "smp" reboot by executing reset on BSP or other CPU*/
			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
		}
		if((str = strchr(str,',')) != NULL)
			str++;
		else
			break;
	}
	return 1;
}

__setup("reboot=", reboot_setup);

/*
 * 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_thru_bios) {
		reboot_thru_bios = 1;
		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"),
			DMI_MATCH(DMI_BOARD_NAME, "0WF810"),
		},
	},
	{	/* 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 Xgt_desc_struct
real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, (long)real_mode_gdt_entries },
real_mode_idt = { 0x3ff, 0 },
no_idt = { 0, 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 + USER_PGD_PTRS,
		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

static void native_machine_shutdown(void)
{
#ifdef CONFIG_SMP
	int reboot_cpu_id;

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

	/* See if there has been given a command line override */
	if ((reboot_cpu != -1) && (reboot_cpu < NR_CPUS) &&
		cpu_isset(reboot_cpu, cpu_online_map)) {
		reboot_cpu_id = reboot_cpu;
	}

	/* Make certain the cpu I'm rebooting on is online */
	if (!cpu_isset(reboot_cpu_id, cpu_online_map)) {
		reboot_cpu_id = smp_processor_id();
	}

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

	/* O.K. Now that I'm on the appropriate processor, stop
	 * all of the others, and disable their local APICs.
	 */

	smp_send_stop();
#endif /* CONFIG_SMP */

	lapic_shutdown();

#ifdef CONFIG_X86_IO_APIC
	disable_IO_APIC();
#endif
}

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

static void native_machine_emergency_restart(void)
{
	if (!reboot_thru_bios) {
		if (efi_enabled) {
			efi.reset_system(EFI_RESET_COLD, EFI_SUCCESS, 0, NULL);
			load_idt(&no_idt);
			__asm__ __volatile__("int3");
		}
		/* rebooting needs to touch the page at absolute addr 0 */
		*((unsigned short *)__va(0x472)) = reboot_mode;
		for (;;) {
			mach_reboot_fixups(); /* for board specific fixups */
			mach_reboot();
			/* That didn't work - force a triple fault.. */
			load_idt(&no_idt);
			__asm__ __volatile__("int3");
		}
	}
	if (efi_enabled)
		efi.reset_system(EFI_RESET_WARM, EFI_SUCCESS, 0, NULL);

	machine_real_restart(jump_to_bios, sizeof(jump_to_bios));
}

static void native_machine_restart(char * __unused)
{
	machine_shutdown();
	machine_emergency_restart();
}

static void native_machine_halt(void)
{
}

static void native_machine_power_off(void)
{
	if (pm_power_off) {
		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,
};

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