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 BITS    16
  86     push    ss
  87     push    cs
  88 o32 call    dword .Base                 ; push eip
  89 .Base:
  90     pushfd
  91     cli                                 ; disable interrupts
  92     push    gs
  93     push    fs
  94     push    es
  95     push    ds
  96     pushad
  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     ax, 2401h
 102     int     15h
 103     cli                                 ; disable interrupts
 104     jnc     .2
 105 .1:
 106     test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL
 107     jz      .2
 108     in      al, 92h
 109     or      al, 2
 110     out     92h, al                     ; deactivate A20M#
 111 .2:
 112     xor     eax, eax
 113     mov     ax, ss
 114     lea     ebp, [esp + IA32_REGS.size]
 115     mov     [bp - IA32_REGS.size + IA32_REGS._ESP], ebp
 116     mov     bx, [bp - IA32_REGS.size + IA32_REGS._EIP]
 117     shl     eax, 4                      ; shl eax, 4
 118     add     ebp, eax                    ; add ebp, eax
 119     DB      66h, 0b8h                   ; mov eax, imm32
 120 .SavedCr4:  DD      0
 121     mov     cr4, eax
 122 o32 lgdt [cs:bx + (SavedGdt - .Base)]
 123     DB      66h, 0b8h                   ; mov eax, imm32
 124 .SavedCr0:  DD      0
 125     mov     cr0, eax
 126     DB      0b8h                        ; mov ax, imm16
 127 .SavedSs    DW      0
 128     mov     ss, eax
 129     DB      66h, 0bch                   ; mov esp, imm32
 130 .SavedEsp   DD      0
 131 o32 retf                                ; return to protected mode
 132
 133 _EntryPoint:
 134         DD      _ToUserCode - ASM_PFX(m16Start)
 135         DW      8h
 136 _16Idtr:
 137         DW      (1 << 10) - 1
 138         DD      0
 139 _16Gdtr:
 140         DW      GdtEnd - _NullSegDesc - 1
 141 _16GdtrBase:
 142         DD      _NullSegDesc
 143
 144 ;------------------------------------------------------------------------------
 145 ; _ToUserCode() takes control in real mode before passing control to user code.
 146 ; It will be shadowed to somewhere in memory below 1MB.
 147 ;------------------------------------------------------------------------------
 148 _ToUserCode:
 149 BITS    16
 150     mov     dx, ss
 151     mov     ss, cx                      ; set new segment selectors
 152     mov     ds, cx
 153     mov     es, cx
 154     mov     fs, cx
 155     mov     gs, cx
 156     mov     cr0, eax                    ; real mode starts at next instruction
 157                                         ;  which (per SDM) *must* be a far JMP.
 158     DB      0eah
 159 .RealAddr: DW 0, 0
 160
 161     mov     cr4, ebp
 162     mov     ss, si                      ; set up 16-bit stack segment
 163     xchg    esp, ebx                    ; set up 16-bit stack pointer
 164     mov     bp, [esp + IA32_REGS.size]
 165     mov     [cs:bp + (_BackFromUserCode.SavedSs - _BackFromUserCode)], dx
 166     mov     [cs:bp + (_BackFromUserCode.SavedEsp - _BackFromUserCode)], ebx
 167     lidt    [cs:bp + (_16Idtr - _BackFromUserCode)]
 168
 169     popad
 170     pop     ds
 171     pop     es
 172     pop     fs
 173     pop     gs
 174     popfd
 175
 176 o32 retf                                ; transfer control to user code
 177
 178 ALIGN   16
 179 _NullSegDesc    DQ      0
 180 _16CsDesc:
 181                 DW      -1
 182                 DW      0
 183                 DB      0
 184                 DB      9bh
 185                 DB      8fh             ; 16-bit segment, 4GB limit
 186                 DB      0
 187 _16DsDesc:
 188                 DW      -1
 189                 DW      0
 190                 DB      0
 191                 DB      93h
 192                 DB      8fh             ; 16-bit segment, 4GB limit
 193                 DB      0
 194 GdtEnd:
 195
 196 ;------------------------------------------------------------------------------
 197 ; IA32_REGISTER_SET *
 198 ; EFIAPI
 199 ; InternalAsmThunk16 (
 200 ;   IN      IA32_REGISTER_SET         *RegisterSet,
 201 ;   IN OUT  VOID                      *Transition
 202 ;   );
 203 ;------------------------------------------------------------------------------
 204 global ASM_PFX(InternalAsmThunk16)
 205 ASM_PFX(InternalAsmThunk16):
 206 BITS    32
 207     push    ebp
 208     push    ebx
 209     push    esi
 210     push    edi
 211     push    ds
 212     push    es
 213     push    fs
 214     push    gs
 215     mov     esi, [esp + 36]             ; esi <- RegSet, the 1st parameter
 216     movzx   edx, word [esi + IA32_REGS._SS]
 217     mov     edi, [esi + IA32_REGS._ESP]
 218     add     edi, - (IA32_REGS.size + 4) ; reserve stack space
 219     mov     ebx, edi                    ; ebx <- stack offset
 220     imul    eax, edx, 16                ; eax <- edx * 16
 221     push    IA32_REGS.size / 4
 222     add     edi, eax                    ; edi <- linear address of 16-bit stack
 223     pop     ecx
 224     rep     movsd                       ; copy RegSet
 225     mov     eax, [esp + 40]             ; eax <- address of transition code
 226     mov     esi, edx                    ; esi <- 16-bit stack segment
 227     lea     edx, [eax + (_BackFromUserCode.SavedCr0 - ASM_PFX(m16Start))]
 228     mov     ecx, eax
 229     and     ecx, 0fh
 230     shl     eax, 12
 231     lea     ecx, [ecx + (_BackFromUserCode - ASM_PFX(m16Start))]
 232     mov     ax, cx
 233     stosd                               ; [edi] <- return address of user code
 234     add     eax, _ToUserCode.RealAddr + 4 - _BackFromUserCode
 235     mov     [edx + (_ToUserCode.RealAddr - _BackFromUserCode.SavedCr0)], eax
 236     sgdt    [edx + (SavedGdt - _BackFromUserCode.SavedCr0)]
 237     sidt    [esp + 36]        ; save IDT stack in argument space
 238     mov     eax, cr0
 239     mov     [edx], eax                  ; save CR0 in _BackFromUserCode.SavedCr0
 240     and     eax, 7ffffffeh              ; clear PE, PG bits
 241     mov     ebp, cr4
 242     mov     [edx + (_BackFromUserCode.SavedCr4 - _BackFromUserCode.SavedCr0)], ebp
 243     and     ebp, ~30h                ; clear PAE, PSE bits
 244     push    10h
 245     pop     ecx                         ; ecx <- selector for data segments
 246     lgdt    [edx + (_16Gdtr - _BackFromUserCode.SavedCr0)]
 247     pushfd                              ; Save df/if indeed
 248     call    dword far [edx + (_EntryPoint - _BackFromUserCode.SavedCr0)]
 249     popfd
 250     lidt    [esp + 36]        ; restore protected mode IDTR
 251     lea     eax, [ebp - IA32_REGS.size] ; eax <- the address of IA32_REGS
 252     pop     gs
 253     pop     fs
 254     pop     es
 255     pop     ds
 256     pop     edi
 257     pop     esi
 258     pop     ebx
 259     pop     ebp
 260     ret