MdePkg/Library/BaseLib/Ia32/Thunk16.nasm

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