[mirror_ubuntu-zesty-kernel.git] / arch / x86_64 / kernel / acpi / wakeup.S

.text
#include <linux/linkage.h>
#include <asm/segment.h>
#include <asm/pgtable.h>
#include <asm/page.h>
#include <asm/msr.h>

# Copyright 2003 Pavel Machek <pavel@suse.cz>, distribute under GPLv2
#
# wakeup_code runs in real mode, and at unknown address (determined at run-time).
# Therefore it must only use relative jumps/calls. 
#
# Do we need to deal with A20? It is okay: ACPI specs says A20 must be enabled
#
# If physical address of wakeup_code is 0x12345, BIOS should call us with
# cs = 0x1234, eip = 0x05
#

#define BEEP \
	inb	$97, %al; 	\
	outb	%al, $0x80; 	\
	movb	$3, %al; 	\
	outb	%al, $97; 	\
	outb	%al, $0x80; 	\
	movb	$-74, %al; 	\
	outb	%al, $67; 	\
	outb	%al, $0x80; 	\
	movb	$-119, %al; 	\
	outb	%al, $66; 	\
	outb	%al, $0x80; 	\
	movb	$15, %al; 	\
	outb	%al, $66;


ALIGN
	.align	16
ENTRY(wakeup_start)
wakeup_code:
	wakeup_code_start = .
	.code16

# Running in *copy* of this code, somewhere in low 1MB.

	movb	$0xa1, %al	;  outb %al, $0x80
	cli
	cld
	# setup data segment
	movw	%cs, %ax
	movw	%ax, %ds		# Make ds:0 point to wakeup_start
	movw	%ax, %ss

	# Data segment must be set up before we can see whether to beep.
	testl   $4, realmode_flags - wakeup_code
	jz      1f
	BEEP
1:

					# Private stack is needed for ASUS board
	mov	$(wakeup_stack - wakeup_code), %sp

	pushl	$0			# Kill any dangerous flags
	popfl

	movl	real_magic - wakeup_code, %eax
	cmpl	$0x12345678, %eax
	jne	bogus_real_magic

  	call	verify_cpu			# Verify the cpu supports long
						# mode
	testl	%eax, %eax
	jnz	no_longmode

	testl	$1, realmode_flags - wakeup_code
	jz	1f
	lcall   $0xc000,$3
	movw	%cs, %ax
	movw	%ax, %ds		# Bios might have played with that
	movw	%ax, %ss
1:

	testl	$2, realmode_flags - wakeup_code
	jz	1f
	mov	video_mode - wakeup_code, %ax
	call	mode_seta
1:

 	movw	$0xb800, %ax
	movw	%ax,%fs
	movw	$0x0e00 + 'L', %fs:(0x10)

	movb	$0xa2, %al	;  outb %al, $0x80
	
	mov	%ds, %ax			# Find 32bit wakeup_code addr
	movzx   %ax, %esi			# (Convert %ds:gdt to a liner ptr)
	shll    $4, %esi
						# Fix up the vectors
	addl    %esi, wakeup_32_vector - wakeup_code
	addl    %esi, wakeup_long64_vector - wakeup_code
	addl    %esi, gdt_48a + 2 - wakeup_code # Fixup the gdt pointer

	lidtl	%ds:idt_48a - wakeup_code
	lgdtl	%ds:gdt_48a - wakeup_code	# load gdt with whatever is
						# appropriate

	movl	$1, %eax			# protected mode (PE) bit
	lmsw	%ax				# This is it!
	jmp	1f
1:

	ljmpl   *(wakeup_32_vector - wakeup_code)

	.balign 4
wakeup_32_vector:
	.long   wakeup_32 - wakeup_code
	.word   __KERNEL32_CS, 0

	.code32
wakeup_32:
# Running in this code, but at low address; paging is not yet turned on.
	movb	$0xa5, %al	;  outb %al, $0x80

	movl	$__KERNEL_DS, %eax
	movl	%eax, %ds

	movw	$0x0e00 + 'i', %ds:(0xb8012)
	movb	$0xa8, %al	;  outb %al, $0x80;

	/*
	 * Prepare for entering 64bits mode
	 */

	/* Enable PAE */
	xorl	%eax, %eax
	btsl	$5, %eax
	movl	%eax, %cr4

	/* Setup early boot stage 4 level pagetables */
	leal    (wakeup_level4_pgt - wakeup_code)(%esi), %eax
	movl	%eax, %cr3

        /* Check if nx is implemented */
        movl    $0x80000001, %eax
        cpuid
        movl    %edx,%edi

	/* Enable Long Mode */
	xorl    %eax, %eax
	btsl	$_EFER_LME, %eax

	/* No Execute supported? */
	btl	$20,%edi
	jnc     1f
	btsl	$_EFER_NX, %eax
				
	/* Make changes effective */
