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