[mirror_edk2.git] / MdePkg / Library / BaseLib / Ia32 / Thunk16.asm

\r
#include "BaseLibInternals.h"\r
\r
;------------------------------------------------------------------------------\r
;\r
; Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>\r
; This program and the accompanying materials\r
; are licensed and made available under the terms and conditions of the BSD License\r
; which accompanies this distribution.  The full text of the license may be found at\r
; http://opensource.org/licenses/bsd-license.php.\r
;\r
; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
;\r
; Module Name:\r
;\r
;   Thunk.asm\r
;\r
; Abstract:\r
;\r
;   Real mode thunk\r
;\r
;------------------------------------------------------------------------------\r
\r
    .686p\r
    .model  flat,C\r
\r
EXTERNDEF   C   m16Start:BYTE\r
EXTERNDEF   C   m16Size:WORD\r
EXTERNDEF   C   mThunk16Attr:WORD\r
EXTERNDEF   C   m16Gdt:WORD\r
EXTERNDEF   C   m16GdtrBase:WORD\r
EXTERNDEF   C   mTransition:WORD\r
\r
;\r
; Here is the layout of the real mode stack. _ToUserCode() is responsible for\r
; loading all these registers from real mode stack.\r
;\r
IA32_REGS   STRUC   4t\r
_EDI        DD      ?\r
_ESI        DD      ?\r
_EBP        DD      ?\r
_ESP        DD      ?\r
_EBX        DD      ?\r
_EDX        DD      ?\r
_ECX        DD      ?\r
_EAX        DD      ?\r
_DS         DW      ?\r
_ES         DW      ?\r
_FS         DW      ?\r
_GS         DW      ?\r
_EFLAGS     DD      ?\r
_EIP        DD      ?\r
_CS         DW      ?\r
_SS         DW      ?\r
IA32_REGS   ENDS\r
\r
    .const\r
\r
;\r
; These are global constant to convey information to C code.\r
;\r
m16Size         DW      InternalAsmThunk16 - m16Start\r
mThunk16Attr    DW      _ThunkAttr - m16Start\r
m16Gdt          DW      _NullSegDesc - m16Start\r
m16GdtrBase     DW      _16GdtrBase - m16Start\r
mTransition     DW      _EntryPoint - m16Start\r
\r
    .code\r
\r
m16Start    LABEL   BYTE\r
\r
SavedGdt    LABEL   FWORD\r
            DW      ?\r
            DD      ?\r
;------------------------------------------------------------------------------\r
; _BackFromUserCode() takes control in real mode after 'retf' has been executed\r
; by user code. It will be shadowed to somewhere in memory below 1MB.\r
;------------------------------------------------------------------------------\r
_BackFromUserCode   PROC\r
    ;\r
    ; The order of saved registers on the stack matches the order they appears\r
    ; in IA32_REGS structure. This facilitates wrapper function to extract them\r
    ; into that structure.\r
    ;\r
    push    ss\r
    push    cs\r
    DB      66h\r
    call    @Base                       ; push eip\r
@Base:\r
    pushf                               ; pushfd actually\r
    cli                                 ; disable interrupts\r
    push    gs\r
    push    fs\r
    push    es\r
    push    ds\r
    pushaw                              ; pushad actually\r
    DB      66h, 0bah                   ; mov edx, imm32\r
_ThunkAttr  DD      ?\r
    test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15\r
    jz      @1\r
    mov     eax, 15cd2401h              ; mov ax, 2401h & int 15h\r
    cli                                 ; disable interrupts\r
    jnc     @2\r
@1:\r
    test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL\r
    jz      @2\r
    in      al, 92h\r
    or      al, 2\r
    out     92h, al                     ; deactivate A20M#\r