1:	movl    $MSR_EFER, %ecx
	xorl    %edx, %edx
	wrmsr

	xorl	%eax, %eax
	btsl	$31, %eax			/* Enable paging and in turn activate Long Mode */
	btsl	$0, %eax			/* Enable protected mode */

	/* Make changes effective */
	movl	%eax, %cr0

	/* At this point:
		CR4.PAE must be 1
		CS.L must be 0
		CR3 must point to PML4
		Next instruction must be a branch
		This must be on identity-mapped page
	*/
	/*
	 * At this point we're in long mode but in 32bit compatibility mode
	 * with EFER.LME = 1, CS.L = 0, CS.D = 1 (and in turn
	 * EFER.LMA = 1). Now we want to jump in 64bit mode, to do that we load
	 * the new gdt/idt that has __KERNEL_CS with CS.L = 1.
	 */

	/* Finally jump in 64bit mode */
        ljmp    *(wakeup_long64_vector - wakeup_code)(%esi)

	.balign 4
wakeup_long64_vector:
	.long   wakeup_long64 - wakeup_code
	.word   __KERNEL_CS, 0

.code64

	/* Hooray, we are in Long 64-bit mode (but still running in
	 * low memory)
	 */
wakeup_long64:
	/*
	 * We must switch to a new descriptor in kernel space for the GDT
	 * because soon the kernel won't have access anymore to the userspace
	 * addresses where we're currently running on. We have to do that here
	 * because in 32bit we couldn't load a 64bit linear address.
	 */
	lgdt	cpu_gdt_descr

	movw	$0x0e00 + 'n', %ds:(0xb8014)
	movb	$0xa9, %al	;  outb %al, $0x80

	movq    saved_magic, %rax
	movq    $0x123456789abcdef0, %rdx
	cmpq    %rdx, %rax
	jne     bogus_64_magic

	movw	$0x0e00 + 'u', %ds:(0xb8016)
	
	nop
	nop
	movw	$__KERNEL_DS, %ax
	movw	%ax, %ss	
	movw	%ax, %ds
	movw	%ax, %es
	movw	%ax, %fs
	movw	%ax, %gs
	movq	saved_rsp, %rsp

	movw	$0x0e00 + 'x', %ds:(0xb8018)
	movq	saved_rbx, %rbx
	movq	saved_rdi, %rdi
	movq	saved_rsi, %rsi
	movq	saved_rbp, %rbp

	movw	$0x0e00 + '!', %ds:(0xb801a)
	movq	saved_rip, %rax
	jmp	*%rax

.code32

	.align	64	
gdta:
	/* Its good to keep gdt in sync with one in trampoline.S */
	.word	0, 0, 0, 0			# dummy
	/* ??? Why I need the accessed bit set in order for this to work? */
	.quad   0x00cf9b000000ffff              # __KERNEL32_CS
	.quad   0x00af9b000000ffff              # __KERNEL_CS
	.quad   0x00cf93000000ffff              # __KERNEL_DS

idt_48a:
	.word	0				# idt limit = 0
	.word	0, 0				# idt base = 0L

gdt_48a:
	.word	0x800				# gdt limit=2048,
						#  256 GDT entries
	.long   gdta - wakeup_code              # gdt base (relocated in later)
	
real_magic:	.quad 0
video_mode:	.quad 0
realmode_flags:	.quad 0

.code16
bogus_real_magic:
	movb	$0xba,%al	;  outb %al,$0x80
	jmp bogus_real_magic

.code64
bogus_64_magic:
	movb	$0xb3,%al	;  outb %al,$0x80
	jmp bogus_64_magic

.code16
no_longmode:
	movb    $0xbc,%al       ;  outb %al,$0x80
	jmp no_longmode

#include "../verify_cpu.S"
	
/* This code uses an extended set of video mode numbers. These include:
 * Aliases for standard modes
 *	NORMAL_VGA (-1)
 *	EXTENDED_VGA (-2)
 *	ASK_VGA (-3)
 * Video modes numbered by menu position -- NOT RECOMMENDED because of lack
 * of compatibility when extending the table. These are between 0x00 and 0xff.
 */
