IntelFrameworkModulePkg/Csm/LegacyBiosDxe/Thunk.c

   1 /** @file
   2   Call into 16-bit BIOS code, Use AsmThunk16 function of BaseLib.
   3
   4 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
   5
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions
   8 of the BSD License which accompanies this distribution.  The
   9 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 **/
  16
  17 #include "LegacyBiosInterface.h"
  18
  19 THUNK_CONTEXT      mThunkContext;
  20
  21 /**
  22   Sets the counter value for Timer #0 in a legacy 8254 timer.
  23
  24   @param  Count - The 16-bit counter value to program into Timer #0 of the legacy 8254 timer.
  25
  26 **/
  27 VOID
  28 SetPitCount (
  29   IN UINT16  Count
  30   )
  31 {
  32   IoWrite8 (TIMER_CONTROL_PORT, TIMER0_CONTROL_WORD);
  33   IoWrite8 (TIMER0_COUNT_PORT, (UINT8) (Count & 0xFF));
  34   IoWrite8 (TIMER0_COUNT_PORT, (UINT8) ((Count>>8) & 0xFF));
  35 }
  36
  37 /**
  38   Thunk to 16-bit real mode and execute a software interrupt with a vector
  39   of BiosInt. Regs will contain the 16-bit register context on entry and
  40   exit.
  41
  42   @param  This    Protocol instance pointer.
  43   @param  BiosInt Processor interrupt vector to invoke
  44   @param  Regs    Register contexted passed into (and returned) from thunk to
  45                   16-bit mode
  46
  47   @retval FALSE   Thunk completed, and there were no BIOS errors in the target code.
  48                   See Regs for status.
  49   @retval TRUE    There was a BIOS erro in the target code.
  50
  51 **/
  52 BOOLEAN
  53 EFIAPI
  54 LegacyBiosInt86 (
  55   IN  EFI_LEGACY_BIOS_PROTOCOL      *This,
  56   IN  UINT8                         BiosInt,
  57   IN  EFI_IA32_REGISTER_SET         *Regs
  58   )
  59 {
  60   Regs->X.Flags.Reserved1 = 1;
  61   Regs->X.Flags.Reserved2 = 0;
  62   Regs->X.Flags.Reserved3 = 0;
  63   Regs->X.Flags.Reserved4 = 0;
  64   Regs->X.Flags.IOPL      = 3;
  65   Regs->X.Flags.NT        = 0;
  66   Regs->X.Flags.IF        = 0;
  67   Regs->X.Flags.TF        = 0;
  68   Regs->X.Flags.CF        = 0;
  69
  70   return InternalLegacyBiosFarCall (
  71            This,
  72            (UINT16) (((UINT32 *)NULL)[BiosInt] >> 16),
  73            (UINT16) ((UINT32 *)NULL)[BiosInt],
  74            Regs,
  75            &Regs->X.Flags,
  76            sizeof (Regs->X.Flags)
  77            );
  78 }
  79
  80 /**
  81   Thunk to 16-bit real mode and call Segment:Offset. Regs will contain the
  82   16-bit register context on entry and exit. Arguments can be passed on
  83   the Stack argument
  84
  85   @param  This                   Protocol instance pointer.
  86   @param  Segment                Segemnt of 16-bit mode call
  87   @param  Offset                 Offset of 16-bit mdoe call
  88   @param  Regs                   Register contexted passed into (and returned) from
  89                                  thunk to  16-bit mode
  90   @param  Stack                  Caller allocated stack used to pass arguments
  91   @param  StackSize              Size of Stack in bytes
  92
  93   @retval FALSE                  Thunk completed, and there were no BIOS errors in
  94                                  the target code. See Regs for status.
  95   @retval TRUE                   There was a BIOS erro in the target code.
  96
  97 **/
  98 BOOLEAN
  99 EFIAPI
 100 LegacyBiosFarCall86 (
 101   IN  EFI_LEGACY_BIOS_PROTOCOL        *This,
 102   IN  UINT16                          Segment,
 103   IN  UINT16                          Offset,
 104   IN  EFI_IA32_REGISTER_SET           *Regs,
 105   IN  VOID                            *Stack,
 106   IN  UINTN                           StackSize
 107   )
 108 {
 109   Regs->X.Flags.Reserved1 = 1;
 110   Regs->X.Flags.Reserved2 = 0;
 111   Regs->X.Flags.Reserved3 = 0;
 112   Regs->X.Flags.Reserved4 = 0;
 113   Regs->X.Flags.IOPL      = 3;
 114   Regs->X.Flags.NT        = 0;
 115   Regs->X.Flags.IF        = 1;
 116   Regs->X.Flags.TF        = 0;
 117   Regs->X.Flags.CF        = 0;
 118
 119   return InternalLegacyBiosFarCall (This, Segment, Offset, Regs, Stack, StackSize);
 120 }
 121
 122 /**
 123   Provide NULL interrupt handler which is used to check
 124   if there is more than one HW interrupt registers with the CPU AP.
 125
 126   @param  InterruptType - The type of interrupt that occured
 127   @param  SystemContext - A pointer to the system context when the interrupt occured
 128
 129 **/
 130 VOID
 131 EFIAPI
 132 LegacyBiosNullInterruptHandler (
 133   IN EFI_EXCEPTION_TYPE   InterruptType,
 134   IN EFI_SYSTEM_CONTEXT   SystemContext
 135   )
 136 {
 137 }
 138
 139 /**
 140   Thunk to 16-bit real mode and call Segment:Offset. Regs will contain the
 141   16-bit register context on entry and exit. Arguments can be passed on
 142   the Stack argument
 143
 144   @param  This       Protocol instance pointer.
 145   @param  Segment    Segemnt of 16-bit mode call
 146   @param  Offset     Offset of 16-bit mdoe call
 147   @param  Regs       Register contexted passed into (and returned) from thunk to
 148                      16-bit mode
 149   @param  Stack      Caller allocated stack used to pass arguments
 150   @param  StackSize  Size of Stack in bytes
 151
 152   @retval FALSE      Thunk completed, and there were no BIOS errors in the target code.
 153                      See Regs for status.
 154   @retval TRUE       There was a BIOS erro in the target code.
 155
 156 **/
 157 BOOLEAN
 158 EFIAPI
 159 InternalLegacyBiosFarCall (
 160   IN  EFI_LEGACY_BIOS_PROTOCOL        *This,
 161   IN  UINT16                          Segment,
 162   IN  UINT16                          Offset,
 163   IN  EFI_IA32_REGISTER_SET           *Regs,
 164   IN  VOID                            *Stack,
 165   IN  UINTN                           StackSize
 166   )
 167 {
 168   UINTN                 Status;
 169   LEGACY_BIOS_INSTANCE  *Private;
 170   UINT16                *Stack16;
 171   EFI_TPL               OriginalTpl;
 172   IA32_REGISTER_SET     ThunkRegSet;
 173   BOOLEAN               InterruptState;
 174   UINT64                TimerPeriod;
 175
 176   Private = LEGACY_BIOS_INSTANCE_FROM_THIS (This);
 177
 178   ZeroMem (&ThunkRegSet, sizeof (ThunkRegSet));
 179   ThunkRegSet.X.DI   = Regs->X.DI;
 180   ThunkRegSet.X.SI   = Regs->X.SI;
 181   ThunkRegSet.X.BP   = Regs->X.BP;
 182   ThunkRegSet.X.BX   = Regs->X.BX;
 183   ThunkRegSet.X.DX   = Regs->X.DX;
 184   //
 185   // Sometimes, ECX is used to pass in 32 bit data. For example, INT 1Ah, AX = B10Dh is
 186   // "PCI BIOS v2.0c + Write Configuration DWORD" and ECX has the dword to write.
 187   //
 188   ThunkRegSet.E.ECX   = Regs->E.ECX;
 189   ThunkRegSet.X.AX   = Regs->X.AX;
 190   ThunkRegSet.E.DS   = Regs->X.DS;
 191   ThunkRegSet.E.ES   = Regs->X.ES;
 192
 193   CopyMem (&(ThunkRegSet.E.EFLAGS.UintN), &(Regs->X.Flags), sizeof (Regs->X.Flags));
 194
 195   //
 196   // Clear the error flag; thunk code may set it. Stack16 should be the high address
 197   // Make Statk16 address the low 16 bit must be not zero.
 198   //
 199   Stack16 = (UINT16 *)((UINT8 *) mThunkContext.RealModeBuffer + mThunkContext.RealModeBufferSize - sizeof (UINT16));
 200
 201   //
 202   // Save current rate of DXE Timer
 203   //
 204   Private->Timer->GetTimerPeriod (Private->Timer, &TimerPeriod);
 205
 206   //
 207   // Disable DXE Timer while executing in real mode
 208   //
 209   Private->Timer->SetTimerPeriod (Private->Timer, 0);
 210
 211   //
 212   // Save and disable interrupt of debug timer
 213   //
 214   InterruptState = SaveAndSetDebugTimerInterrupt (FALSE);
 215
 216   //
 217   // The call to Legacy16 is a critical section to EFI
 218   //
 219   OriginalTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
 220
 221   //
 222   // Check to see if there is more than one HW interrupt registers with the CPU AP.
 223   // If there is, then ASSERT() since that is not compatible with the CSM because
 224   // interupts other than the Timer interrupt that was disabled above can not be
 225   // handled properly from real mode.
 226   //
 227   DEBUG_CODE (
 228     UINTN  Vector;
 229     UINTN  Count;
 230
 231     for (Vector = 0x20, Count = 0; Vector < 0x100; Vector++) {
 232       Status = Private->Cpu->RegisterInterruptHandler (Private->Cpu, Vector, LegacyBiosNullInterruptHandler);
 233       if (Status == EFI_ALREADY_STARTED) {
 234         Count++;
 235       }
 236       if (Status == EFI_SUCCESS) {
 237         Private->Cpu->RegisterInterruptHandler (Private->Cpu, Vector, NULL);
 238       }
 239     }
 240     if (Count >= 2) {
 241       DEBUG ((EFI_D_ERROR, "ERROR: More than one HW interrupt active with CSM enabled\n"));
 242     }
 243     ASSERT (Count < 2);
 244   );
 245
 246   //
 247   // If the Timer AP has enabled the 8254 timer IRQ and the current 8254 timer
 248   // period is less than the CSM required rate of 54.9254, then force the 8254
 249   // PIT counter to 0, which is the CSM required rate of 54.9254 ms
 250   //
 251   if (Private->TimerUses8254 && TimerPeriod < 549254) {
 252     SetPitCount (0);
 253   }
 254
 255   if (Stack != NULL && StackSize != 0) {
 256     //
 257     // Copy Stack to low memory stack
 258     //
 259     Stack16 -= StackSize / sizeof (UINT16);
 260     CopyMem (Stack16, Stack, StackSize);
 261   }
 262
 263   ThunkRegSet.E.SS   = (UINT16) (((UINTN) Stack16 >> 16) << 12);
 264   ThunkRegSet.E.ESP  = (UINT16) (UINTN) Stack16;
 265   ThunkRegSet.E.CS   = Segment;
 266   ThunkRegSet.E.Eip  = Offset;
 267
 268   mThunkContext.RealModeState      = &ThunkRegSet;
 269
 270   //
 271   // Set Legacy16 state. 0x08, 0x70 is legacy 8259 vector bases.
 272   //
 273   Status = Private->Legacy8259->SetMode (Private->Legacy8259, Efi8259LegacyMode, NULL, NULL);
 274   ASSERT_EFI_ERROR (Status);
 275
 276   AsmThunk16 (&mThunkContext);
 277
 278   //
 279   // OPROM may allocate EBDA range by itself and change EBDA base and EBDA size.
 280   // Get the current EBDA base address, and compared with pre-allocate minimum
 281   // EBDA base address, if the current EBDA base address is smaller, it indicates
 282   // PcdEbdaReservedMemorySize should be adjusted to larger for more OPROMs.
 283   //
 284   DEBUG_CODE (
 285     {
 286       UINTN                 EbdaBaseAddress;
 287       UINTN                 ReservedEbdaBaseAddress;
 288
 289       EbdaBaseAddress = (*(UINT16 *) (UINTN) 0x40E) << 4;
 290       ReservedEbdaBaseAddress = CONVENTIONAL_MEMORY_TOP - PcdGet32 (PcdEbdaReservedMemorySize);
 291       ASSERT (ReservedEbdaBaseAddress <= EbdaBaseAddress);
 292     }
 293   );
 294
 295   if (Stack != NULL && StackSize != 0) {
 296     //
 297     // Copy low memory stack to Stack
 298     //
 299     CopyMem (Stack, Stack16, StackSize);
 300   }
 301
 302   //
 303   // Restore protected mode interrupt state
 304   //
 305   Status = Private->Legacy8259->SetMode (Private->Legacy8259, Efi8259ProtectedMode, NULL, NULL);
 306   ASSERT_EFI_ERROR (Status);
 307
 308   mThunkContext.RealModeState = NULL;
 309
 310   //
 311   // End critical section
 312   //
 313   gBS->RestoreTPL (OriginalTpl);
 314
 315   //
 316   // Enable and restore rate of DXE Timer
 317   //
 318   Private->Timer->SetTimerPeriod (Private->Timer, TimerPeriod);
 319
 320   //
 321   // Restore interrupt of debug timer
 322   //
 323   SaveAndSetDebugTimerInterrupt (InterruptState);
 324
 325   Regs->E.EDI      = ThunkRegSet.E.EDI;
 326   Regs->E.ESI      = ThunkRegSet.E.ESI;
 327   Regs->E.EBP      = ThunkRegSet.E.EBP;
 328   Regs->E.EBX      = ThunkRegSet.E.EBX;
 329   Regs->E.EDX      = ThunkRegSet.E.EDX;
 330   Regs->E.ECX      = ThunkRegSet.E.ECX;
 331   Regs->E.EAX      = ThunkRegSet.E.EAX;
 332   Regs->X.SS       = ThunkRegSet.E.SS;
 333   Regs->X.CS       = ThunkRegSet.E.CS;
 334   Regs->X.DS       = ThunkRegSet.E.DS;
 335   Regs->X.ES       = ThunkRegSet.E.ES;
 336
 337   CopyMem (&(Regs->X.Flags), &(ThunkRegSet.E.EFLAGS.UintN), sizeof (Regs->X.Flags));
 338
 339   return (BOOLEAN) (Regs->X.Flags.CF == 1);
 340 }
 341
 342 /**
 343   Allocate memory < 1 MB and copy the thunker code into low memory. Se up
 344   all the descriptors.
 345
 346   @param  Private                Private context for Legacy BIOS
 347
 348   @retval EFI_SUCCESS            Should only pass.
 349
 350 **/
 351 EFI_STATUS
 352 LegacyBiosInitializeThunk (
 353   IN  LEGACY_BIOS_INSTANCE    *Private
 354   )
 355 {
 356   EFI_STATUS              Status;
 357   EFI_PHYSICAL_ADDRESS    MemoryAddress;
 358   UINT8                   TimerVector;
 359
 360   MemoryAddress   = (EFI_PHYSICAL_ADDRESS) (UINTN) Private->IntThunk;
 361
 362   mThunkContext.RealModeBuffer     = (VOID *) (UINTN) (MemoryAddress + ((sizeof (LOW_MEMORY_THUNK) / EFI_PAGE_SIZE) + 1) * EFI_PAGE_SIZE);
 363   mThunkContext.RealModeBufferSize = EFI_PAGE_SIZE;
 364   mThunkContext.ThunkAttributes    = THUNK_ATTRIBUTE_BIG_REAL_MODE | THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15;
 365
 366   AsmPrepareThunk16 (&mThunkContext);
 367
 368   //
 369   // Get the interrupt vector number corresponding to IRQ0 from the 8259 driver
 370   //
 371   TimerVector = 0;
 372   Status = Private->Legacy8259->GetVector (Private->Legacy8259, Efi8259Irq0, &TimerVector);
 373   ASSERT_EFI_ERROR (Status);
 374
 375   //
 376   // Check to see if the Timer AP has hooked the IRQ0 from the 8254 PIT
 377   //
 378   Status = Private->Cpu->RegisterInterruptHandler (
 379                            Private->Cpu,
 380                            TimerVector,
 381                            LegacyBiosNullInterruptHandler
 382                            );
 383   if (Status == EFI_SUCCESS) {
 384     //
 385     // If the Timer AP has not enabled the 8254 timer IRQ, then force the 8254 PIT
 386     // counter to 0, which is the CSM required rate of 54.9254 ms
 387     //
 388     Private->Cpu->RegisterInterruptHandler (
 389                     Private->Cpu,
 390                     TimerVector,
 391                     NULL
 392                     );
 393     SetPitCount (0);
 394
 395     //
 396     // Save status that the Timer AP is not using the 8254 PIT
 397     //
 398     Private->TimerUses8254 = FALSE;
 399   } else if (Status == EFI_ALREADY_STARTED) {
 400     //
 401     // Save status that the Timer AP is using the 8254 PIT
 402     //
 403     Private->TimerUses8254 = TRUE;
 404   } else {
 405     //
 406     // Unexpected status from CPU AP RegisterInterruptHandler()
 407     //
 408     ASSERT (FALSE);
 409   }
 410
 411   return EFI_SUCCESS;
 412 }