@2:\r
    xor     ax, ax                      ; xor eax, eax\r
    mov     eax, ss                     ; mov ax, ss\r
    DB      67h\r
    lea     bp, [esp + sizeof (IA32_REGS)]\r
    ;\r
    ; esi's in the following 2 instructions are indeed bp in 16-bit code. Fact\r
    ; is "esi" in 32-bit addressing mode has the same encoding of "bp" in 16-\r
    ; bit addressing mode.\r
    ;\r
    mov     word ptr (IA32_REGS ptr [esi - sizeof (IA32_REGS)])._ESP, bp\r
    mov     ebx, (IA32_REGS ptr [esi - sizeof (IA32_REGS)])._EIP\r
    shl     ax, 4                       ; shl eax, 4\r
    add     bp, ax                      ; add ebp, eax\r
    DB      66h, 0b8h                   ; mov eax, imm32\r
SavedCr4    DD      ?\r
    mov     cr4, eax\r
    DB      66h\r
    lgdt    fword ptr cs:[edi + (SavedGdt - @Base)]\r
    DB      66h, 0b8h                   ; mov eax, imm32\r
SavedCr0    DD      ?\r
    mov     cr0, eax\r
    DB      0b8h                        ; mov ax, imm16\r
SavedSs     DW      ?\r
    mov     ss, eax\r
    DB      66h, 0bch                   ; mov esp, imm32\r
SavedEsp    DD      ?\r
    DB      66h\r
    retf                                ; return to protected mode\r
_BackFromUserCode   ENDP\r
\r
_EntryPoint DD      _ToUserCode - m16Start\r
            DW      8h\r
_16Idtr     FWORD   (1 SHL 10) - 1\r
_16Gdtr     LABEL   FWORD\r
            DW      GdtEnd - _NullSegDesc - 1\r
_16GdtrBase DD      _NullSegDesc\r
\r
;------------------------------------------------------------------------------\r
; _ToUserCode() takes control in real mode before passing control to user code.\r
; It will be shadowed to somewhere in memory below 1MB.\r
;------------------------------------------------------------------------------\r
_ToUserCode PROC\r
    mov     edx, ss\r
    mov     ss, ecx                     ; set new segment selectors\r
    mov     ds, ecx\r
    mov     es, ecx\r
    mov     fs, ecx\r
    mov     gs, ecx\r
    mov     cr0, eax                    ; real mode starts at next instruction\r
                                        ;  which (per SDM) *must* be a far JMP.\r
    DB      0eah\r
_RealAddr DW 0,0                       ; filled in by InternalAsmThunk16\r
\r
    mov     cr4, ebp\r
    mov     ss, esi                     ; set up 16-bit stack segment\r
    xchg    sp, bx                      ; set up 16-bit stack pointer\r