#define VIDEO_FIRST_MENU 0x0000

/* Standard BIOS video modes (BIOS number + 0x0100) */
#define VIDEO_FIRST_BIOS 0x0100

/* VESA BIOS video modes (VESA number + 0x0200) */
#define VIDEO_FIRST_VESA 0x0200

/* Video7 special modes (BIOS number + 0x0900) */
#define VIDEO_FIRST_V7 0x0900

# Setting of user mode (AX=mode ID) => CF=success
.code16
mode_seta:
	movw	%ax, %bx
#if 0
	cmpb	$0xff, %ah
	jz	setalias

	testb	$VIDEO_RECALC>>8, %ah
	jnz	_setrec

	cmpb	$VIDEO_FIRST_RESOLUTION>>8, %ah
	jnc	setres
	
	cmpb	$VIDEO_FIRST_SPECIAL>>8, %ah
	jz	setspc

	cmpb	$VIDEO_FIRST_V7>>8, %ah
	jz	setv7
#endif
	
	cmpb	$VIDEO_FIRST_VESA>>8, %ah
	jnc	check_vesaa
#if 0	
	orb	%ah, %ah
	jz	setmenu
#endif
	
	decb	%ah
#	jz	setbios				  Add bios modes later

setbada:	clc
	ret

check_vesaa:
	subb	$VIDEO_FIRST_VESA>>8, %bh
	orw	$0x4000, %bx			# Use linear frame buffer
	movw	$0x4f02, %ax			# VESA BIOS mode set call
	int	$0x10
	cmpw	$0x004f, %ax			# AL=4f if implemented
	jnz	_setbada				# AH=0 if OK

	stc
	ret

_setbada: jmp setbada

wakeup_stack_begin:	# Stack grows down

.org	0xff0
wakeup_stack:		# Just below end of page

.org   0x1000
ENTRY(wakeup_level4_pgt)
	.quad   level3_ident_pgt - __START_KERNEL_map + _KERNPG_TABLE
	.fill   510,8,0
	/* (2^48-(2*1024*1024*1024))/(2^39) = 511 */
	.quad   level3_kernel_pgt - __START_KERNEL_map + _KERNPG_TABLE

ENTRY(wakeup_end)
	
##
# acpi_copy_wakeup_routine
#
# Copy the above routine to low memory.
#
# Parameters:
# %rdi:	place to copy wakeup routine to
#
# Returned address is location of code in low memory (past data and stack)
#
	.code64
ENTRY(acpi_copy_wakeup_routine)
	pushq	%rax
	pushq	%rdx

	movl	saved_video_mode, %edx
	movl	%edx, video_mode - wakeup_start (,%rdi)
	movl	acpi_realmode_flags, %edx
	movl	%edx, realmode_flags - wakeup_start (,%rdi)
	movq	$0x12345678, real_magic - wakeup_start (,%rdi)
	movq	$0x123456789abcdef0, %rdx
	movq	%rdx, saved_magic

	movq    saved_magic, %rax
	movq    $0x123456789abcdef0, %rdx
	cmpq    %rdx, %rax
	jne     bogus_64_magic

	# restore the regs we used
	popq	%rdx
	popq	%rax
ENTRY(do_suspend_lowlevel_s4bios)
	ret

	.align 2
	.p2align 4,,15
.globl do_suspend_lowlevel
	.type	do_suspend_lowlevel,@function
do_suspend_lowlevel:
.LFB5:
	subq	$8, %rsp
	xorl	%eax, %eax
	call	save_processor_state

	movq %rsp, saved_context_esp(%rip)
	movq %rax, saved_context_eax(%rip)
	movq %rbx, saved_context_ebx(%rip)
	movq %rcx, saved_context_ecx(%rip)
	movq %rdx, saved_context_edx(%rip)
	movq %rbp, saved_context_ebp(%rip)
	movq %rsi, saved_context_esi(%rip)
	movq %rdi, saved_context_edi(%rip)
	movq %r8,  saved_context_r08(%rip)
	movq %r9,  saved_context_r09(%rip)
	movq %r10, saved_context_r10(%rip)
	movq %r11, saved_context_r11(%rip)
	movq %r12, saved_context_r12(%rip)
	movq %r13, saved_context_r13(%rip)
	movq %r14, saved_context_r14(%rip)
	movq %r15, saved_context_r15(%rip)
	pushfq ; popq saved_context_eflags(%rip)

	movq	$.L97, saved_rip(%rip)

	movq %rsp,saved_rsp
	movq %rbp,saved_rbp
	movq %rbx,saved_rbx
	movq %rdi,saved_rdi
	movq %rsi,saved_rsi

	addq	$8, %rsp
	movl	$3, %edi
	xorl	%eax, %eax
	jmp	acpi_enter_sleep_state
