MdePkg/Library/BaseLib/x86Thunk.c

   1 /** @file
   2   Real Mode Thunk Functions for IA32 and X64.
   3
   4   Copyright (c) 2006, Intel Corporation<BR>
   5   All rights reserved. This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13   Module Name:  x86Thunk.c
  14
  15 **/
  16
  17 //
  18 // Byte packed structure for a segment descriptor in a GDT/LDT
  19 //
  20 typedef union {
  21   struct {
  22     UINT32  LimitLow:16;
  23     UINT32  BaseLow:16;
  24     UINT32  BaseMid:8;
  25     UINT32  Type:4;
  26     UINT32  S:1;
  27     UINT32  DPL:2;
  28     UINT32  P:1;
  29     UINT32  LimitHigh:4;
  30     UINT32  AVL:1;
  31     UINT32  L:1;
  32     UINT32  DB:1;
  33     UINT32  G:1;
  34     UINT32  BaseHigh:8;
  35   } Bits;
  36   UINT64  Uint64;
  37 } IA32_SEGMENT_DESCRIPTOR;
  38
  39 extern CONST UINT8                  m16Start;
  40 extern CONST UINT16                 m16Size;
  41 extern CONST UINT16                 mThunk16Attr;
  42 extern CONST UINT16                 m16Gdt;
  43 extern CONST UINT16                 m16GdtrBase;
  44 extern CONST UINT16                 mTransition;
  45
  46 /**
  47   Invokes 16-bit code in big real mode and returns the updated register set.
  48
  49   This function transfers control to the 16-bit code specified by CS:EIP using
  50   the stack specified by SS:ESP in RegisterSet. The updated registers are saved
  51   on the real mode stack and the starting address of the save area is returned.
  52
  53   @param  RegisterSet Values of registers before invocation of 16-bit code.
  54   @param  Transition  Pointer to the transition code under 1MB.
  55
  56   @return The pointer to a IA32_REGISTER_SET structure containing the updated
  57           register values.
  58
  59 **/
  60 IA32_REGISTER_SET *
  61 InternalAsmThunk16 (
  62   IN      IA32_REGISTER_SET         *RegisterSet,
  63   IN OUT  VOID                      *Transition
  64   );
  65
  66 /**
  67   Retrieves the properties for 16-bit thunk functions.
  68
  69   Computes the size of the buffer and stack below 1MB required to use the
  70   AsmPrepareThunk16(), AsmThunk16() and AsmPrepareAndThunk16() functions. This
  71   buffer size is returned in RealModeBufferSize, and the stack size is returned
  72   in ExtraStackSize. If parameters are passed to the 16-bit real mode code,
  73   then the actual minimum stack size is ExtraStackSize plus the maximum number
  74   of bytes that need to be passed to the 16-bit real mode code.
  75
  76   If RealModeBufferSize is NULL, then ASSERT().
  77   If ExtraStackSize is NULL, then ASSERT().
  78
  79   @param  RealModeBufferSize  A pointer to the size of the buffer below 1MB
  80                               required to use the 16-bit thunk functions.
  81   @param  ExtraStackSize      A pointer to the extra size of stack below 1MB
  82                               that the 16-bit thunk functions require for
  83                               temporary storage in the transition to and from
  84                               16-bit real mode.
  85
  86 **/
  87 VOID
  88 EFIAPI
  89 AsmGetThunk16Properties (
  90   OUT     UINT32                    *RealModeBufferSize,
  91   OUT     UINT32                    *ExtraStackSize
  92   )
  93 {
  94   ASSERT (RealModeBufferSize != NULL);
  95   ASSERT (ExtraStackSize != NULL);
  96
  97   *RealModeBufferSize = m16Size;
  98   *ExtraStackSize = sizeof (IA32_DWORD_REGS) + 8;
  99 }
 100
 101 /**
 102   Prepares all structures a code required to use AsmThunk16().
 103
 104   Prepares all structures and code required to use AsmThunk16().
 105
 106   If ThunkContext is NULL, then ASSERT().
 107
 108   @param  ThunkContext  A pointer to the context structure that describes the
 109                         16-bit real mode code to call.
 110
 111 **/
 112 VOID
 113 EFIAPI
 114 AsmPrepareThunk16 (
 115   OUT     THUNK_CONTEXT             *ThunkContext
 116   )
 117 {
 118   IA32_SEGMENT_DESCRIPTOR           *RealModeGdt;
 119
 120   ASSERT (ThunkContext != NULL);
 121   ASSERT ((UINTN)ThunkContext->RealModeBuffer < 0x100000);
 122   ASSERT (ThunkContext->RealModeBufferSize >= m16Size);
 123   ASSERT ((UINTN)ThunkContext->RealModeBuffer + m16Size <= 0x100000);
 124   ASSERT (((UINTN)ThunkContext->RealModeBuffer & 0x0f) == 0);
 125
 126   CopyMem (ThunkContext->RealModeBuffer, &m16Start, m16Size);
 127
 128   //
 129   // Point RealModeGdt to the GDT to be used in transition
 130   //
 131   // RealModeGdt[0]: Reserved as NULL descriptor
 132   // RealModeGdt[1]: Code Segment
 133   // RealModeGdt[2]: Data Segment
 134   // RealModeGdt[3]: Call Gate
 135   //
 136   RealModeGdt = (IA32_SEGMENT_DESCRIPTOR*)(
 137                   (UINTN)ThunkContext->RealModeBuffer + m16Gdt);
 138
 139   //
 140   // Update Code & Data Segment Descriptor
 141   //
 142   RealModeGdt[1].Bits.BaseLow =
 143     (UINT32)(UINTN)ThunkContext->RealModeBuffer & ~0xf;
 144   RealModeGdt[1].Bits.BaseMid =
 145     (UINT32)(UINTN)ThunkContext->RealModeBuffer >> 16;
 146
 147   //
 148   // Update transition code entry point offset
 149   //
 150   *(UINT32*)((UINTN)ThunkContext->RealModeBuffer + mTransition) +=
 151     (UINT32)(UINTN)ThunkContext->RealModeBuffer & 0xf;
 152
 153   //
 154   // Update Segment Limits for both Code and Data Segment Descriptors
 155   //
 156   if ((ThunkContext->ThunkAttributes & THUNK_ATTRIBUTE_BIG_REAL_MODE) == 0) {
 157     //
 158     // Set segment limits to 64KB
 159     //
 160     RealModeGdt[1].Bits.LimitHigh = 0;
 161     RealModeGdt[1].Bits.G = 0;
 162     RealModeGdt[2].Bits.LimitHigh = 0;
 163     RealModeGdt[2].Bits.G = 0;
 164   }
 165
 166   //
 167   // Update GDTBASE for this thunk context
 168   //
 169   *(VOID**)((UINTN)ThunkContext->RealModeBuffer + m16GdtrBase) = RealModeGdt;
 170
 171   //
 172   // Update Thunk Attributes
 173   //
 174   *(UINT32*)((UINTN)ThunkContext->RealModeBuffer + mThunk16Attr) =
 175     ThunkContext->ThunkAttributes;
 176 }
 177
 178 /**
 179   Transfers control to a 16-bit real mode entry point and returns the results.
 180
 181   Transfers control to a 16-bit real mode entry point and returns the results.
 182   AsmPrepareThunk16() must be called with ThunkContext before this function is
 183   used. This function must be called with interrupts disabled.
 184
 185   If ThunkContext is NULL, then ASSERT().
 186   If AsmPrepareThunk16() was not previously called with ThunkContext, then ASSERT().
 187
 188   @param  ThunkContext  A pointer to the context structure that describes the
 189                         16-bit real mode code to call.
 190
 191 **/
 192 VOID
 193 EFIAPI
 194 AsmThunk16 (
 195   IN OUT  THUNK_CONTEXT             *ThunkContext
 196   )
 197 {
 198   IA32_REGISTER_SET                 *UpdatedRegs;
 199
 200   ASSERT (ThunkContext != NULL);
 201   ASSERT ((UINTN)ThunkContext->RealModeBuffer < 0x100000);
 202   ASSERT (ThunkContext->RealModeBufferSize >= m16Size);
 203   ASSERT ((UINTN)ThunkContext->RealModeBuffer + m16Size <= 0x100000);
 204   ASSERT (((UINTN)ThunkContext->RealModeBuffer & 0x0f) == 0);
 205
 206   UpdatedRegs = InternalAsmThunk16 (
 207                   ThunkContext->RealModeState,
 208                   ThunkContext->RealModeBuffer
 209                   );
 210
 211   CopyMem (ThunkContext->RealModeState, UpdatedRegs, sizeof (*UpdatedRegs));
 212 }
 213
 214 /**
 215   Prepares all structures and code for a 16-bit real mode thunk, transfers
 216   control to a 16-bit real mode entry point, and returns the results.
 217
 218   Prepares all structures and code for a 16-bit real mode thunk, transfers
 219   control to a 16-bit real mode entry point, and returns the results. If the
 220   caller only need to perform a single 16-bit real mode thunk, then this
 221   service should be used. If the caller intends to make more than one 16-bit
 222   real mode thunk, then it is more efficient if AsmPrepareThunk16() is called
 223   once and AsmThunk16() can be called for each 16-bit real mode thunk. This
 224   function must be called with interrupts disabled.
 225
 226   If ThunkContext is NULL, then ASSERT().
 227
 228   @param  ThunkContext  A pointer to the context structure that describes the
 229                         16-bit real mode code to call.
 230
 231 **/
 232 VOID
 233 EFIAPI
 234 AsmPrepareAndThunk16 (
 235   IN OUT  THUNK_CONTEXT             *ThunkContext
 236   )
 237 {
 238   AsmPrepareThunk16 (ThunkContext);
 239   AsmThunk16 (ThunkContext);
 240 }