\r
;   mov     bp, [esp + sizeof(IA32_REGS)\r
    DB      67h\r
    mov     ebp, [esp + sizeof(IA32_REGS)] ; BackFromUserCode address from stack\r
\r
;   mov     cs:[bp + (SavedSs - _BackFromUserCode)], dx\r
    mov     cs:[esi + (SavedSs - _BackFromUserCode)], edx\r
\r
;   mov     cs:[bp + (SavedEsp - _BackFromUserCode)], ebx\r
    DB      2eh, 66h, 89h, 9eh\r
    DW      SavedEsp - _BackFromUserCode\r
\r
;   lidt    cs:[bp + (_16Idtr - _BackFromUserCode)]\r
    DB      2eh, 66h, 0fh, 01h, 9eh\r
    DW      _16Idtr - _BackFromUserCode\r
\r
    popaw                               ; popad actually\r
    pop     ds\r
    pop     es\r
    pop     fs\r
    pop     gs\r
    popf                                ; popfd\r
    DB      66h                         ; Use 32-bit addressing for "retf" below\r
    retf                                ; transfer control to user code\r
_ToUserCode ENDP\r
\r
_NullSegDesc    DQ      0\r
_16CsDesc       LABEL   QWORD\r
                DW      -1\r
                DW      0\r
                DB      0\r
                DB      9bh\r
                DB      8fh             ; 16-bit segment, 4GB limit\r
                DB      0\r
_16DsDesc       LABEL   QWORD\r
                DW      -1\r
                DW      0\r
                DB      0\r
                DB      93h\r
                DB      8fh             ; 16-bit segment, 4GB limit\r
                DB      0\r
GdtEnd          LABEL   QWORD\r
\r
;------------------------------------------------------------------------------\r
; IA32_REGISTER_SET *\r
; EFIAPI\r
; InternalAsmThunk16 (\r
;   IN      IA32_REGISTER_SET         *RegisterSet,\r
;   IN OUT  VOID                      *Transition\r
;   );\r
;------------------------------------------------------------------------------\r
InternalAsmThunk16  PROC    USES    ebp ebx esi edi ds  es  fs  gs\r
    mov     esi, [esp + 36]             ; esi <- RegSet, the 1st parameter\r
    movzx   edx, (IA32_REGS ptr [esi])._SS\r
    mov     edi, (IA32_REGS ptr [esi])._ESP\r
    add     edi, - (sizeof (IA32_REGS) + 4) ; reserve stack space\r
    mov     ebx, edi                    ; ebx <- stack offset\r
    imul    eax, edx, 16                ; eax <- edx * 16\r
    push    sizeof (IA32_REGS) / 4\r
    add     edi, eax                    ; edi <- linear address of 16-bit stack\r
    pop     ecx\r
    rep     movsd                       ; copy RegSet\r
    mov     eax, [esp + 40]             ; eax <- address of transition code\r
    mov     esi, edx                    ; esi <- 16-bit stack segment\r
    lea     edx, [eax + (SavedCr0 - m16Start)]\r
    mov     ecx, eax\r
    and     ecx, 0fh\r
    shl     eax, 12\r
    lea     ecx, [ecx + (_BackFromUserCode - m16Start)]\r
    mov     ax, cx\r
    stosd                               ; [edi] <- return address of user code\r
    add     eax, _RealAddr + 4 - _BackFromUserCode\r
    mov     dword ptr [edx + (_RealAddr - SavedCr0)], eax\r
    sgdt    fword ptr [edx + (SavedGdt - SavedCr0)]\r
    sidt    fword ptr [esp + 36]        ; save IDT stack in argument space\r
    mov     eax, cr0\r
    mov     [edx], eax                  ; save CR0 in SavedCr0\r
    and     eax, 7ffffffeh              ; clear PE, PG bits\r
    mov     ebp, cr4\r
    mov     [edx + (SavedCr4 - SavedCr0)], ebp\r
    and     ebp, NOT 30h                ; clear PAE, PSE bits\r
    push    10h\r
    pop     ecx                         ; ecx <- selector for data segments\r
    lgdt    fword ptr [edx + (_16Gdtr - SavedCr0)]\r
    pushfd                              ; Save df/if indeed\r
    call    fword ptr [edx + (_EntryPoint - SavedCr0)]\r
    popfd\r
    lidt    fword ptr [esp + 36]        ; restore protected mode IDTR\r
    lea     eax, [ebp - sizeof (IA32_REGS)] ; eax <- the address of IA32_REGS\r
    ret\r
InternalAsmThunk16  ENDP\r
\r
    END\r
Commit	Line	Data
1efcc4ae	1	\r
47fc17d8	2	#include "BaseLibInternals.h"\r
e1f414b6	3	\r
	4	;------------------------------------------------------------------------------\r
	5	;\r
48c8b6a2	6	; Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>\r
bb817c56	7	; This program and the accompanying materials\r
e1f414b6	8	; are licensed and made available under the terms and conditions of the BSD License\r
e1f414b6	9	; which accompanies this distribution. The full text of the license may be found at\r
e4a34497	10	; http://opensource.org/licenses/bsd-license.php.\r
e1f414b6	11	;\r
	12	; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	13	; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	14	;\r
	15	; Module Name:\r
	16	;\r
	17	; Thunk.asm\r
	18	;\r
	19	; Abstract:\r
	20	;\r
	21	; Real mode thunk\r
	22	;\r
	23	;------------------------------------------------------------------------------\r
	24	\r
	25	.686p\r
	26	.model flat,C\r
	27	\r
	28	EXTERNDEF C m16Start:BYTE\r
	29	EXTERNDEF C m16Size:WORD\r
	30	EXTERNDEF C mThunk16Attr:WORD\r
	31	EXTERNDEF C m16Gdt:WORD\r
	32	EXTERNDEF C m16GdtrBase:WORD\r
	33	EXTERNDEF C mTransition:WORD\r
	34	\r
	35	;\r
	36	; Here is the layout of the real mode stack. _ToUserCode() is responsible for\r
	37	; loading all these registers from real mode stack.\r
	38	;\r
	39	IA32_REGS STRUC 4t\r
	40	_EDI DD ?\r
	41	_ESI DD ?\r
	42	_EBP DD ?\r
	43	_ESP DD ?\r
	44	_EBX DD ?\r
	45	_EDX DD ?\r
	46	_ECX DD ?\r
	47	_EAX DD ?\r
	48	_DS DW ?\r
	49	_ES DW ?\r
	50	_FS DW ?\r
	51	_GS DW ?\r
	52	_EFLAGS DD ?\r
	53	_EIP DD ?\r
	54	_CS DW ?\r
	55	_SS DW ?\r
	56	IA32_REGS ENDS\r
	57	\r
	58	.const\r
	59	\r
	60	;\r
	61	; These are global constant to convey information to C code.\r
	62	;\r
	63	m16Size DW InternalAsmThunk16 - m16Start\r
	64	mThunk16Attr DW _ThunkAttr - m16Start\r
	65	m16Gdt DW _NullSegDesc - m16Start\r
	66	m16GdtrBase DW _16GdtrBase - m16Start\r
	67	mTransition DW _EntryPoint - m16Start\r
	68	\r
	69	.code\r
	70	\r
	71	m16Start LABEL BYTE\r
	72	\r
	73	SavedGdt LABEL FWORD\r
	74	DW ?\r
75	DD ?\r
76	;------------------------------------------------------------------------------\r
77	; _BackFromUserCode() takes control in real mode after 'retf' has been executed\r
78	; by user code. It will be shadowed to somewhere in memory below 1MB.\r
79	;------------------------------------------------------------------------------\r
80	_BackFromUserCode PROC\r
81	;\r
82	; The order of saved registers on the stack matches the order they appears\r
83	; in IA32_REGS structure. This facilitates wrapper function to extract them\r
84	; into that structure.\r
85	;\r
86	push ss\r
87	push cs\r
88	DB 66h\r
89	call @Base ; push eip\r
90	@Base:\r
91	pushf ; pushfd actually\r
92	cli ; disable interrupts\r
93	push gs\r
94	push fs\r
95	push es\r
96	push ds\r
97	pushaw ; pushad actually\r
98	DB 66h, 0bah ; mov edx, imm32\r
99	_ThunkAttr DD ?\r
100	test dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15\r
101	jz @1\r
102	mov eax, 15cd2401h ; mov ax, 2401h & int 15h\r
103	cli ; disable interrupts\r
104	jnc @2\r
105	@1:\r
106	test dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL\r
107	jz @2\r
108	in al, 92h\r
109	or al, 2\r
110	out 92h, al ; deactivate A20M#\r
111	@2:\r
c577049a LG	112	xor ax, ax ; xor eax, eax\r
c577049a LG	113	mov eax, ss ; mov ax, ss\r
e1f414b6	114	DB 67h\r
	115	lea bp, [esp + sizeof (IA32_REGS)]\r
	116	;\r
	117	; esi's in the following 2 instructions are indeed bp in 16-bit code. Fact\r
	118	; is "esi" in 32-bit addressing mode has the same encoding of "bp" in 16-\r
	119	; bit addressing mode.\r
	120	;\r
	121	mov word ptr (IA32_REGS ptr [esi - sizeof (IA32_REGS)])._ESP, bp\r
	122	mov ebx, (IA32_REGS ptr [esi - sizeof (IA32_REGS)])._EIP\r
	123	shl ax, 4 ; shl eax, 4\r
	124	add bp, ax ; add ebp, eax\r
	125	DB 66h, 0b8h ; mov eax, imm32\r
	126	SavedCr4 DD ?\r
	127	mov cr4, eax\r
	128	DB 66h\r
	129	lgdt fword ptr cs:[edi + (SavedGdt - @Base)]\r
	130	DB 66h, 0b8h ; mov eax, imm32\r
	131	SavedCr0 DD ?\r
	132	mov cr0, eax\r
	133	DB 0b8h ; mov ax, imm16\r
	134	SavedSs DW ?\r
	135	mov ss, eax\r
	136	DB 66h, 0bch ; mov esp, imm32\r
	137	SavedEsp DD ?\r
	138	DB 66h\r
	139	retf ; return to protected mode\r
	140	_BackFromUserCode ENDP\r
	141	\r
	142	_EntryPoint DD _ToUserCode - m16Start\r
	143	DW 8h\r
	144	_16Idtr FWORD (1 SHL 10) - 1\r
	145	_16Gdtr LABEL FWORD\r
	146	DW GdtEnd - _NullSegDesc - 1\r
	147	_16GdtrBase DD _NullSegDesc\r
	148	\r
	149	;------------------------------------------------------------------------------\r
	150	; _ToUserCode() takes control in real mode before passing control to user code.\r
	151	; It will be shadowed to somewhere in memory below 1MB.\r
	152	;------------------------------------------------------------------------------\r
	153	_ToUserCode PROC\r
	154	mov edx, ss\r
	155	mov ss, ecx ; set new segment selectors\r
	156	mov ds, ecx\r
	157	mov es, ecx\r
	158	mov fs, ecx\r
	159	mov gs, ecx\r
af8aa62d DW	160	mov cr0, eax ; real mode starts at next instruction\r
	161	; which (per SDM) must be a far JMP.\r
	162	DB 0eah\r
	163	_RealAddr DW 0,0 ; filled in by InternalAsmThunk16\r
	164	\r
	165	mov cr4, ebp\r
e1f414b6	166	mov ss, esi ; set up 16-bit stack segment\r
e1f414b6	167	xchg sp, bx ; set up 16-bit stack pointer\r
af8aa62d DW	168	\r
	169	; mov bp, [esp + sizeof(IA32_REGS)\r
	170	DB 67h\r
	171	mov ebp, [esp + sizeof(IA32_REGS)] ; BackFromUserCode address from stack\r
	172	\r
	173	; mov cs:[bp + (SavedSs - _BackFromUserCode)], dx\r
	174	mov cs:[esi + (SavedSs - _BackFromUserCode)], edx\r
	175	\r
	176	; mov cs:[bp + (SavedEsp - _BackFromUserCode)], ebx\r
	177	DB 2eh, 66h, 89h, 9eh\r
	178	DW SavedEsp - _BackFromUserCode\r
	179	\r
	180	; lidt cs:[bp + (_16Idtr - _BackFromUserCode)]\r
	181	DB 2eh, 66h, 0fh, 01h, 9eh\r
	182	DW _16Idtr - _BackFromUserCode\r
	183	\r
e1f414b6	184	popaw ; popad actually\r
	185	pop ds\r
	186	pop es\r
	187	pop fs\r
	188	pop gs\r
	189	popf ; popfd\r
	190	DB 66h ; Use 32-bit addressing for "retf" below\r
	191	retf ; transfer control to user code\r
	192	_ToUserCode ENDP\r
	193	\r
	194	_NullSegDesc DQ 0\r
	195	_16CsDesc LABEL QWORD\r
	196	DW -1\r
	197	DW 0\r
	198	DB 0\r
	199	DB 9bh\r
	200	DB 8fh ; 16-bit segment, 4GB limit\r
	201	DB 0\r
	202	_16DsDesc LABEL QWORD\r
	203	DW -1\r
	204	DW 0\r
	205	DB 0\r
	206	DB 93h\r
	207	DB 8fh ; 16-bit segment, 4GB limit\r
	208	DB 0\r
	209	GdtEnd LABEL QWORD\r
	210	\r
	211	;------------------------------------------------------------------------------\r
	212	; IA32_REGISTER_SET *\r
	213	; EFIAPI\r
	214	; InternalAsmThunk16 (\r
	215	; IN IA32_REGISTER_SET *RegisterSet,\r
	216	; IN OUT VOID *Transition\r
	217	; );\r
	218	;------------------------------------------------------------------------------\r
	219	InternalAsmThunk16 PROC USES ebp ebx esi edi ds es fs gs\r
	220	mov esi, [esp + 36] ; esi <- RegSet, the 1st parameter\r
	221	movzx edx, (IA32_REGS ptr [esi])._SS\r
	222	mov edi, (IA32_REGS ptr [esi])._ESP\r
	223	add edi, - (sizeof (IA32_REGS) + 4) ; reserve stack space\r
	224	mov ebx, edi ; ebx <- stack offset\r
	225	imul eax, edx, 16 ; eax <- edx * 16\r
	226	push sizeof (IA32_REGS) / 4\r
	227	add edi, eax ; edi <- linear address of 16-bit stack\r
	228	pop ecx\r
	229	rep movsd ; copy RegSet\r
	230	mov eax, [esp + 40] ; eax <- address of transition code\r
	231	mov esi, edx ; esi <- 16-bit stack segment\r
	232	lea edx, [eax + (SavedCr0 - m16Start)]\r
	233	mov ecx, eax\r
	234	and ecx, 0fh\r
	235	shl eax, 12\r
	236	lea ecx, [ecx + (_BackFromUserCode - m16Start)]\r
	237	mov ax, cx\r
	238	stosd ; [edi] <- return address of user code\r
af8aa62d DW	239	add eax, _RealAddr + 4 - _BackFromUserCode\r
af8aa62d DW	240	mov dword ptr [edx + (_RealAddr - SavedCr0)], eax\r
e1f414b6	241	sgdt fword ptr [edx + (SavedGdt - SavedCr0)]\r
	242	sidt fword ptr [esp + 36] ; save IDT stack in argument space\r
	243	mov eax, cr0\r
	244	mov [edx], eax ; save CR0 in SavedCr0\r
	245	and eax, 7ffffffeh ; clear PE, PG bits\r
	246	mov ebp, cr4\r
	247	mov [edx + (SavedCr4 - SavedCr0)], ebp\r
48c8b6a2	248	and ebp, NOT 30h ; clear PAE, PSE bits\r
e1f414b6	249	push 10h\r
	250	pop ecx ; ecx <- selector for data segments\r
	251	lgdt fword ptr [edx + (_16Gdtr - SavedCr0)]\r
	252	pushfd ; Save df/if indeed\r
	253	call fword ptr [edx + (_EntryPoint - SavedCr0)]\r
	254	popfd\r
	255	lidt fword ptr [esp + 36] ; restore protected mode IDTR\r
	256	lea eax, [ebp - sizeof (IA32_REGS)] ; eax <- the address of IA32_REGS\r
	257	ret\r
	258	InternalAsmThunk16 ENDP\r
	259	\r
	260	END\r