.L97:
	.p2align 4,,7
.L99:
	.align 4
	movl	$24, %eax
	movw %ax, %ds
	movq	saved_context+58(%rip), %rax
	movq %rax, %cr4
	movq	saved_context+50(%rip), %rax
	movq %rax, %cr3
	movq	saved_context+42(%rip), %rax
	movq %rax, %cr2
	movq	saved_context+34(%rip), %rax
	movq %rax, %cr0
	pushq saved_context_eflags(%rip) ; popfq
	movq saved_context_esp(%rip), %rsp
	movq saved_context_ebp(%rip), %rbp
	movq saved_context_eax(%rip), %rax
	movq saved_context_ebx(%rip), %rbx
	movq saved_context_ecx(%rip), %rcx
	movq saved_context_edx(%rip), %rdx
	movq saved_context_esi(%rip), %rsi
	movq saved_context_edi(%rip), %rdi
	movq saved_context_r08(%rip), %r8
	movq saved_context_r09(%rip), %r9
	movq saved_context_r10(%rip), %r10
	movq saved_context_r11(%rip), %r11
	movq saved_context_r12(%rip), %r12
	movq saved_context_r13(%rip), %r13
	movq saved_context_r14(%rip), %r14
	movq saved_context_r15(%rip), %r15

	xorl	%eax, %eax
	addq	$8, %rsp
	jmp	restore_processor_state
.LFE5:
.Lfe5:
	.size	do_suspend_lowlevel,.Lfe5-do_suspend_lowlevel
	
.data
ALIGN
ENTRY(saved_rbp)	.quad	0
ENTRY(saved_rsi)	.quad	0
ENTRY(saved_rdi)	.quad	0
ENTRY(saved_rbx)	.quad	0

ENTRY(saved_rip)	.quad	0
ENTRY(saved_rsp)	.quad	0

ENTRY(saved_magic)	.quad	0
Commit	Line	Data
1da177e4 LT	1	.text
	2	#include <linux/linkage.h>
	3	#include <asm/segment.h>
d8e1baf1	4	#include <asm/pgtable.h>
1da177e4 LT	5	#include <asm/page.h>
	6	#include <asm/msr.h>
	7
	8	# Copyright 2003 Pavel Machek <pavel@suse.cz>, distribute under GPLv2
	9	#
	10	# wakeup_code runs in real mode, and at unknown address (determined at run-time).
	11	# Therefore it must only use relative jumps/calls.
	12	#
	13	# Do we need to deal with A20? It is okay: ACPI specs says A20 must be enabled
	14	#
	15	# If physical address of wakeup_code is 0x12345, BIOS should call us with
	16	# cs = 0x1234, eip = 0x05
	17	#
	18
5a60d623 NC	19	#define BEEP \
	20	inb $97, %al; \
	21	outb %al, $0x80; \
	22	movb $3, %al; \
	23	outb %al, $97; \
	24	outb %al, $0x80; \
	25	movb $-74, %al; \
	26	outb %al, $67; \
	27	outb %al, $0x80; \
	28	movb $-119, %al; \
	29	outb %al, $66; \
	30	outb %al, $0x80; \
	31	movb $15, %al; \
	32	outb %al, $66;
	33
1da177e4 LT	34
	35	ALIGN
	36	.align 16
	37	ENTRY(wakeup_start)
	38	wakeup_code:
	39	wakeup_code_start = .
	40	.code16
	41
	42	# Running in copy of this code, somewhere in low 1MB.
	43
	44	movb $0xa1, %al ; outb %al, $0x80
	45	cli
	46	cld
	47	# setup data segment
	48	movw %cs, %ax
275f5517	49	movw %ax, %ds # Make ds:0 point to wakeup_start
1da177e4	50	movw %ax, %ss
5a60d623 NC	51
5a60d623 NC	52	# Data segment must be set up before we can see whether to beep.
77afcf78	53	testl $4, realmode_flags - wakeup_code
5a60d623 NC	54	jz 1f
	55	BEEP
	56	1:
	57
