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