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 EFIAPI
  62 InternalAsmThunk16 (
  63   IN      IA32_REGISTER_SET         *RegisterSet,
  64   IN OUT  VOID                      *Transition
  65   );
  66
  67 /**
  68   Retrieves the properties for 16-bit thunk functions.
  69
  70   Computes the size of the buffer and stack below 1MB required to use the
  71   AsmPrepareThunk16(), AsmThunk16() and AsmPrepareAndThunk16() functions. This
  72   buffer size is returned in RealModeBufferSize, and the stack size is returned
  73   in ExtraStackSize. If parameters are passed to the 16-bit real mode code,
  74   then the actual minimum stack size is ExtraStackSize plus the maximum number
  75   of bytes that need to be passed to the 16-bit real mode code.
  76
  77   If RealModeBufferSize is NULL, then ASSERT().
  78   If ExtraStackSize is NULL, then ASSERT().
  79
  80   @param  RealModeBufferSize  A pointer to the size of the buffer below 1MB
  81                               required to use the 16-bit thunk functions.
  82   @param  ExtraStackSize      A pointer to the extra size of stack below 1MB
  83                               that the 16-bit thunk functions require for
  84                               temporary storage in the transition to and from
  85                               16-bit real mode.
  86
  87 **/
  88 VOID
  89 EFIAPI
  90 AsmGetThunk16Properties (
  91   OUT     UINT32                    *RealModeBufferSize,
  92   OUT     UINT32                    *ExtraStackSize
  93   )
  94 {
  95   ASSERT (RealModeBufferSize != NULL);
  96   ASSERT (ExtraStackSize != NULL);
  97
  98   *RealModeBufferSize = m16Size;
  99
 100   //
 101   // Extra 4 bytes for return address, and another 4 bytes for mode transition
 102   //
 103   *ExtraStackSize = sizeof (IA32_DWORD_REGS) + 8;
 104 }
 105
 106 /**
 107   Prepares all structures a code required to use AsmThunk16().
 108
 109   Prepares all structures and code required to use AsmThunk16().
 110
 111   If ThunkContext is NULL, then ASSERT().
 112
 113   @param  ThunkContext  A pointer to the context structure that describes the
 114                         16-bit real mode code to call.
 115
 116 **/
 117 VOID
 118 EFIAPI
 119 AsmPrepareThunk16 (
 120   OUT     THUNK_CONTEXT             *ThunkContext
 121   )
 122 {
 123   IA32_SEGMENT_DESCRIPTOR           *RealModeGdt;
 124
 125   ASSERT (ThunkContext != NULL);
 126   ASSERT ((UINTN)ThunkContext->RealModeBuffer < 0x100000);
 127   ASSERT (ThunkContext->RealModeBufferSize >= m16Size);
 128   ASSERT ((UINTN)ThunkContext->RealModeBuffer + m16Size <= 0x100000);
 129
 130   CopyMem (ThunkContext->RealModeBuffer, &m16Start, m16Size);
 131
 132   //
 133   // Point RealModeGdt to the GDT to be used in transition
 134   //
 135   // RealModeGdt[0]: Reserved as NULL descriptor
 136   // RealModeGdt[1]: Code Segment
 137   // RealModeGdt[2]: Data Segment
 138   // RealModeGdt[3]: Call Gate
 139   //
 140   RealModeGdt = (IA32_SEGMENT_DESCRIPTOR*)(
 141                   (UINTN)ThunkContext->RealModeBuffer + m16Gdt);
 142
 143   //
 144   // Update Code & Data Segment Descriptor
 145   //
 146   RealModeGdt[1].Bits.BaseLow =
 147     (UINT32)(UINTN)ThunkContext->RealModeBuffer & ~0xf;
 148   RealModeGdt[1].Bits.BaseMid =
 149     (UINT32)(UINTN)ThunkContext->RealModeBuffer >> 16;
 150
 151   //
 152   // Update transition code entry point offset
 153   //
 154   *(UINT32*)((UINTN)ThunkContext->RealModeBuffer + mTransition) +=
 155     (UINT32)(UINTN)ThunkContext->RealModeBuffer & 0xf;
 156
 157   //
 158   // Update Segment Limits for both Code and Data Segment Descriptors
 159   //
 160   if ((ThunkContext->ThunkAttributes & THUNK_ATTRIBUTE_BIG_REAL_MODE) == 0) {
 161     //
 162     // Set segment limits to 64KB
 163     //
 164     RealModeGdt[1].Bits.LimitHigh = 0;
 165     RealModeGdt[1].Bits.G = 0;
 166     RealModeGdt[2].Bits.LimitHigh = 0;
 167     RealModeGdt[2].Bits.G = 0;
 168   }
 169
 170   //
 171   // Update GDTBASE for this thunk context
 172   //
 173   *(VOID**)((UINTN)ThunkContext->RealModeBuffer + m16GdtrBase) = RealModeGdt;
 174
 175   //
 176   // Update Thunk Attributes
 177   //
 178   *(UINT32*)((UINTN)ThunkContext->RealModeBuffer + mThunk16Attr) =
 179     ThunkContext->ThunkAttributes;
 180 }
 181
 182 /**
 183   Transfers control to a 16-bit real mode entry point and returns the results.
 184
 185   Transfers control to a 16-bit real mode entry point and returns the results.
 186   AsmPrepareThunk16() must be called with ThunkContext before this function is
 187   used. This function must be called with interrupts disabled.
 188
 189   If ThunkContext is NULL, then ASSERT().
 190   If AsmPrepareThunk16() was not previously called with ThunkContext, then ASSERT().
 191
 192   @param  ThunkContext  A pointer to the context structure that describes the
 193                         16-bit real mode code to call.
 194
 195 **/
 196 VOID
 197 EFIAPI
 198 AsmThunk16 (
 199   IN OUT  THUNK_CONTEXT             *ThunkContext
 200   )
 201 {
 202   IA32_REGISTER_SET                 *UpdatedRegs;
 203
 204   ASSERT (ThunkContext != NULL);
 205   ASSERT ((UINTN)ThunkContext->RealModeBuffer < 0x100000);
 206   ASSERT (ThunkContext->RealModeBufferSize >= m16Size);
 207   ASSERT ((UINTN)ThunkContext->RealModeBuffer + m16Size <= 0x100000);
 208
 209   UpdatedRegs = InternalAsmThunk16 (
 210                   ThunkContext->RealModeState,
 211                   ThunkContext->RealModeBuffer
 212                   );
 213
 214   CopyMem (ThunkContext->RealModeState, UpdatedRegs, sizeof (*UpdatedRegs));
 215 }
 216
 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.
 220
 221   Prepares all structures and code for a 16-bit real mode thunk, transfers
 222   control to a 16-bit real mode entry point, and returns the results. If the
 223   caller only need to perform a single 16-bit real mode thunk, then this
 224   service should be used. If the caller intends to make more than one 16-bit
 225   real mode thunk, then it is more efficient if AsmPrepareThunk16() is called
 226   once and AsmThunk16() can be called for each 16-bit real mode thunk. This
 227   function must be called with interrupts disabled.
 228
 229   If ThunkContext is NULL, then ASSERT().
 230
 231   @param  ThunkContext  A pointer to the context structure that describes the
 232                         16-bit real mode code to call.
 233
 234 **/
 235 VOID
 236 EFIAPI
 237 AsmPrepareAndThunk16 (
 238   IN OUT  THUNK_CONTEXT             *ThunkContext
 239   )
 240 {
 241   AsmPrepareThunk16 (ThunkContext);
 242   AsmThunk16 (ThunkContext);
 243 }