275f5517 VG	58	# Private stack is needed for ASUS board
275f5517 VG	59	mov $(wakeup_stack - wakeup_code), %sp
1da177e4	60
275f5517	61	pushl $0 # Kill any dangerous flags
1da177e4 LT	62	popfl
	63
	64	movl real_magic - wakeup_code, %eax
	65	cmpl $0x12345678, %eax
	66	jne bogus_real_magic
	67
a4831e08 VG	68	call verify_cpu # Verify the cpu supports long
	69	# mode
	70	testl %eax, %eax
	71	jnz no_longmode
	72
77afcf78	73	testl $1, realmode_flags - wakeup_code
1da177e4 LT	74	jz 1f
	75	lcall $0xc000,$3
	76	movw %cs, %ax
275f5517	77	movw %ax, %ds # Bios might have played with that
1da177e4 LT	78	movw %ax, %ss
	79	1:
	80
77afcf78	81	testl $2, realmode_flags - wakeup_code
1da177e4 LT	82	jz 1f
	83	mov video_mode - wakeup_code, %ax
	84	call mode_seta
	85	1:
	86
	87	movw $0xb800, %ax
	88	movw %ax,%fs
	89	movw $0x0e00 + 'L', %fs:(0x10)
	90
	91	movb $0xa2, %al ; outb %al, $0x80
	92
d8e1baf1 VG	93	mov %ds, %ax # Find 32bit wakeup_code addr
	94	movzx %ax, %esi # (Convert %ds:gdt to a liner ptr)
	95	shll $4, %esi
	96	# Fix up the vectors
	97	addl %esi, wakeup_32_vector - wakeup_code
	98	addl %esi, wakeup_long64_vector - wakeup_code
	99	addl %esi, gdt_48a + 2 - wakeup_code # Fixup the gdt pointer
	100
	101	lidtl %ds:idt_48a - wakeup_code
343c3f64	102	lgdtl %ds:gdt_48a - wakeup_code # load gdt with whatever is
1da177e4 LT	103	# appropriate
	104
	105	movl $1, %eax # protected mode (PE) bit
	106	lmsw %ax # This is it!
	107	jmp 1f
	108	1:
	109
275f5517 VG	110	ljmpl *(wakeup_32_vector - wakeup_code)
	111
	112	.balign 4
	113	wakeup_32_vector:
d8e1baf1	114	.long wakeup_32 - wakeup_code
275f5517	115	.word __KERNEL32_CS, 0
1da177e4 LT	116
	117	.code32
	118	wakeup_32:
	119	# Running in this code, but at low address; paging is not yet turned on.
	120	movb $0xa5, %al ; outb %al, $0x80
	121
275f5517 VG	122	movl $__KERNEL_DS, %eax
275f5517 VG	123	movl %eax, %ds
1da177e4	124
275f5517 VG	125	movw $0x0e00 + 'i', %ds:(0xb8012)
	126	movb $0xa8, %al ; outb %al, $0x80;
	127
1da177e4 LT	128	/*
	129	* Prepare for entering 64bits mode
	130	*/
	131
275f5517	132	/* Enable PAE */
1da177e4 LT	133	xorl %eax, %eax
1da177e4 LT	134	btsl $5, %eax
1da177e4 LT	135	movl %eax, %cr4
	136
	137	/* Setup early boot stage 4 level pagetables */
d8e1baf1	138	leal (wakeup_level4_pgt - wakeup_code)(%esi), %eax
1da177e4 LT	139	movl %eax, %cr3
1da177e4 LT	140
a4831e08 VG	141	/* Check if nx is implemented */
	142	movl $0x80000001, %eax
	143	cpuid
	144	movl %edx,%edi
	145
1da177e4	146	/* Enable Long Mode */
275f5517	147	xorl %eax, %eax
1da177e4	148	btsl $_EFER_LME, %eax
1da177e4	149
275f5517	150	/* No Execute supported? */
1da177e4 LT	151	btl $20,%edi
	152	jnc 1f
	153	btsl $_EFER_NX, %eax
1da177e4 LT	154
1da177e4 LT	155	/* Make changes effective */
275f5517 VG	156	1: movl $MSR_EFER, %ecx
275f5517 VG	157	xorl %edx, %edx
1da177e4	158	wrmsr
1da177e4 LT	159
	160	xorl %eax, %eax
	161	btsl $31, %eax /* Enable paging and in turn activate Long Mode */
	162	btsl $0, %eax /* Enable protected mode */
1da177e4 LT	163
	164	/* Make changes effective */
	165	movl %eax, %cr0
275f5517	166
1da177e4 LT	167	/* At this point:
	168	CR4.PAE must be 1
	169	CS.L must be 0
	170	CR3 must point to PML4
	171	Next instruction must be a branch
	172	This must be on identity-mapped page
	173	*/
1da177e4 LT	174	/*
	175	* At this point we're in long mode but in 32bit compatibility mode
	176	* with EFER.LME = 1, CS.L = 0, CS.D = 1 (and in turn
	177	* EFER.LMA = 1). Now we want to jump in 64bit mode, to do that we load
	178	* the new gdt/idt that has __KERNEL_CS with CS.L = 1.
	179	*/
	180
1da177e4	181	/* Finally jump in 64bit mode */
d8e1baf1	182	ljmp *(wakeup_long64_vector - wakeup_code)(%esi)
1da177e4	183
275f5517 VG	184	.balign 4
275f5517 VG	185	wakeup_long64_vector:
d8e1baf1	186	.long wakeup_long64 - wakeup_code
275f5517	187	.word __KERNEL_CS, 0
1da177e4 LT	188
	189	.code64
	190
275f5517 VG	191	/* Hooray, we are in Long 64-bit mode (but still running in
	192	* low memory)
	193	*/
1da177e4 LT	194	wakeup_long64:
	195	/*
	196	* We must switch to a new descriptor in kernel space for the GDT
	197	* because soon the kernel won't have access anymore to the userspace
	198	* addresses where we're currently running on. We have to do that here
	199	* because in 32bit we couldn't load a 64bit linear address.
	200	*/
d8e1baf1	201	lgdt cpu_gdt_descr
1da177e4	202
275f5517 VG	203	movw $0x0e00 + 'n', %ds:(0xb8014)
	204	movb $0xa9, %al ; outb %al, $0x80
	205
d8e1baf1 VG	206	movq saved_magic, %rax
	207	movq $0x123456789abcdef0, %rdx
	208	cmpq %rdx, %rax
	209	jne bogus_64_magic
	210
1da177e4 LT	211	movw $0x0e00 + 'u', %ds:(0xb8016)
	212
	213	nop
	214	nop
	215	movw $__KERNEL_DS, %ax
	216	movw %ax, %ss
	217	movw %ax, %ds
	218	movw %ax, %es
	219	movw %ax, %fs
	220	movw %ax, %gs
7db681d7	221	movq saved_rsp, %rsp
1da177e4 LT	222
1da177e4 LT	223	movw $0x0e00 + 'x', %ds:(0xb8018)
7db681d7 VG	224	movq saved_rbx, %rbx
	225	movq saved_rdi, %rdi
	226	movq saved_rsi, %rsi
	227	movq saved_rbp, %rbp
1da177e4 LT	228
1da177e4 LT	229	movw $0x0e00 + '!', %ds:(0xb801a)
7db681d7	230	movq saved_rip, %rax
1da177e4 LT	231	jmp *%rax
	232
	233	.code32
	234
	235	.align 64
	236	gdta:
275f5517	237	/* Its good to keep gdt in sync with one in trampoline.S */
1da177e4	238	.word 0, 0, 0, 0 # dummy
275f5517 VG	239	/* ??? Why I need the accessed bit set in order for this to work? */
	240	.quad 0x00cf9b000000ffff # __KERNEL32_CS
	241	.quad 0x00af9b000000ffff # __KERNEL_CS
	242	.quad 0x00cf93000000ffff # __KERNEL_DS
1da177e4 LT	243
	244	idt_48a:
	245	.word 0 # idt limit = 0
	246	.word 0, 0 # idt base = 0L
	247
	248	gdt_48a:
275f5517	249	.word 0x800 # gdt limit=2048,
1da177e4	250	# 256 GDT entries
d8e1baf1	251	.long gdta - wakeup_code # gdt base (relocated in later)
1da177e4	252
1da177e4 LT	253	real_magic: .quad 0
1da177e4 LT	254	video_mode: .quad 0
77afcf78	255	realmode_flags: .quad 0
1da177e4	256
d8e1baf1	257	.code16
1da177e4	258	bogus_real_magic:
275f5517	259	movb $0xba,%al ; outb %al,$0x80
1da177e4 LT	260	jmp bogus_real_magic
1da177e4 LT	261
d8e1baf1 VG	262	.code64
d8e1baf1 VG	263	bogus_64_magic:
1da177e4	264	movb $0xb3,%al ; outb %al,$0x80
d8e1baf1	265	jmp bogus_64_magic
1da177e4	266
a4831e08 VG	267	.code16
	268	no_longmode:
	269	movb $0xbc,%al ; outb %al,$0x80
	270	jmp no_longmode
1da177e4	271
a4831e08	272	#include "../verify_cpu.S"
1da177e4 LT	273
	274	/* This code uses an extended set of video mode numbers. These include:
	275	* Aliases for standard modes
	276	* NORMAL_VGA (-1)
	277	* EXTENDED_VGA (-2)
	278	* ASK_VGA (-3)
	279	* Video modes numbered by menu position -- NOT RECOMMENDED because of lack
	280	* of compatibility when extending the table. These are between 0x00 and 0xff.
	281	*/
	282	#define VIDEO_FIRST_MENU 0x0000
	283
	284	/* Standard BIOS video modes (BIOS number + 0x0100) */
	285	#define VIDEO_FIRST_BIOS 0x0100
	286
	287	/* VESA BIOS video modes (VESA number + 0x0200) */
	288	#define VIDEO_FIRST_VESA 0x0200
	289
	290	/* Video7 special modes (BIOS number + 0x0900) */
	291	#define VIDEO_FIRST_V7 0x0900
	292
	293	# Setting of user mode (AX=mode ID) => CF=success
d8e1baf1	294	.code16
1da177e4 LT	295	mode_seta:
	296	movw %ax, %bx
	297	#if 0
	298	cmpb $0xff, %ah
	299	jz setalias
	300
	301	testb $VIDEO_RECALC>>8, %ah
	302	jnz _setrec
	303
	304	cmpb $VIDEO_FIRST_RESOLUTION>>8, %ah
	305	jnc setres
	306
	307	cmpb $VIDEO_FIRST_SPECIAL>>8, %ah
	308	jz setspc
	309
	310	cmpb $VIDEO_FIRST_V7>>8, %ah
	311	jz setv7
	312	#endif
	313
	314	cmpb $VIDEO_FIRST_VESA>>8, %ah
	315	jnc check_vesaa
	316	#if 0
	317	orb %ah, %ah
	318	jz setmenu
	319	#endif
	320
	321	decb %ah
	322	# jz setbios Add bios modes later
	323
	324	setbada: clc
	325	ret
	326
	327	check_vesaa:
	328	subb $VIDEO_FIRST_VESA>>8, %bh
	329	orw $0x4000, %bx # Use linear frame buffer
	330	movw $0x4f02, %ax # VESA BIOS mode set call
	331	int $0x10
	332	cmpw $0x004f, %ax # AL=4f if implemented
	333	jnz _setbada # AH=0 if OK
	334
	335	stc
	336	ret
	337
	338	_setbada: jmp setbada
	339
1da177e4 LT	340	wakeup_stack_begin: # Stack grows down
	341
	342	.org 0xff0
	343	wakeup_stack: # Just below end of page
	344
d8e1baf1 VG	345	.org 0x1000
	346	ENTRY(wakeup_level4_pgt)
	347	.quad level3_ident_pgt - __START_KERNEL_map + _KERNPG_TABLE
	348	.fill 510,8,0
	349	/* (2^48-(2102410241024))/(2^39) = 511 /
	350	.quad level3_kernel_pgt - __START_KERNEL_map + _KERNPG_TABLE
	351
1da177e4 LT	352	ENTRY(wakeup_end)
	353
	354	##
	355	# acpi_copy_wakeup_routine
	356	#
	357	# Copy the above routine to low memory.
	358	#
	359	# Parameters:
	360	# %rdi: place to copy wakeup routine to
	361	#
	362	# Returned address is location of code in low memory (past data and stack)
	363	#
7c17e706	364	.code64
1da177e4 LT	365	ENTRY(acpi_copy_wakeup_routine)
1da177e4 LT	366	pushq %rax
1da177e4 LT	367	pushq %rdx
1da177e4 LT	368
1da177e4 LT	369	movl saved_video_mode, %edx
1da177e4 LT	370	movl %edx, video_mode - wakeup_start (,%rdi)
77afcf78 PM	371	movl acpi_realmode_flags, %edx
77afcf78 PM	372	movl %edx, realmode_flags - wakeup_start (,%rdi)
1da177e4 LT	373	movq $0x12345678, real_magic - wakeup_start (,%rdi)
	374	movq $0x123456789abcdef0, %rdx
	375	movq %rdx, saved_magic
	376
d8e1baf1 VG	377	movq saved_magic, %rax
	378	movq $0x123456789abcdef0, %rdx
	379	cmpq %rdx, %rax
	380	jne bogus_64_magic
1da177e4	381
1da177e4 LT	382	# restore the regs we used
1da177e4 LT	383	popq %rdx
1da177e4 LT	384	popq %rax
	385	ENTRY(do_suspend_lowlevel_s4bios)
	386	ret
	387
	388	.align 2
	389	.p2align 4,,15
	390	.globl do_suspend_lowlevel
	391	.type do_suspend_lowlevel,@function
	392	do_suspend_lowlevel:
	393	.LFB5:
	394	subq $8, %rsp
	395	xorl %eax, %eax
	396	call save_processor_state
	397
	398	movq %rsp, saved_context_esp(%rip)
	399	movq %rax, saved_context_eax(%rip)
	400	movq %rbx, saved_context_ebx(%rip)
	401	movq %rcx, saved_context_ecx(%rip)
	402	movq %rdx, saved_context_edx(%rip)
	403	movq %rbp, saved_context_ebp(%rip)
	404	movq %rsi, saved_context_esi(%rip)
	405	movq %rdi, saved_context_edi(%rip)
	406	movq %r8, saved_context_r08(%rip)
	407	movq %r9, saved_context_r09(%rip)
	408	movq %r10, saved_context_r10(%rip)
	409	movq %r11, saved_context_r11(%rip)
	410	movq %r12, saved_context_r12(%rip)
	411	movq %r13, saved_context_r13(%rip)
	412	movq %r14, saved_context_r14(%rip)
	413	movq %r15, saved_context_r15(%rip)
	414	pushfq ; popq saved_context_eflags(%rip)
	415
7db681d7	416	movq $.L97, saved_rip(%rip)
1da177e4	417
7db681d7 VG	418	movq %rsp,saved_rsp
	419	movq %rbp,saved_rbp
	420	movq %rbx,saved_rbx
	421	movq %rdi,saved_rdi
	422	movq %rsi,saved_rsi
1da177e4 LT	423
	424	addq $8, %rsp
	425	movl $3, %edi
	426	xorl %eax, %eax
	427	jmp acpi_enter_sleep_state
	428	.L97:
	429	.p2align 4,,7
	430	.L99:
	431	.align 4
	432	movl $24, %eax
	433	movw %ax, %ds
	434	movq saved_context+58(%rip), %rax
	435	movq %rax, %cr4
	436	movq saved_context+50(%rip), %rax
	437	movq %rax, %cr3
	438	movq saved_context+42(%rip), %rax
	439	movq %rax, %cr2
	440	movq saved_context+34(%rip), %rax
	441	movq %rax, %cr0
	442	pushq saved_context_eflags(%rip) ; popfq
	443	movq saved_context_esp(%rip), %rsp
	444	movq saved_context_ebp(%rip), %rbp
	445	movq saved_context_eax(%rip), %rax
	446	movq saved_context_ebx(%rip), %rbx
	447	movq saved_context_ecx(%rip), %rcx
	448	movq saved_context_edx(%rip), %rdx
	449	movq saved_context_esi(%rip), %rsi
	450	movq saved_context_edi(%rip), %rdi
	451	movq saved_context_r08(%rip), %r8
	452	movq saved_context_r09(%rip), %r9
	453	movq saved_context_r10(%rip), %r10
	454	movq saved_context_r11(%rip), %r11
	455	movq saved_context_r12(%rip), %r12
	456	movq saved_context_r13(%rip), %r13
	457	movq saved_context_r14(%rip), %r14
	458	movq saved_context_r15(%rip), %r15
	459
	460	xorl %eax, %eax
	461	addq $8, %rsp
	462	jmp restore_processor_state
	463	.LFE5:
	464	.Lfe5:
	465	.size do_suspend_lowlevel,.Lfe5-do_suspend_lowlevel
	466
	467	.data
	468	ALIGN
7db681d7 VG	469	ENTRY(saved_rbp) .quad 0
	470	ENTRY(saved_rsi) .quad 0
	471	ENTRY(saved_rdi) .quad 0
	472	ENTRY(saved_rbx) .quad 0
1da177e4	473
7db681d7 VG	474	ENTRY(saved_rip) .quad 0
7db681d7 VG	475	ENTRY(saved_rsp) .quad 0
1da177e4 LT	476
1da177e4 LT	477	ENTRY(saved_magic) .quad 0