[mirror_edk2.git] / OvmfPkg / Csm / LegacyBiosDxe / LegacyBootSupport.c

/** @file\r
\r
Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>\r
\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "LegacyBiosInterface.h"\r
#include <IndustryStandard/Pci.h>\r
\r
#define BOOT_LEGACY_OS              0\r
#define BOOT_EFI_OS                 1\r
#define BOOT_UNCONVENTIONAL_DEVICE  2\r
\r
UINT32               mLoadOptionsSize   = 0;\r
UINTN                mBootMode          = BOOT_LEGACY_OS;\r
VOID                 *mLoadOptions      = NULL;\r
BBS_BBS_DEVICE_PATH  *mBbsDevicePathPtr = NULL;\r
BBS_BBS_DEVICE_PATH  mBbsDevicePathNode;\r
UDC_ATTRIBUTES       mAttributes       = { 0, 0, 0, 0 };\r
UINTN                mBbsEntry         = 0;\r
VOID                 *mBeerData        = NULL;\r
VOID                 *mServiceAreaData = NULL;\r
UINT64               mLowWater         = 0xffffffffffffffffULL;\r
\r
extern BBS_TABLE  *mBbsTable;\r
\r
extern VOID                  *mRuntimeSmbiosEntryPoint;\r
extern EFI_PHYSICAL_ADDRESS  mReserveSmbiosEntryPoint;\r
extern EFI_PHYSICAL_ADDRESS  mStructureTableAddress;\r
\r
/**\r
  Print the BBS Table.\r
\r
  @param BbsTable   The BBS table.\r
\r
\r
**/\r
VOID\r
PrintBbsTable (\r
  IN BBS_TABLE  *BbsTable\r
  )\r
{\r
  UINT16  Index;\r
  UINT16  SubIndex;\r
  CHAR8   *String;\r
\r
  DEBUG ((DEBUG_INFO, "\n"));\r
  DEBUG ((DEBUG_INFO, " NO  Prio bb/dd/ff cl/sc Type Stat segm:offs mfgs:mfgo dess:deso\n"));\r
  DEBUG ((DEBUG_INFO, "=================================================================\n"));\r
  for (Index = 0; Index < MAX_BBS_ENTRIES; Index++) {\r
    //\r
    // Filter\r
    //\r
    if (BbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) {\r
      continue;\r
    }\r
\r
    DEBUG ((\r
      DEBUG_INFO,\r
      " %02x: %04x %02x/%02x/%02x %02x/%02x %04x %04x",\r
      (UINTN)Index,\r
      (UINTN)BbsTable[Index].BootPriority,\r
      (UINTN)BbsTable[Index].Bus,\r
      (UINTN)BbsTable[Index].Device,\r
      (UINTN)BbsTable[Index].Function,\r
      (UINTN)BbsTable[Index].Class,\r
      (UINTN)BbsTable[Index].SubClass,\r
      (UINTN)BbsTable[Index].DeviceType,\r
      (UINTN)*(UINT16 *)&BbsTable[Index].StatusFlags\r
      ));\r
    DEBUG ((\r
      DEBUG_INFO,\r
      " %04x:%04x %04x:%04x %04x:%04x",\r
      (UINTN)BbsTable[Index].BootHandlerSegment,\r
      (UINTN)BbsTable[Index].BootHandlerOffset,\r
      (UINTN)BbsTable[Index].MfgStringSegment,\r
      (UINTN)BbsTable[Index].MfgStringOffset,\r
      (UINTN)BbsTable[Index].DescStringSegment,\r
      (UINTN)BbsTable[Index].DescStringOffset\r
      ));\r
\r
    //\r
    // Print DescString\r
    //\r
    String = (CHAR8 *)(((UINTN)BbsTable[Index].DescStringSegment << 4) + BbsTable[Index].DescStringOffset);\r
    if (String != NULL) {\r
      DEBUG ((DEBUG_INFO, " ("));\r
      for (SubIndex = 0; String[SubIndex] != 0; SubIndex++) {\r
        DEBUG ((DEBUG_INFO, "%c", String[SubIndex]));\r
      }\r
\r
      DEBUG ((DEBUG_INFO, ")"));\r
    }\r
\r
    DEBUG ((DEBUG_INFO, "\n"));\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "\n"));\r
\r
  return;\r
}\r
\r
/**\r
  Print the BBS Table.\r
\r
  @param HddInfo   The HddInfo table.\r
\r
\r
**/\r
VOID\r
PrintHddInfo (\r
  IN HDD_INFO  *HddInfo\r
  )\r
{\r
  UINTN  Index;\r
\r
  DEBUG ((DEBUG_INFO, "\n"));\r
  for (Index = 0; Index < MAX_IDE_CONTROLLER; Index++) {\r
    DEBUG ((DEBUG_INFO, "Index - %04x\n", Index));\r
    DEBUG ((DEBUG_INFO, "  Status    - %04x\n", (UINTN)HddInfo[Index].Status));\r
    DEBUG ((DEBUG_INFO, "  B/D/F     - %02x/%02x/%02x\n", (UINTN)HddInfo[Index].Bus, (UINTN)HddInfo[Index].Device, (UINTN)HddInfo[Index].Function));\r
    DEBUG ((DEBUG_INFO, "  Command   - %04x\n", HddInfo[Index].CommandBaseAddress));\r
    DEBUG ((DEBUG_INFO, "  Control   - %04x\n", HddInfo[Index].ControlBaseAddress));\r
    DEBUG ((DEBUG_INFO, "  BusMaster - %04x\n", HddInfo[Index].BusMasterAddress));\r
    DEBUG ((DEBUG_INFO, "  HddIrq    - %02x\n", HddInfo[Index].HddIrq));\r
    DEBUG ((DEBUG_INFO, "  IdentifyDrive[0].Raw[0] - %x\n", HddInfo[Index].IdentifyDrive[0].Raw[0]));\r
    DEBUG ((DEBUG_INFO, "  IdentifyDrive[1].Raw[0] - %x\n", HddInfo[Index].IdentifyDrive[1].Raw[0]));\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "\n"));\r
\r
  return;\r
}\r
\r
/**\r
  Print the PCI Interrupt Line and Interrupt Pin registers.\r
**/\r
VOID\r
PrintPciInterruptRegister (\r
  VOID\r
  )\r
{\r
  EFI_STATUS           Status;\r
  UINTN                Index;\r
  EFI_HANDLE           *Handles;\r
  UINTN                HandleNum;\r
  EFI_PCI_IO_PROTOCOL  *PciIo;\r
  UINT8                Interrupt[2];\r
  UINTN                Segment;\r
  UINTN                Bus;\r
  UINTN                Device;\r
  UINTN                Function;\r
\r
  gBS->LocateHandleBuffer (\r
         ByProtocol,\r
         &gEfiPciIoProtocolGuid,\r
         NULL,\r
         &HandleNum,\r
         &Handles\r
         );\r
\r
  Bus      = 0;\r
  Device   = 0;\r
  Function = 0;\r
\r
  DEBUG ((DEBUG_INFO, "\n"));\r
  DEBUG ((DEBUG_INFO, " bb/dd/ff interrupt line interrupt pin\n"));\r
  DEBUG ((DEBUG_INFO, "======================================\n"));\r
  for (Index = 0; Index < HandleNum; Index++) {\r
    Status = gBS->HandleProtocol (Handles[Index], &gEfiPciIoProtocolGuid, (VOID **)&PciIo);\r
    if (!EFI_ERROR (Status)) {\r
      Status = PciIo->Pci.Read (\r
                            PciIo,\r
                            EfiPciIoWidthUint8,\r
                            PCI_INT_LINE_OFFSET,\r
                            2,\r
                            Interrupt\r
                            );\r
    }\r
\r
    if (!EFI_ERROR (Status)) {\r
      Status = PciIo->GetLocation (\r
                        PciIo,\r
                        &Segment,\r
                        &Bus,\r
                        &Device,\r
                        &Function\r
                        );\r
    }\r
\r
    if (!EFI_ERROR (Status)) {\r
      DEBUG ((\r
        DEBUG_INFO,\r
        " %02x/%02x/%02x 0x%02x           0x%02x\n",\r
        Bus,\r
        Device,\r
        Function,\r
        Interrupt[0],\r
        Interrupt[1]\r
        ));\r
    }\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "\n"));\r
\r
  if (Handles != NULL) {\r
    FreePool (Handles);\r
  }\r
}\r
\r
/**\r
  Identify drive data must be updated to actual parameters before boot.\r
\r
  @param  IdentifyDriveData       ATA Identify Data\r
\r
**/\r
VOID\r
UpdateIdentifyDriveData (\r
  IN  UINT8  *IdentifyDriveData\r
  );\r
\r
/**\r
  Update SIO data.\r
\r
  @param  Private                 Legacy BIOS Instance data\r
\r
  @retval EFI_SUCCESS             Removable media not present\r
\r
**/\r
EFI_STATUS\r
UpdateSioData (\r
  IN  LEGACY_BIOS_INSTANCE  *Private\r
  )\r
{\r
  EFI_STATUS                           Status;\r
  UINTN                                Index;\r
  UINTN                                Index1;\r
  UINT8                                LegacyInterrupts[16];\r
  EFI_LEGACY_IRQ_ROUTING_ENTRY         *RoutingTable;\r
  UINTN                                RoutingTableEntries;\r
  EFI_LEGACY_IRQ_PRIORITY_TABLE_ENTRY  *IrqPriorityTable;\r
  UINTN                                NumberPriorityEntries;\r
  EFI_TO_COMPATIBILITY16_BOOT_TABLE    *EfiToLegacy16BootTable;\r
  UINT8                                HddIrq;\r
  UINT16                               LegacyInt;\r
  UINT16                               LegMask;\r
  UINT32                               Register;\r
  UINTN                                HandleCount;\r
  EFI_HANDLE                           *HandleBuffer;\r
  EFI_ISA_IO_PROTOCOL                  *IsaIo;\r
\r
  LegacyInt    = 0;\r
  HandleBuffer = NULL;\r
\r
  EfiToLegacy16BootTable = &Private->IntThunk->EfiToLegacy16BootTable;\r
  LegacyBiosBuildSioData (Private);\r
  SetMem (LegacyInterrupts, sizeof (LegacyInterrupts), 0);\r
\r
  //\r
  // Create list of legacy interrupts.\r
  //\r
  for (Index = 0; Index < 4; Index++) {\r
    LegacyInterrupts[Index] = EfiToLegacy16BootTable->SioData.Serial[Index].Irq;\r
  }\r
\r
  for (Index = 4; Index < 7; Index++) {\r
    LegacyInterrupts[Index] = EfiToLegacy16BootTable->SioData.Parallel[Index - 4].Irq;\r
  }\r
\r
  LegacyInterrupts[7] = EfiToLegacy16BootTable->SioData.Floppy.Irq;\r
\r
  //\r
  // Get Legacy Hdd IRQs. If native mode treat as PCI\r
  //\r
  for (Index = 0; Index < 2; Index++) {\r
    HddIrq = EfiToLegacy16BootTable->HddInfo[Index].HddIrq;\r
    if ((HddIrq != 0) && ((HddIrq == 15) || (HddIrq == 14))) {\r
      LegacyInterrupts[Index + 8] = HddIrq;\r
    }\r
  }\r
\r
  Private->LegacyBiosPlatform->GetRoutingTable (\r
                                 Private->LegacyBiosPlatform,\r
                                 (VOID *)&RoutingTable,\r
                                 &RoutingTableEntries,\r
                                 NULL,\r
                                 NULL,\r
                                 (VOID **)&IrqPriorityTable,\r
                                 &NumberPriorityEntries\r
                                 );\r
  //\r
  // Remove legacy interrupts from the list of PCI interrupts available.\r
  //\r
  for (Index = 0; Index <= 0x0b; Index++) {\r
    for (Index1 = 0; Index1 <= NumberPriorityEntries; Index1++) {\r
      if (LegacyInterrupts[Index] != 0) {\r
        LegacyInt = (UINT16)(LegacyInt | (1 << LegacyInterrupts[Index]));\r
        if (LegacyInterrupts[Index] == IrqPriorityTable[Index1].Irq) {\r
          IrqPriorityTable[Index1].Used = LEGACY_USED;\r
        }\r
      }\r
    }\r
  }\r
\r
  Private->Legacy8259->GetMask (\r
                         Private->Legacy8259,\r
                         &LegMask,\r
                         NULL,\r
                         NULL,\r
                         NULL\r
                         );\r
\r
  //\r
  // Set SIO interrupts and disable mouse. Let mouse driver\r
  // re-enable it.\r
  //\r
  LegMask = (UINT16)((LegMask &~LegacyInt) | 0x1000);\r
  Private->Legacy8259->SetMask (\r
                         Private->Legacy8259,\r
                         &LegMask,\r
                         NULL,\r
                         NULL,\r
                         NULL\r
                         );\r
\r
  //\r
  // Disable mouse in keyboard controller\r
  //\r
  Register = 0xA7;\r
  Status   = gBS->LocateHandleBuffer (\r
                    ByProtocol,\r
                    &gEfiIsaIoProtocolGuid,\r
                    NULL,\r
                    &HandleCount,\r
                    &HandleBuffer\r
                    );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  for (Index = 0; Index < HandleCount; Index++) {\r
    Status = gBS->HandleProtocol (\r
                    HandleBuffer[Index],\r
                    &gEfiIsaIoProtocolGuid,\r
                    (VOID **)&IsaIo\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
    IsaIo->Io.Write (IsaIo, EfiIsaIoWidthUint8, 0x64, 1, &Register);\r
  }\r
\r
  if (HandleBuffer != NULL) {\r
    FreePool (HandleBuffer);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Identify drive data must be updated to actual parameters before boot.\r
  This requires updating the checksum, if it exists.\r
\r
  @param  IdentifyDriveData       ATA Identify Data\r
  @param  Checksum                checksum of the ATA Identify Data\r
\r
  @retval EFI_SUCCESS             checksum calculated\r
  @retval EFI_SECURITY_VIOLATION  IdentifyData invalid\r
\r
**/\r
EFI_STATUS\r
CalculateIdentifyDriveChecksum (\r
  IN  UINT8  *IdentifyDriveData,\r
  OUT UINT8  *Checksum\r
  )\r
{\r
  UINTN  Index;\r
  UINT8  LocalChecksum;\r
\r
  LocalChecksum = 0;\r
  *Checksum     = 0;\r
  if (IdentifyDriveData[510] != 0xA5) {\r
    return EFI_SECURITY_VIOLATION;\r
  }\r
\r
  for (Index = 0; Index < 512; Index++) {\r
    LocalChecksum = (UINT8)(LocalChecksum + IdentifyDriveData[Index]);\r
  }\r
\r
  *Checksum = LocalChecksum;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Identify drive data must be updated to actual parameters before boot.\r
\r
  @param  IdentifyDriveData       ATA Identify Data\r
\r
\r
**/\r
VOID\r
UpdateIdentifyDriveData (\r
  IN  UINT8  *IdentifyDriveData\r
  )\r
{\r
  UINT16          NumberCylinders;\r
  UINT16          NumberHeads;\r
  UINT16          NumberSectorsTrack;\r
  UINT32          CapacityInSectors;\r
  UINT8           OriginalChecksum;\r
  UINT8           FinalChecksum;\r
  EFI_STATUS      Status;\r
  ATAPI_IDENTIFY  *ReadInfo;\r
\r
  //\r
  // Status indicates if Integrity byte is correct. Checksum should be\r
  // 0 if valid.\r
  //\r
  ReadInfo = (ATAPI_IDENTIFY *)IdentifyDriveData;\r
  Status   = CalculateIdentifyDriveChecksum (IdentifyDriveData, &OriginalChecksum);\r
  if (OriginalChecksum != 0) {\r
    Status = EFI_SECURITY_VIOLATION;\r
  }\r
\r
  //\r
  // If NumberCylinders = 0 then do data(Controller present but don drive attached).\r
  //\r
  NumberCylinders = ReadInfo->Raw[1];\r
  if (NumberCylinders != 0) {\r
    ReadInfo->Raw[54] = NumberCylinders;\r
\r
    NumberHeads       = ReadInfo->Raw[3];\r
    ReadInfo->Raw[55] = NumberHeads;\r
\r
    NumberSectorsTrack = ReadInfo->Raw[6];\r
    ReadInfo->Raw[56]  = NumberSectorsTrack;\r
\r
    //\r
    // Copy Multisector info and set valid bit.\r
    //\r
    ReadInfo->Raw[59] = (UINT16)(ReadInfo->Raw[47] + 0x100);\r
    CapacityInSectors = (UINT32)((UINT32)(NumberCylinders) * (UINT32)(NumberHeads) * (UINT32)(NumberSectorsTrack));\r
    ReadInfo->Raw[57] = (UINT16)(CapacityInSectors >> 16);\r
    ReadInfo->Raw[58] = (UINT16)(CapacityInSectors & 0xffff);\r
    if (Status == EFI_SUCCESS) {\r
      //\r
      // Forece checksum byte to 0 and get new checksum.\r
      //\r
      ReadInfo->Raw[255] &= 0xff;\r
      CalculateIdentifyDriveChecksum (IdentifyDriveData, &FinalChecksum);\r
\r
      //\r
      // Force new checksum such that sum is 0.\r
      //\r
      FinalChecksum      = (UINT8)((UINT8)0 - FinalChecksum);\r
      ReadInfo->Raw[255] = (UINT16)(ReadInfo->Raw[255] | (FinalChecksum << 8));\r
    }\r
  }\r
}\r
\r
/**\r
  Identify drive data must be updated to actual parameters before boot.\r
  Do for all drives.\r
\r
  @param  Private                 Legacy BIOS Instance data\r
\r
\r
**/\r
VOID\r
UpdateAllIdentifyDriveData (\r
  IN LEGACY_BIOS_INSTANCE  *Private\r
  )\r
{\r
  UINTN     Index;\r
  HDD_INFO  *HddInfo;\r
\r
  HddInfo = &Private->IntThunk->EfiToLegacy16BootTable.HddInfo[0];\r
\r
  for (Index = 0; Index < MAX_IDE_CONTROLLER; Index++) {\r
    //\r
    // Each controller can have 2 devices. Update for each device\r
    //\r
    if ((HddInfo[Index].Status & HDD_MASTER_IDE) != 0) {\r
      UpdateIdentifyDriveData ((UINT8 *)(&HddInfo[Index].IdentifyDrive[0].Raw[0]));\r
    }\r
\r
    if ((HddInfo[Index].Status & HDD_SLAVE_IDE) != 0) {\r
      UpdateIdentifyDriveData ((UINT8 *)(&HddInfo[Index].IdentifyDrive[1].Raw[0]));\r
    }\r
  }\r
}\r
\r
/**\r
  Enable ide controller.  This gets disabled when LegacyBoot.c is about\r
  to run the Option ROMs.\r
\r
  @param  Private        Legacy BIOS Instance data\r
\r
\r
**/\r
VOID\r
EnableIdeController (\r
  IN LEGACY_BIOS_INSTANCE  *Private\r
  )\r
{\r
  EFI_PCI_IO_PROTOCOL  *PciIo;\r
  EFI_STATUS           Status;\r
  EFI_HANDLE           IdeController;\r
  UINT8                ByteBuffer;\r
  UINTN                HandleCount;\r
  EFI_HANDLE           *HandleBuffer;\r
\r
  Status = Private->LegacyBiosPlatform->GetPlatformHandle (\r
                                          Private->LegacyBiosPlatform,\r
                                          EfiGetPlatformIdeHandle,\r
                                          0,\r
                                          &HandleBuffer,\r
                                          &HandleCount,\r
                                          NULL\r
                                          );\r
  if (!EFI_ERROR (Status)) {\r
    IdeController = HandleBuffer[0];\r
    Status        = gBS->HandleProtocol (\r
                           IdeController,\r
                           &gEfiPciIoProtocolGuid,\r
                           (VOID **)&PciIo\r
                           );\r
    ByteBuffer = 0x1f;\r
    if (!EFI_ERROR (Status)) {\r
      PciIo->Pci.Write (PciIo, EfiPciIoWidthUint8, 0x04, 1, &ByteBuffer);\r
    }\r
  }\r
}\r
\r
/**\r
  Enable ide controller.  This gets disabled when LegacyBoot.c is about\r
  to run the Option ROMs.\r
\r
  @param  Private                 Legacy BIOS Instance data\r
\r
\r
**/\r
VOID\r
EnableAllControllers (\r
  IN LEGACY_BIOS_INSTANCE  *Private\r
  )\r
{\r
  UINTN                HandleCount;\r
  EFI_HANDLE           *HandleBuffer;\r
  UINTN                Index;\r
  EFI_PCI_IO_PROTOCOL  *PciIo;\r
  PCI_TYPE01           PciConfigHeader;\r
  EFI_STATUS           Status;\r
\r
  //\r
  //\r
  //\r
  EnableIdeController (Private);\r
\r
  //\r
  // Assumption is table is built from low bus to high bus numbers.\r
  //\r
  Status = gBS->LocateHandleBuffer (\r
                  ByProtocol,\r
                  &gEfiPciIoProtocolGuid,\r
                  NULL,\r
                  &HandleCount,\r
                  &HandleBuffer\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  for (Index = 0; Index < HandleCount; Index++) {\r
    Status = gBS->HandleProtocol (\r
                    HandleBuffer[Index],\r
                    &gEfiPciIoProtocolGuid,\r
                    (VOID **)&PciIo\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
\r
    PciIo->Pci.Read (\r
                 PciIo,\r
                 EfiPciIoWidthUint32,\r
                 0,\r
                 sizeof (PciConfigHeader) / sizeof (UINT32),\r
                 &PciConfigHeader\r
                 );\r
\r
    //\r
    // We do not enable PPB here. This is for HotPlug Consideration.\r
    // The Platform HotPlug Driver is responsible for Padding enough hot plug\r
    // resources. It is also responsible for enable this bridge. If it\r
    // does not pad it. It will cause some early Windows fail to installation.\r
    // If the platform driver does not pad resource for PPB, PPB should be in\r
    // un-enabled state to let Windows know that this PPB is not configured by\r
    // BIOS. So Windows will allocate default resource for PPB.\r
    //\r
    // The reason for why we enable the command register is:\r
    // The CSM will use the IO bar to detect some IRQ status, if the command\r
    // is disabled, the IO resource will be out of scope.\r
    // For example:\r
    // We installed a legacy IRQ handle for a PCI IDE controller. When IRQ\r
    // comes up, the handle will check the IO space to identify is the\r
    // controller generated the IRQ source.\r
    // If the IO command is not enabled, the IRQ handler will has wrong\r
    // information. It will cause IRQ storm when the correctly IRQ handler fails\r
    // to run.\r
    //\r
    if (!(IS_PCI_VGA (&PciConfigHeader)     ||\r
          IS_PCI_OLD_VGA (&PciConfigHeader) ||\r
          IS_PCI_IDE (&PciConfigHeader)     ||\r
          IS_PCI_P2P (&PciConfigHeader)     ||\r
          IS_PCI_P2P_SUB (&PciConfigHeader) ||\r
          IS_PCI_LPC (&PciConfigHeader)))\r
    {\r
      PciConfigHeader.Hdr.Command |= 0x1f;\r
\r
      PciIo->Pci.Write (PciIo, EfiPciIoWidthUint32, 4, 1, &PciConfigHeader.Hdr.Command);\r
    }\r
  }\r
}\r
\r
/**\r
  The following routines are identical in operation, so combine\r
  for code compaction:\r
  EfiGetPlatformBinaryGetMpTable\r
  EfiGetPlatformBinaryGetOemIntData\r
  EfiGetPlatformBinaryGetOem32Data\r
  EfiGetPlatformBinaryGetOem16Data\r
\r
  @param  This                    Protocol instance pointer.\r
  @param  Id                      Table/Data identifier\r
\r
  @retval EFI_SUCCESS             Success\r
  @retval EFI_INVALID_PARAMETER   Invalid ID\r
  @retval EFI_OUT_OF_RESOURCES    no resource to get data or table\r
\r
**/\r
EFI_STATUS\r
LegacyGetDataOrTable (\r
  IN EFI_LEGACY_BIOS_PROTOCOL    *This,\r
  IN EFI_GET_PLATFORM_INFO_MODE  Id\r
  )\r
{\r
  VOID                               *Table;\r
  UINT32                             TablePtr;\r
  UINTN                              TableSize;\r
  UINTN                              Alignment;\r
  UINTN                              Location;\r
  EFI_STATUS                         Status;\r
  EFI_LEGACY_BIOS_PLATFORM_PROTOCOL  *LegacyBiosPlatform;\r
  EFI_COMPATIBILITY16_TABLE          *Legacy16Table;\r
  EFI_IA32_REGISTER_SET              Regs;\r
  LEGACY_BIOS_INSTANCE               *Private;\r
\r
  Private = LEGACY_BIOS_INSTANCE_FROM_THIS (This);\r
\r
  LegacyBiosPlatform = Private->LegacyBiosPlatform;\r
  Legacy16Table      = Private->Legacy16Table;\r
\r
  //\r
  // Phase 1 - get an address allocated in 16-bit code\r
  //\r
  while (TRUE) {\r
    switch (Id) {\r
      case EfiGetPlatformBinaryMpTable:\r
      case EfiGetPlatformBinaryOemIntData:\r
      case EfiGetPlatformBinaryOem32Data:\r
      case EfiGetPlatformBinaryOem16Data:\r
      {\r
        Status = LegacyBiosPlatform->GetPlatformInfo (\r
                                       LegacyBiosPlatform,\r
                                       Id,\r
                                       (VOID *)&Table,\r
                                       &TableSize,\r
                                       &Location,\r
                                       &Alignment,\r
                                       0,\r
                                       0\r
                                       );\r
        DEBUG ((DEBUG_INFO, "LegacyGetDataOrTable - ID: %x, %r\n", (UINTN)Id, Status));\r
        DEBUG ((DEBUG_INFO, "  Table - %x, Size - %x, Location - %x, Alignment - %x\n", (UINTN)Table, (UINTN)TableSize, (UINTN)Location, (UINTN)Alignment));\r
        break;\r
      }\r
\r
      default:\r
      {\r
        return EFI_INVALID_PARAMETER;\r
      }\r
    }\r
\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));\r
    Regs.X.AX = Legacy16GetTableAddress;\r
    Regs.X.CX = (UINT16)TableSize;\r
    Regs.X.BX = (UINT16)Location;\r
    Regs.X.DX = (UINT16)Alignment;\r
    Private->LegacyBios.FarCall86 (\r
                          This,\r
                          Private->Legacy16CallSegment,\r
                          Private->Legacy16CallOffset,\r
                          &Regs,\r
                          NULL,\r
                          0\r
                          );\r
\r
    if (Regs.X.AX != 0) {\r
      DEBUG ((DEBUG_ERROR, "Table ID %x length insufficient\n", Id));\r
      return EFI_OUT_OF_RESOURCES;\r
    } else {\r
      break;\r
    }\r
  }\r
\r
  //\r
  // Phase 2 Call routine second time with address to allow address adjustment\r
  //\r
  Status = LegacyBiosPlatform->GetPlatformInfo (\r
                                 LegacyBiosPlatform,\r
                                 Id,\r
                                 (VOID *)&Table,\r
                                 &TableSize,\r
                                 &Location,\r
                                 &Alignment,\r
                                 Regs.X.DS,\r
                                 Regs.X.BX\r
                                 );\r
  switch (Id) {\r
    case EfiGetPlatformBinaryMpTable:\r
    {\r
      Legacy16Table->MpTablePtr    = (UINT32)(Regs.X.DS * 16 + Regs.X.BX);\r
      Legacy16Table->MpTableLength = (UINT32)TableSize;\r
      DEBUG ((DEBUG_INFO, "MP table in legacy region - %x\n", (UINTN)Legacy16Table->MpTablePtr));\r
      break;\r
    }\r
\r
    case EfiGetPlatformBinaryOemIntData:\r
    {\r
      Legacy16Table->OemIntSegment = Regs.X.DS;\r
      Legacy16Table->OemIntOffset  = Regs.X.BX;\r
      DEBUG ((DEBUG_INFO, "OemInt table in legacy region - %04x:%04x\n", (UINTN)Legacy16Table->OemIntSegment, (UINTN)Legacy16Table->OemIntOffset));\r
      break;\r
    }\r
\r
    case EfiGetPlatformBinaryOem32Data:\r
    {\r
      Legacy16Table->Oem32Segment = Regs.X.DS;\r
      Legacy16Table->Oem32Offset  = Regs.X.BX;\r
      DEBUG ((DEBUG_INFO, "Oem32 table in legacy region - %04x:%04x\n", (UINTN)Legacy16Table->Oem32Segment, (UINTN)Legacy16Table->Oem32Offset));\r
      break;\r
    }\r
\r
    case EfiGetPlatformBinaryOem16Data:\r
    {\r
      //\r
      //          Legacy16Table->Oem16Segment = Regs.X.DS;\r
      //          Legacy16Table->Oem16Offset  = Regs.X.BX;\r
      DEBUG ((DEBUG_INFO, "Oem16 table in legacy region - %04x:%04x\n", (UINTN)Legacy16Table->Oem16Segment, (UINTN)Legacy16Table->Oem16Offset));\r
      break;\r
    }\r
\r
    default:\r
    {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Phase 3 Copy table to final location\r
  //\r
  TablePtr = (UINT32)(Regs.X.DS * 16 + Regs.X.BX);\r
\r
  CopyMem (\r
    (VOID *)(UINTN)TablePtr,\r
    Table,\r
    TableSize\r
    );\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Copy SMBIOS table to EfiReservedMemoryType of memory for legacy boot.\r
\r
**/\r
VOID\r
CreateSmbiosTableInReservedMemory (\r
  VOID\r
  )\r
{\r
  SMBIOS_TABLE_ENTRY_POINT  *EntryPointStructure;\r
\r
  if ((mRuntimeSmbiosEntryPoint == NULL) ||\r
      (mReserveSmbiosEntryPoint == 0) ||\r
      (mStructureTableAddress == 0))\r
  {\r
    return;\r
  }\r
\r
  EntryPointStructure = (SMBIOS_TABLE_ENTRY_POINT *)mRuntimeSmbiosEntryPoint;\r
\r
  //\r
  // Copy SMBIOS Entry Point Structure\r
  //\r
  CopyMem (\r
    (VOID *)(UINTN)mReserveSmbiosEntryPoint,\r
    EntryPointStructure,\r
    EntryPointStructure->EntryPointLength\r
    );\r
\r
  //\r
  // Copy SMBIOS Structure Table into EfiReservedMemoryType memory\r
  //\r
  CopyMem (\r
    (VOID *)(UINTN)mStructureTableAddress,\r
    (VOID *)(UINTN)EntryPointStructure->TableAddress,\r
    EntryPointStructure->TableLength\r
    );\r
\r
  //\r
  // Update TableAddress in Entry Point Structure\r
  //\r
  EntryPointStructure               = (SMBIOS_TABLE_ENTRY_POINT *)(UINTN)mReserveSmbiosEntryPoint;\r
  EntryPointStructure->TableAddress = (UINT32)(UINTN)mStructureTableAddress;\r
\r
  //\r
  // Fixup checksums in the Entry Point Structure\r
  //\r
  EntryPointStructure->IntermediateChecksum        = 0;\r
  EntryPointStructure->EntryPointStructureChecksum = 0;\r
\r
  EntryPointStructure->IntermediateChecksum =\r
    CalculateCheckSum8 (\r
      (UINT8 *)EntryPointStructure + OFFSET_OF (SMBIOS_TABLE_ENTRY_POINT, IntermediateAnchorString),\r
      EntryPointStructure->EntryPointLength - OFFSET_OF (SMBIOS_TABLE_ENTRY_POINT, IntermediateAnchorString)\r
      );\r
  EntryPointStructure->EntryPointStructureChecksum =\r
    CalculateCheckSum8 ((UINT8 *)EntryPointStructure, EntryPointStructure->EntryPointLength);\r
}\r
\r
/**\r
  Assign drive number to legacy HDD drives prior to booting an EFI\r
  aware OS so the OS can access drives without an EFI driver.\r
  Note: BBS compliant drives ARE NOT available until this call by\r
  either shell or EFI.\r
\r
  @param  This                    Protocol instance pointer.\r
\r
  @retval EFI_SUCCESS             Drive numbers assigned\r
\r
**/\r
EFI_STATUS\r
GenericLegacyBoot (\r
  IN EFI_LEGACY_BIOS_PROTOCOL  *This\r
  )\r
{\r
  EFI_STATUS                         Status;\r
  LEGACY_BIOS_INSTANCE               *Private;\r
  EFI_IA32_REGISTER_SET              Regs;\r
  EFI_TO_COMPATIBILITY16_BOOT_TABLE  *EfiToLegacy16BootTable;\r
  EFI_LEGACY_BIOS_PLATFORM_PROTOCOL  *LegacyBiosPlatform;\r
  UINTN                              CopySize;\r
  VOID                               *AcpiPtr;\r
  HDD_INFO                           *HddInfo;\r
  HDD_INFO                           *LocalHddInfo;\r
  UINTN                              Index;\r
  EFI_COMPATIBILITY16_TABLE          *Legacy16Table;\r
  UINT32                             *BdaPtr;\r
  UINT16                             HddCount;\r
  UINT16                             BbsCount;\r
  BBS_TABLE                          *LocalBbsTable;\r
  UINT32                             *BaseVectorMaster;\r
  EFI_TIME                           BootTime;\r
  UINT32                             LocalTime;\r
  EFI_HANDLE                         IdeController;\r
  UINTN                              HandleCount;\r
  EFI_HANDLE                         *HandleBuffer;\r
  VOID                               *AcpiTable;\r
  UINTN                              ShadowAddress;\r
  UINT32                             Granularity;\r
\r
  LocalHddInfo  = NULL;\r
  HddCount      = 0;\r
  BbsCount      = 0;\r
  LocalBbsTable = NULL;\r
\r
  Private = LEGACY_BIOS_INSTANCE_FROM_THIS (This);\r
  DEBUG_CODE (\r
    DEBUG ((DEBUG_ERROR, "Start of legacy boot\n"));\r
    );\r
\r
  Legacy16Table          = Private->Legacy16Table;\r
  EfiToLegacy16BootTable = &Private->IntThunk->EfiToLegacy16BootTable;\r
  HddInfo                = &EfiToLegacy16BootTable->HddInfo[0];\r
\r
  LegacyBiosPlatform = Private->LegacyBiosPlatform;\r
\r
  EfiToLegacy16BootTable->MajorVersion = EFI_TO_LEGACY_MAJOR_VERSION;\r
  EfiToLegacy16BootTable->MinorVersion = EFI_TO_LEGACY_MINOR_VERSION;\r
\r
  //\r
  // If booting to a legacy OS then force HDD drives to the appropriate\r
  // boot mode by calling GetIdeHandle.\r
  // A reconnect -r can force all HDDs back to native mode.\r
  //\r
  IdeController = NULL;\r
  if ((mBootMode == BOOT_LEGACY_OS) || (mBootMode == BOOT_UNCONVENTIONAL_DEVICE)) {\r
    Status = LegacyBiosPlatform->GetPlatformHandle (\r
                                   Private->LegacyBiosPlatform,\r
                                   EfiGetPlatformIdeHandle,\r
                                   0,\r
                                   &HandleBuffer,\r
                                   &HandleCount,\r
                                   NULL\r
                                   );\r
    if (!EFI_ERROR (Status)) {\r
      IdeController = HandleBuffer[0];\r
    }\r
  }\r
\r
  //\r
  // Unlock the Legacy BIOS region\r
  //\r
  Private->LegacyRegion->UnLock (\r
                           Private->LegacyRegion,\r
                           0xE0000,\r
                           0x20000,\r
                           &Granularity\r
                           );\r
\r
  //\r
  // Reconstruct the Legacy16 boot memory map\r
  //\r
  LegacyBiosBuildE820 (Private, &CopySize);\r
  if (CopySize > Private->Legacy16Table->E820Length) {\r
    ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));\r
    Regs.X.AX = Legacy16GetTableAddress;\r
    Regs.X.BX = (UINT16)0x0;  // Any region\r
    Regs.X.CX = (UINT16)CopySize;\r
    Regs.X.DX = (UINT16)0x4;  // Alignment\r
    Private->LegacyBios.FarCall86 (\r
                          &Private->LegacyBios,\r
                          Private->Legacy16Table->Compatibility16CallSegment,\r
                          Private->Legacy16Table->Compatibility16CallOffset,\r
                          &Regs,\r
                          NULL,\r
                          0\r
                          );\r
\r
    Private->Legacy16Table->E820Pointer = (UINT32)(Regs.X.DS * 16 + Regs.X.BX);\r
    Private->Legacy16Table->E820Length  = (UINT32)CopySize;\r
    if (Regs.X.AX != 0) {\r
      DEBUG ((DEBUG_ERROR, "Legacy16 E820 length insufficient\n"));\r
      return EFI_OUT_OF_RESOURCES;\r
    } else {\r
      CopyMem (\r
        (VOID *)(UINTN)Private->Legacy16Table->E820Pointer,\r
        Private->E820Table,\r
        CopySize\r
        );\r
    }\r
  } else {\r
    CopyMem (\r
      (VOID *)(UINTN)Private->Legacy16Table->E820Pointer,\r
      Private->E820Table,\r
      CopySize\r
      );\r
    Private->Legacy16Table->E820Length = (UINT32)CopySize;\r
  }\r
\r
  //\r
  // We do not ASSERT if SmbiosTable not found. It is possible that a platform does not produce SmbiosTable.\r
  //\r
  if (mReserveSmbiosEntryPoint == 0) {\r
    DEBUG ((DEBUG_INFO, "Smbios table is not found!\n"));\r
  }\r
\r
  CreateSmbiosTableInReservedMemory ();\r
  EfiToLegacy16BootTable->SmbiosTable = (UINT32)(UINTN)mReserveSmbiosEntryPoint;\r
\r
  AcpiTable = NULL;\r
  Status    = EfiGetSystemConfigurationTable (\r
                &gEfiAcpi20TableGuid,\r
                &AcpiTable\r
                );\r
  if (EFI_ERROR (Status)) {\r
    Status = EfiGetSystemConfigurationTable (\r
               &gEfiAcpi10TableGuid,\r
               &AcpiTable\r
               );\r
  }\r
\r
  //\r
  // We do not ASSERT if AcpiTable not found. It is possible that a platform does not produce AcpiTable.\r
  //\r
  if (AcpiTable == NULL) {\r
    DEBUG ((DEBUG_INFO, "ACPI table is not found!\n"));\r
  }\r
\r
  EfiToLegacy16BootTable->AcpiTable = (UINT32)(UINTN)AcpiTable;\r
\r
  //\r
  // Get RSD Ptr table rev at offset 15 decimal\r
  // Rev = 0 Length is 20 decimal\r
  // Rev != 0 Length is UINT32 at offset 20 decimal\r
  //\r
  if (AcpiTable != NULL) {\r
    AcpiPtr = AcpiTable;\r
    if (*((UINT8 *)AcpiPtr + 15) == 0) {\r
      CopySize = 20;\r
    } else {\r
      AcpiPtr  = ((UINT8 *)AcpiPtr + 20);\r
      CopySize = (*(UINT32 *)AcpiPtr);\r
    }\r
\r
    CopyMem (\r
      (VOID *)(UINTN)Private->Legacy16Table->AcpiRsdPtrPointer,\r
      AcpiTable,\r
      CopySize\r
      );\r
  }\r
\r
  //\r
  // Make sure all PCI Interrupt Line register are programmed to match 8259\r
  //\r
  PciProgramAllInterruptLineRegisters (Private);\r
\r
  //\r
  // Unlock the Legacy BIOS region as PciProgramAllInterruptLineRegisters\r
  // can lock it.\r
  //\r
  Private->LegacyRegion->UnLock (\r
                           Private->LegacyRegion,\r
                           Private->BiosStart,\r
                           Private->LegacyBiosImageSize,\r
                           &Granularity\r
                           );\r
\r
  //\r
  // Configure Legacy Device Magic\r
  //\r
  // Only do this code if booting legacy OS\r
  //\r
  if ((mBootMode == BOOT_LEGACY_OS) || (mBootMode == BOOT_UNCONVENTIONAL_DEVICE)) {\r
    UpdateSioData (Private);\r
  }\r
\r
  //\r
  // Setup BDA and EBDA standard areas before Legacy Boot\r
  //\r
  ACCESS_PAGE0_CODE (\r
    LegacyBiosCompleteBdaBeforeBoot (Private);\r
    );\r
  LegacyBiosCompleteStandardCmosBeforeBoot (Private);\r
\r
  //\r
  // We must build IDE data, if it hasn't been done, before PciShadowRoms\r
  // to insure EFI drivers are connected.\r
  //\r
  LegacyBiosBuildIdeData (Private, &HddInfo, 1);\r
  UpdateAllIdentifyDriveData (Private);\r
\r
  //\r
  // Clear IO BAR, if IDE controller in legacy mode.\r
  //\r
  InitLegacyIdeController (IdeController);\r
\r
  //\r
  // Generate number of ticks since midnight for BDA. DOS requires this\r
  // for its time. We have to make assumptions as to how long following\r
  // code takes since after PciShadowRoms PciIo is gone. Place result in\r
  // 40:6C-6F\r
  //\r
  // Adjust value by 1 second.\r
  //\r
  gRT->GetTime (&BootTime, NULL);\r
  LocalTime  = BootTime.Hour * 3600 + BootTime.Minute * 60 + BootTime.Second;\r
  LocalTime += 1;\r
\r
  //\r
  // Multiply result by 18.2 for number of ticks since midnight.\r
  // Use 182/10 to avoid floating point math.\r
  //\r
  LocalTime = (LocalTime * 182) / 10;\r
  ACCESS_PAGE0_CODE (\r
    BdaPtr  = (UINT32 *)(UINTN)0x46C;\r
    *BdaPtr = LocalTime;\r
    );\r
\r
  //\r
  // Shadow PCI ROMs. We must do this near the end since this will kick\r
  // of Native EFI drivers that may be needed to collect info for Legacy16\r
  //\r
  //  WARNING: PciIo is gone after this call.\r
  //\r
  PciShadowRoms (Private);\r
\r
  //\r
  // Shadow PXE base code, BIS etc.\r
  //\r
  Private->LegacyRegion->UnLock (Private->LegacyRegion, 0xc0000, 0x40000, &Granularity);\r
  ShadowAddress = Private->OptionRom;\r
  Private->LegacyBiosPlatform->PlatformHooks (\r
                                 Private->LegacyBiosPlatform,\r
                                 EfiPlatformHookShadowServiceRoms,\r
                                 0,\r
                                 0,\r
                                 &ShadowAddress,\r
                                 Legacy16Table,\r
                                 NULL\r
                                 );\r
  Private->OptionRom = (UINT32)ShadowAddress;\r
  //\r
  // Register Legacy SMI Handler\r
  //\r
  LegacyBiosPlatform->SmmInit (\r
                        LegacyBiosPlatform,\r
                        EfiToLegacy16BootTable\r
                        );\r
\r
  //\r
  // Let platform code know the boot options\r
  //\r
  LegacyBiosGetBbsInfo (\r
    This,\r
    &HddCount,\r
    &LocalHddInfo,\r
    &BbsCount,\r
    &LocalBbsTable\r
    );\r
\r
  DEBUG_CODE (\r
    PrintPciInterruptRegister ();\r
    PrintBbsTable (LocalBbsTable);\r
    PrintHddInfo (LocalHddInfo);\r
    );\r
  //\r
  // If drive wasn't spun up then BuildIdeData may have found new drives.\r
  // Need to update BBS boot priority.\r
  //\r
  for (Index = 0; Index < MAX_IDE_CONTROLLER; Index++) {\r
    if ((LocalHddInfo[Index].IdentifyDrive[0].Raw[0] != 0) &&\r
        (LocalBbsTable[2 * Index + 1].BootPriority == BBS_IGNORE_ENTRY)\r
        )\r
    {\r
      LocalBbsTable[2 * Index + 1].BootPriority = BBS_UNPRIORITIZED_ENTRY;\r
    }\r
\r
    if ((LocalHddInfo[Index].IdentifyDrive[1].Raw[0] != 0) &&\r
        (LocalBbsTable[2 * Index + 2].BootPriority == BBS_IGNORE_ENTRY)\r
        )\r
    {\r
      LocalBbsTable[2 * Index + 2].BootPriority = BBS_UNPRIORITIZED_ENTRY;\r
    }\r
  }\r
\r
  Private->LegacyRegion->UnLock (\r
                           Private->LegacyRegion,\r
                           0xc0000,\r
                           0x40000,\r
                           &Granularity\r
                           );\r
\r
  LegacyBiosPlatform->PrepareToBoot (\r
                        LegacyBiosPlatform,\r
                        mBbsDevicePathPtr,\r
                        mBbsTable,\r
                        mLoadOptionsSize,\r
                        mLoadOptions,\r
                        (VOID *)&Private->IntThunk->EfiToLegacy16BootTable\r
                        );\r
\r
  //\r
  // If no boot device return to BDS\r
  //\r
  if ((mBootMode == BOOT_LEGACY_OS) || (mBootMode == BOOT_UNCONVENTIONAL_DEVICE)) {\r
    for (Index = 0; Index < BbsCount; Index++) {\r
      if ((LocalBbsTable[Index].BootPriority != BBS_DO_NOT_BOOT_FROM) &&\r
          (LocalBbsTable[Index].BootPriority != BBS_UNPRIORITIZED_ENTRY) &&\r
          (LocalBbsTable[Index].BootPriority != BBS_IGNORE_ENTRY))\r
      {\r
        break;\r
      }\r
    }\r
\r
    if (Index == BbsCount) {\r
      return EFI_DEVICE_ERROR;\r
    }\r
  }\r
\r
  //\r
  // Let the Legacy16 code know the device path type for legacy boot\r
  //\r
  EfiToLegacy16BootTable->DevicePathType = mBbsDevicePathPtr->DeviceType;\r
\r
  //\r
  // Copy MP table, if it exists.\r
  //\r
  LegacyGetDataOrTable (This, EfiGetPlatformBinaryMpTable);\r
\r
  if (!Private->LegacyBootEntered) {\r
    //\r
    // Copy OEM INT Data, if it exists. Note: This code treats any data\r
    // as a bag of bits and knows nothing of the contents nor cares.\r
    // Contents are IBV specific.\r
    //\r
    LegacyGetDataOrTable (This, EfiGetPlatformBinaryOemIntData);\r
\r
    //\r
    // Copy OEM16 Data, if it exists.Note: This code treats any data\r
    // as a bag of bits and knows nothing of the contents nor cares.\r
    // Contents are IBV specific.\r
    //\r
    LegacyGetDataOrTable (This, EfiGetPlatformBinaryOem16Data);\r
\r
    //\r
    // Copy OEM32 Data, if it exists.Note: This code treats any data\r
    // as a bag of bits and knows nothing of the contents nor cares.\r
    // Contents are IBV specific.\r
    //\r
    LegacyGetDataOrTable (This, EfiGetPlatformBinaryOem32Data);\r
  }\r
\r
  //\r
  // Call into Legacy16 code to prepare for INT 19h\r
  //\r
  ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));\r
  Regs.X.AX = Legacy16PrepareToBoot;\r
\r
  //\r
  // Pass in handoff data\r
  //\r
  Regs.X.ES = NORMALIZE_EFI_SEGMENT ((UINTN)EfiToLegacy16BootTable);\r
  Regs.X.BX = NORMALIZE_EFI_OFFSET ((UINTN)EfiToLegacy16BootTable);\r
\r
  Private->LegacyBios.FarCall86 (\r
                        This,\r
                        Private->Legacy16CallSegment,\r
                        Private->Legacy16CallOffset,\r
                        &Regs,\r
                        NULL,\r
                        0\r
                        );\r
\r
  if (Regs.X.AX != 0) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  //\r
  // Lock the Legacy BIOS region\r
  //\r
  Private->LegacyRegion->Lock (\r
                           Private->LegacyRegion,\r
                           0xc0000,\r
                           0x40000,\r
                           &Granularity\r
                           );\r
\r
  if ((Private->Legacy16Table->TableLength >= OFFSET_OF (EFI_COMPATIBILITY16_TABLE, HiPermanentMemoryAddress)) &&\r
      ((Private->Legacy16Table->UmaAddress != 0) && (Private->Legacy16Table->UmaSize != 0)))\r
  {\r
    //\r
    // Here we could reduce UmaAddress down as far as Private->OptionRom, taking into\r
    // account the granularity of the access control.\r
    //\r
    DEBUG ((\r
      DEBUG_INFO,\r
      "Unlocking UMB RAM region 0x%x-0x%x\n",\r
      Private->Legacy16Table->UmaAddress,\r
      Private->Legacy16Table->UmaAddress + Private->Legacy16Table->UmaSize\r
      ));\r
\r
    Private->LegacyRegion->UnLock (\r
                             Private->LegacyRegion,\r
                             Private->Legacy16Table->UmaAddress,\r
                             Private->Legacy16Table->UmaSize,\r
                             &Granularity\r
                             );\r
  }\r
\r
  //\r
  // Lock attributes of the Legacy Region if chipset supports\r
  //\r
  Private->LegacyRegion->BootLock (\r
                           Private->LegacyRegion,\r
                           0xc0000,\r
                           0x40000,\r
                           &Granularity\r
                           );\r
\r
  //\r
  // Call into Legacy16 code to do the INT 19h\r
  //\r
  EnableAllControllers (Private);\r
  if ((mBootMode == BOOT_LEGACY_OS) || (mBootMode == BOOT_UNCONVENTIONAL_DEVICE)) {\r
    //\r
    // Signal all the events that are waiting on EVT_SIGNAL_LEGACY_BOOT\r
    //\r
    EfiSignalEventLegacyBoot ();\r
\r
    //\r
    // Report Status Code to indicate legacy boot event was signalled\r
    //\r
    REPORT_STATUS_CODE (\r
      EFI_PROGRESS_CODE,\r
      (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_PC_LEGACY_BOOT_EVENT)\r
      );\r
\r
    DEBUG ((DEBUG_INFO, "Legacy INT19 Boot...\n"));\r
\r
    //\r
    // Disable DXE Timer while executing in real mode\r
    //\r
    Private->Timer->SetTimerPeriod (Private->Timer, 0);\r
\r
    //\r
    // Save and disable interrupt of debug timer\r
    //\r
    SaveAndSetDebugTimerInterrupt (FALSE);\r
\r
    //\r
    // Put the 8259 into its legacy mode by reprogramming the vector bases\r
    //\r
    Private->Legacy8259->SetVectorBase (Private->Legacy8259, LEGACY_MODE_BASE_VECTOR_MASTER, LEGACY_MODE_BASE_VECTOR_SLAVE);\r
    //\r
    // PC History\r
    //   The original PC used INT8-F for master PIC. Since these mapped over\r
    //   processor exceptions TIANO moved the master PIC to INT68-6F.\r
    // We need to set these back to the Legacy16 unexpected interrupt(saved\r
    // in LegacyBios.c) since some OS see that these have values different from\r
    // what is expected and invoke them. Since the legacy OS corrupts EFI\r
    // memory, there is no handler for these interrupts and OS blows up.\r
    //\r
    // We need to save the TIANO values for the rare case that the Legacy16\r
    // code cannot boot but knows memory hasn't been destroyed.\r
    //\r
    // To compound the problem, video takes over one of these INTS and must be\r
    // be left.\r
    // @bug - determine if video hooks INT(in which case we must find new\r
    //          set of TIANO vectors) or takes it over.\r
    //\r
    //\r
    ACCESS_PAGE0_CODE (\r
      BaseVectorMaster = (UINT32 *)(sizeof (UINT32) * PROTECTED_MODE_BASE_VECTOR_MASTER);\r
      for (Index = 0; Index < 8; Index++) {\r
      Private->ThunkSavedInt[Index] = BaseVectorMaster[Index];\r
      if (Private->ThunkSeg == (UINT16)(BaseVectorMaster[Index] >> 16)) {\r
        BaseVectorMaster[Index] = (UINT32)(Private->BiosUnexpectedInt);\r
      }\r
    }\r
\r
      );\r
\r
    ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));\r
    Regs.X.AX = Legacy16Boot;\r
\r
    Private->LegacyBios.FarCall86 (\r
                          This,\r
                          Private->Legacy16CallSegment,\r
                          Private->Legacy16CallOffset,\r
                          &Regs,\r
                          NULL,\r
                          0\r
                          );\r
\r
    ACCESS_PAGE0_CODE (\r
      BaseVectorMaster = (UINT32 *)(sizeof (UINT32) * PROTECTED_MODE_BASE_VECTOR_MASTER);\r
      for (Index = 0; Index < 8; Index++) {\r
      BaseVectorMaster[Index] = Private->ThunkSavedInt[Index];\r
    }\r
\r
      );\r
  }\r
\r
  Private->LegacyBootEntered = TRUE;\r
  if ((mBootMode == BOOT_LEGACY_OS) || (mBootMode == BOOT_UNCONVENTIONAL_DEVICE)) {\r
    //\r
    // Should never return unless never passed control to 0:7c00(first stage\r
    // OS loader) and only then if no bootable device found.\r
    //\r
    return EFI_DEVICE_ERROR;\r
  } else {\r
    //\r
    // If boot to EFI then expect to return to caller\r
    //\r
    return EFI_SUCCESS;\r
  }\r
}\r
\r
/**\r
  Assign drive number to legacy HDD drives prior to booting an EFI\r
  aware OS so the OS can access drives without an EFI driver.\r
  Note: BBS compliant drives ARE NOT available until this call by\r
  either shell or EFI.\r
\r
  @param  This                    Protocol instance pointer.\r
  @param  BbsCount                Number of BBS_TABLE structures\r
  @param  BbsTable                List BBS entries\r
\r
  @retval EFI_SUCCESS             Drive numbers assigned\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
LegacyBiosPrepareToBootEfi (\r
  IN EFI_LEGACY_BIOS_PROTOCOL  *This,\r
  OUT UINT16                   *BbsCount,\r
  OUT BBS_TABLE                **BbsTable\r
  )\r
{\r
  EFI_STATUS                         Status;\r
  EFI_TO_COMPATIBILITY16_BOOT_TABLE  *EfiToLegacy16BootTable;\r
  LEGACY_BIOS_INSTANCE               *Private;\r
\r
  Private                = LEGACY_BIOS_INSTANCE_FROM_THIS (This);\r
  EfiToLegacy16BootTable = &Private->IntThunk->EfiToLegacy16BootTable;\r
  mBootMode              = BOOT_EFI_OS;\r
  mBbsDevicePathPtr      = NULL;\r
  Status                 = GenericLegacyBoot (This);\r
  *BbsTable              = (BBS_TABLE *)(UINTN)EfiToLegacy16BootTable->BbsTable;\r
  *BbsCount              = (UINT16)(sizeof (Private->IntThunk->BbsTable) / sizeof (BBS_TABLE));\r
  return Status;\r
}\r
\r
/**\r
  To boot from an unconventional device like parties and/or execute HDD diagnostics.\r
\r
  @param  This            Protocol instance pointer.\r
  @param  Attributes      How to interpret the other input parameters\r
  @param  BbsEntry        The 0-based index into the BbsTable for the parent\r
                          device.\r
  @param  BeerData        Pointer to the 128 bytes of ram BEER data.\r
  @param  ServiceAreaData Pointer to the 64 bytes of raw Service Area data. The\r
                          caller must provide a pointer to the specific Service\r
                          Area and not the start all Service Areas.\r
\r
  @retval EFI_INVALID_PARAMETER if error. Does NOT return if no error.\r
\r
***/\r
EFI_STATUS\r
EFIAPI\r
LegacyBiosBootUnconventionalDevice (\r
  IN EFI_LEGACY_BIOS_PROTOCOL  *This,\r
  IN UDC_ATTRIBUTES            Attributes,\r
  IN UINTN                     BbsEntry,\r
  IN VOID                      *BeerData,\r
  IN VOID                      *ServiceAreaData\r
  )\r
{\r
  EFI_STATUS                         Status;\r
  EFI_TO_COMPATIBILITY16_BOOT_TABLE  *EfiToLegacy16BootTable;\r
  LEGACY_BIOS_INSTANCE               *Private;\r
  UD_TABLE                           *UcdTable;\r
  UINTN                              Index;\r
  UINT16                             BootPriority;\r
  BBS_TABLE                          *BbsTable;\r
\r
  BootPriority      = 0;\r
  Private           = LEGACY_BIOS_INSTANCE_FROM_THIS (This);\r
  mBootMode         = BOOT_UNCONVENTIONAL_DEVICE;\r
  mBbsDevicePathPtr = &mBbsDevicePathNode;\r
  mAttributes       = Attributes;\r
  mBbsEntry         = BbsEntry;\r
  mBeerData         = BeerData, mServiceAreaData = ServiceAreaData;\r
\r
  EfiToLegacy16BootTable = &Private->IntThunk->EfiToLegacy16BootTable;\r
\r
  //\r
  // Do input parameter checking\r
  //\r
  if ((Attributes.DirectoryServiceValidity == 0) &&\r
      (Attributes.RabcaUsedFlag == 0) &&\r
      (Attributes.ExecuteHddDiagnosticsFlag == 0)\r
      )\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (((Attributes.DirectoryServiceValidity != 0) && (ServiceAreaData == NULL)) ||\r
      (((Attributes.DirectoryServiceValidity | Attributes.RabcaUsedFlag) != 0) && (BeerData == NULL))\r
      )\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  UcdTable = (UD_TABLE *)AllocatePool (\r
                           sizeof (UD_TABLE)\r
                           );\r
  if (NULL == UcdTable) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  EfiToLegacy16BootTable->UnconventionalDeviceTable = (UINT32)(UINTN)UcdTable;\r
  UcdTable->Attributes                              = Attributes;\r
  UcdTable->BbsTableEntryNumberForParentDevice      = (UINT8)BbsEntry;\r
  //\r
  // Force all existing BBS entries to DoNotBoot. This allows 16-bit CSM\r
  // to assign drive numbers but bot boot from. Only newly created entries\r
  // will be valid.\r
  //\r
  BbsTable = (BBS_TABLE *)(UINTN)EfiToLegacy16BootTable->BbsTable;\r
  for (Index = 0; Index < EfiToLegacy16BootTable->NumberBbsEntries; Index++) {\r
    BbsTable[Index].BootPriority = BBS_DO_NOT_BOOT_FROM;\r
  }\r
\r
  //\r
  // If parent is onboard IDE then assign controller & device number\r
  // else they are 0.\r
  //\r
  if (BbsEntry < MAX_IDE_CONTROLLER * 2) {\r
    UcdTable->DeviceNumber = (UINT8)((BbsEntry - 1) % 2);\r
  }\r
\r
  if (BeerData != NULL) {\r
    CopyMem (\r
      (VOID *)UcdTable->BeerData,\r
      BeerData,\r
      (UINTN)128\r
      );\r
  }\r
\r
  if (ServiceAreaData != NULL) {\r
    CopyMem (\r
      (VOID *)UcdTable->ServiceAreaData,\r
      ServiceAreaData,\r
      (UINTN)64\r
      );\r
  }\r
\r
  //\r
  // For each new entry do the following:\r
  //   1. Increment current number of BBS entries\r
  //   2. Copy parent entry to new entry.\r
  //   3. Zero out BootHandler Offset & segment\r
  //   4. Set appropriate device type. BEV(0x80) for HDD diagnostics\r
  //      and Floppy(0x01) for PARTIES boot.\r
  //   5. Assign new priority.\r
  //\r
  if ((Attributes.ExecuteHddDiagnosticsFlag) != 0) {\r
    EfiToLegacy16BootTable->NumberBbsEntries += 1;\r
\r
    CopyMem (\r
      (VOID *)&BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootPriority,\r
      (VOID *)&BbsTable[BbsEntry].BootPriority,\r
      sizeof (BBS_TABLE)\r
      );\r
\r
    BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootHandlerOffset  = 0;\r
    BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootHandlerSegment = 0;\r
    BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].DeviceType         = 0x80;\r
\r
    UcdTable->BbsTableEntryNumberForHddDiag = (UINT8)(EfiToLegacy16BootTable->NumberBbsEntries - 1);\r
\r
    BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootPriority = BootPriority;\r
    BootPriority                                                   += 1;\r
\r
    //\r
    // Set device type as BBS_TYPE_DEV for PARTIES diagnostic\r
    //\r
    mBbsDevicePathNode.DeviceType = BBS_TYPE_BEV;\r
  }\r
\r
  if (((Attributes.DirectoryServiceValidity | Attributes.RabcaUsedFlag)) != 0) {\r
    EfiToLegacy16BootTable->NumberBbsEntries += 1;\r
    CopyMem (\r
      (VOID *)&BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootPriority,\r
      (VOID *)&BbsTable[BbsEntry].BootPriority,\r
      sizeof (BBS_TABLE)\r
      );\r
\r
    BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootHandlerOffset  = 0;\r
    BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootHandlerSegment = 0;\r
    BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].DeviceType         = 0x01;\r
    UcdTable->BbsTableEntryNumberForBoot                                  = (UINT8)(EfiToLegacy16BootTable->NumberBbsEntries - 1);\r
    BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootPriority       = BootPriority;\r
\r
    //\r
    // Set device type as BBS_TYPE_FLOPPY for PARTIES boot as floppy\r
    //\r
    mBbsDevicePathNode.DeviceType = BBS_TYPE_FLOPPY;\r
  }\r
\r
  //\r
  // Build the BBS Device Path for this boot selection\r
  //\r
  mBbsDevicePathNode.Header.Type    = BBS_DEVICE_PATH;\r
  mBbsDevicePathNode.Header.SubType = BBS_BBS_DP;\r
  SetDevicePathNodeLength (&mBbsDevicePathNode.Header, sizeof (BBS_BBS_DEVICE_PATH));\r
  mBbsDevicePathNode.StatusFlag = 0;\r
  mBbsDevicePathNode.String[0]  = 0;\r
\r
  Status = GenericLegacyBoot (This);\r
  return Status;\r
}\r
\r
/**\r
  Attempt to legacy boot the BootOption. If the EFI contexted has been\r
  compromised this function will not return.\r
\r
  @param  This             Protocol instance pointer.\r
  @param  BbsDevicePath    EFI Device Path from BootXXXX variable.\r
  @param  LoadOptionsSize  Size of LoadOption in size.\r
  @param  LoadOptions      LoadOption from BootXXXX variable\r
\r
  @retval EFI_SUCCESS      Removable media not present\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
LegacyBiosLegacyBoot (\r
  IN EFI_LEGACY_BIOS_PROTOCOL  *This,\r
  IN  BBS_BBS_DEVICE_PATH      *BbsDevicePath,\r
  IN  UINT32                   LoadOptionsSize,\r
  IN  VOID                     *LoadOptions\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  mBbsDevicePathPtr = BbsDevicePath;\r
  mLoadOptionsSize  = LoadOptionsSize;\r
  mLoadOptions      = LoadOptions;\r
  mBootMode         = BOOT_LEGACY_OS;\r
  Status            = GenericLegacyBoot (This);\r
\r
  return Status;\r
}\r
\r
/**\r
  Convert EFI Memory Type to E820 Memory Type.\r
\r
  @param  Type  EFI Memory Type\r
\r
  @return ACPI Memory Type for EFI Memory Type\r
\r
**/\r
EFI_ACPI_MEMORY_TYPE\r
EfiMemoryTypeToE820Type (\r
  IN  UINT32  Type\r
  )\r
{\r
  switch (Type) {\r
    case EfiLoaderCode:\r
    case EfiLoaderData:\r
    case EfiBootServicesCode:\r
    case EfiBootServicesData:\r
    case EfiConventionalMemory:\r
    //\r
    // The memory of EfiRuntimeServicesCode and EfiRuntimeServicesData are\r
    // usable memory for legacy OS, because legacy OS is not aware of EFI runtime concept.\r
    // In ACPI specification, EfiRuntimeServiceCode and EfiRuntimeServiceData\r
    // should be mapped to AddressRangeReserved. This statement is for UEFI OS, not for legacy OS.\r
    //\r
    case EfiRuntimeServicesCode:\r
    case EfiRuntimeServicesData:\r
      return EfiAcpiAddressRangeMemory;\r
\r
    case EfiPersistentMemory:\r
      return EfiAddressRangePersistentMemory;\r
\r
    case EfiACPIReclaimMemory:\r
      return EfiAcpiAddressRangeACPI;\r
\r
    case EfiACPIMemoryNVS:\r
      return EfiAcpiAddressRangeNVS;\r
\r
    //\r
    // All other types map to reserved.\r
    // Adding the code just waists FLASH space.\r
    //\r
    //  case  EfiReservedMemoryType:\r
    //  case  EfiUnusableMemory:\r
    //  case  EfiMemoryMappedIO:\r
    //  case  EfiMemoryMappedIOPortSpace:\r
    //  case  EfiPalCode:\r
    //\r
    default:\r
      return EfiAcpiAddressRangeReserved;\r
  }\r
}\r
\r
/**\r
  Build the E820 table.\r
\r
  @param  Private  Legacy BIOS Instance data\r
  @param  Size     Size of E820 Table\r
\r
  @retval EFI_SUCCESS  It should always work.\r
\r
**/\r
EFI_STATUS\r
LegacyBiosBuildE820 (\r
  IN  LEGACY_BIOS_INSTANCE  *Private,\r
  OUT UINTN                 *Size\r
  )\r
{\r
  EFI_STATUS                   Status;\r
  EFI_E820_ENTRY64             *E820Table;\r
  EFI_MEMORY_DESCRIPTOR        *EfiMemoryMap;\r
  EFI_MEMORY_DESCRIPTOR        *EfiMemoryMapEnd;\r
  EFI_MEMORY_DESCRIPTOR        *EfiEntry;\r
  EFI_MEMORY_DESCRIPTOR        *NextEfiEntry;\r
  EFI_MEMORY_DESCRIPTOR        TempEfiEntry;\r
  UINTN                        EfiMemoryMapSize;\r
  UINTN                        EfiMapKey;\r
  UINTN                        EfiDescriptorSize;\r
  UINT32                       EfiDescriptorVersion;\r
  UINTN                        Index;\r
  EFI_PEI_HOB_POINTERS         Hob;\r
  EFI_HOB_RESOURCE_DESCRIPTOR  *ResourceHob;\r
  UINTN                        TempIndex;\r
  UINTN                        IndexSort;\r
  UINTN                        TempNextIndex;\r
  EFI_E820_ENTRY64             TempE820;\r
  EFI_ACPI_MEMORY_TYPE         TempType;\r
  BOOLEAN                      ChangedFlag;\r
  UINTN                        Above1MIndex;\r
  UINT64                       MemoryBlockLength;\r
\r
  E820Table = (EFI_E820_ENTRY64 *)Private->E820Table;\r
\r
  //\r
  // Get the EFI memory map.\r
  //\r
  EfiMemoryMapSize = 0;\r
  EfiMemoryMap     = NULL;\r
  Status           = gBS->GetMemoryMap (\r
                            &EfiMemoryMapSize,\r
                            EfiMemoryMap,\r
                            &EfiMapKey,\r
                            &EfiDescriptorSize,\r
                            &EfiDescriptorVersion\r
                            );\r
  ASSERT (Status == EFI_BUFFER_TOO_SMALL);\r
\r
  do {\r
    //\r
    // Use size returned for the AllocatePool.\r
    // We don't just multiply by 2 since the "for" loop below terminates on\r
    // EfiMemoryMapEnd which is dependent upon EfiMemoryMapSize. Otherwise\r
    // we process bogus entries and create bogus E820 entries.\r
    //\r
    EfiMemoryMap = (EFI_MEMORY_DESCRIPTOR *)AllocatePool (EfiMemoryMapSize);\r
    ASSERT (EfiMemoryMap != NULL);\r
    Status = gBS->GetMemoryMap (\r
                    &EfiMemoryMapSize,\r
                    EfiMemoryMap,\r
                    &EfiMapKey,\r
                    &EfiDescriptorSize,\r
                    &EfiDescriptorVersion\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (EfiMemoryMap);\r
    }\r
  } while (Status == EFI_BUFFER_TOO_SMALL);\r
\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Punch in the E820 table for memory less than 1 MB.\r
  // Assume ZeroMem () has been done on data structure.\r
  //\r
  //\r
  // First entry is 0 to (640k - EBDA)\r
  //\r
  ACCESS_PAGE0_CODE (\r
    E820Table[0].BaseAddr = 0;\r
    E820Table[0].Length   = (UINT64)((*(UINT16 *)(UINTN)0x40E) << 4);\r
    E820Table[0].Type     = EfiAcpiAddressRangeMemory;\r
    );\r
\r
  //\r
  // Second entry is (640k - EBDA) to 640k\r
  //\r
  E820Table[1].BaseAddr = E820Table[0].Length;\r
  E820Table[1].Length   = (UINT64)((640 * 1024) - E820Table[0].Length);\r
  E820Table[1].Type     = EfiAcpiAddressRangeReserved;\r
\r
  //\r
  // Third Entry is legacy BIOS\r
  // DO NOT CLAIM region from 0xA0000-0xDFFFF. OS can use free areas\r
  // to page in memory under 1MB.\r
  // Omit region from 0xE0000 to start of BIOS, if any. This can be\r
  // used for a multiple reasons including OPROMS.\r
  //\r
\r
  //\r
  // The CSM binary image size is not the actually size that CSM binary used,\r
  // to avoid memory corrupt, we declare the 0E0000 - 0FFFFF is used by CSM binary.\r
  //\r
  E820Table[2].BaseAddr = 0xE0000;\r
  E820Table[2].Length   = 0x20000;\r
  E820Table[2].Type     = EfiAcpiAddressRangeReserved;\r
\r
  Above1MIndex = 2;\r
\r
  //\r
  // Process the EFI map to produce E820 map;\r
  //\r
\r
  //\r
  // Sort memory map from low to high\r
  //\r
  EfiEntry        = EfiMemoryMap;\r
  NextEfiEntry    = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);\r
  EfiMemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)EfiMemoryMap + EfiMemoryMapSize);\r
  while (EfiEntry < EfiMemoryMapEnd) {\r
    while (NextEfiEntry < EfiMemoryMapEnd) {\r
      if (EfiEntry->PhysicalStart > NextEfiEntry->PhysicalStart) {\r
        CopyMem (&TempEfiEntry, EfiEntry, sizeof (EFI_MEMORY_DESCRIPTOR));\r
        CopyMem (EfiEntry, NextEfiEntry, sizeof (EFI_MEMORY_DESCRIPTOR));\r
        CopyMem (NextEfiEntry, &TempEfiEntry, sizeof (EFI_MEMORY_DESCRIPTOR));\r
      }\r
\r
      NextEfiEntry = NEXT_MEMORY_DESCRIPTOR (NextEfiEntry, EfiDescriptorSize);\r
    }\r
\r
    EfiEntry     = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);\r
    NextEfiEntry = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);\r
  }\r
\r
  EfiEntry        = EfiMemoryMap;\r
  EfiMemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)EfiMemoryMap + EfiMemoryMapSize);\r
  for (Index = Above1MIndex; (EfiEntry < EfiMemoryMapEnd) && (Index < EFI_MAX_E820_ENTRY - 1); ) {\r
    MemoryBlockLength = (UINT64)(LShiftU64 (EfiEntry->NumberOfPages, 12));\r
    if ((EfiEntry->PhysicalStart + MemoryBlockLength) < 0x100000) {\r
      //\r
      // Skip the memory block if under 1MB\r
      //\r
    } else {\r
      if (EfiEntry->PhysicalStart < 0x100000) {\r
        //\r
        // When the memory block spans below 1MB, ensure the memory block start address is at least 1MB\r
        //\r
        MemoryBlockLength      -= 0x100000 - EfiEntry->PhysicalStart;\r
        EfiEntry->PhysicalStart =  0x100000;\r
      }\r
\r
      //\r
      // Convert memory type to E820 type\r
      //\r
      TempType = EfiMemoryTypeToE820Type (EfiEntry->Type);\r
\r
      if ((E820Table[Index].Type == TempType) && (EfiEntry->PhysicalStart == (E820Table[Index].BaseAddr + E820Table[Index].Length))) {\r
        //\r
        // Grow an existing entry\r
        //\r
        E820Table[Index].Length += MemoryBlockLength;\r
      } else {\r
        //\r
        // Make a new entry\r
        //\r
        ++Index;\r
        E820Table[Index].BaseAddr = EfiEntry->PhysicalStart;\r
        E820Table[Index].Length   = MemoryBlockLength;\r
        E820Table[Index].Type     = TempType;\r
      }\r
    }\r
\r
    EfiEntry = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);\r
  }\r
\r
  FreePool (EfiMemoryMap);\r
\r
  //\r
  // Process the reserved memory map to produce E820 map ;\r
  //\r
  for (Hob.Raw = GetHobList (); !END_OF_HOB_LIST (Hob); Hob.Raw = GET_NEXT_HOB (Hob)) {\r
    if ((Hob.Raw != NULL) && (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_RESOURCE_DESCRIPTOR)) {\r
      ResourceHob = Hob.ResourceDescriptor;\r
      if (((ResourceHob->ResourceType == EFI_RESOURCE_MEMORY_MAPPED_IO) ||\r
           (ResourceHob->ResourceType == EFI_RESOURCE_FIRMWARE_DEVICE)  ||\r
           (ResourceHob->ResourceType == EFI_RESOURCE_MEMORY_RESERVED)) &&\r
          (ResourceHob->PhysicalStart > 0x100000) &&\r
          (Index < EFI_MAX_E820_ENTRY - 1))\r
      {\r
        ++Index;\r
        E820Table[Index].BaseAddr = ResourceHob->PhysicalStart;\r
        E820Table[Index].Length   = ResourceHob->ResourceLength;\r
        E820Table[Index].Type     = EfiAcpiAddressRangeReserved;\r
      }\r
    }\r
  }\r
\r
  Index++;\r
  Private->IntThunk->EfiToLegacy16InitTable.NumberE820Entries = (UINT32)Index;\r
  Private->IntThunk->EfiToLegacy16BootTable.NumberE820Entries = (UINT32)Index;\r
  Private->NumberE820Entries                                  = (UINT32)Index;\r
  *Size                                                       = (UINTN)(Index * sizeof (EFI_E820_ENTRY64));\r
\r
  //\r
  // Sort E820Table from low to high\r
  //\r
  for (TempIndex = 0; TempIndex < Index; TempIndex++) {\r
    ChangedFlag = FALSE;\r
    for (TempNextIndex = 1; TempNextIndex < Index - TempIndex; TempNextIndex++) {\r
      if (E820Table[TempNextIndex - 1].BaseAddr > E820Table[TempNextIndex].BaseAddr) {\r
        ChangedFlag       = TRUE;\r
        TempE820.BaseAddr = E820Table[TempNextIndex - 1].BaseAddr;\r
        TempE820.Length   = E820Table[TempNextIndex - 1].Length;\r
        TempE820.Type     = E820Table[TempNextIndex - 1].Type;\r
\r
        E820Table[TempNextIndex - 1].BaseAddr = E820Table[TempNextIndex].BaseAddr;\r
        E820Table[TempNextIndex - 1].Length   = E820Table[TempNextIndex].Length;\r
        E820Table[TempNextIndex - 1].Type     = E820Table[TempNextIndex].Type;\r
\r
        E820Table[TempNextIndex].BaseAddr = TempE820.BaseAddr;\r
        E820Table[TempNextIndex].Length   = TempE820.Length;\r
        E820Table[TempNextIndex].Type     = TempE820.Type;\r
      }\r
    }\r
\r
    if (!ChangedFlag) {\r
      break;\r
    }\r
  }\r
\r
  //\r
  // Remove the overlap range\r
  //\r
  for (TempIndex = 1; TempIndex < Index; TempIndex++) {\r
    if ((E820Table[TempIndex - 1].BaseAddr <= E820Table[TempIndex].BaseAddr) &&\r
        ((E820Table[TempIndex - 1].BaseAddr + E820Table[TempIndex - 1].Length) >=\r
         (E820Table[TempIndex].BaseAddr +E820Table[TempIndex].Length)))\r
    {\r
      //\r
      // Overlap range is found\r
      //\r
      ASSERT (E820Table[TempIndex - 1].Type == E820Table[TempIndex].Type);\r
\r
      if (TempIndex == Index - 1) {\r
        E820Table[TempIndex].BaseAddr = 0;\r
        E820Table[TempIndex].Length   = 0;\r
        E820Table[TempIndex].Type     = (EFI_ACPI_MEMORY_TYPE)0;\r
        Index--;\r
        break;\r
      } else {\r
        for (IndexSort = TempIndex; IndexSort < Index - 1; IndexSort++) {\r
          E820Table[IndexSort].BaseAddr = E820Table[IndexSort + 1].BaseAddr;\r
          E820Table[IndexSort].Length   = E820Table[IndexSort + 1].Length;\r
          E820Table[IndexSort].Type     = E820Table[IndexSort + 1].Type;\r
        }\r
\r
        Index--;\r
      }\r
    }\r
  }\r
\r
  Private->IntThunk->EfiToLegacy16InitTable.NumberE820Entries = (UINT32)Index;\r
  Private->IntThunk->EfiToLegacy16BootTable.NumberE820Entries = (UINT32)Index;\r
  Private->NumberE820Entries                                  = (UINT32)Index;\r
  *Size                                                       = (UINTN)(Index * sizeof (EFI_E820_ENTRY64));\r
\r
  //\r
  // Determine OS usable memory above 1MB\r
  //\r
  Private->IntThunk->EfiToLegacy16BootTable.OsMemoryAbove1Mb = 0x0000;\r
  for (TempIndex = Above1MIndex; TempIndex < Index; TempIndex++) {\r
    if ((E820Table[TempIndex].BaseAddr >= 0x100000) && (E820Table[TempIndex].BaseAddr < 0x100000000ULL)) {\r
      // not include above 4G memory\r
      //\r
      // ACPIReclaimMemory is also usable memory for ACPI OS, after OS dumps all ACPI tables.\r
      //\r
      if ((E820Table[TempIndex].Type == EfiAcpiAddressRangeMemory) || (E820Table[TempIndex].Type == EfiAcpiAddressRangeACPI)) {\r
        Private->IntThunk->EfiToLegacy16BootTable.OsMemoryAbove1Mb += (UINT32)(E820Table[TempIndex].Length);\r
      } else {\r
        break; // break at first not normal memory, because SMM may use reserved memory.\r
      }\r
    }\r
  }\r
\r
  Private->IntThunk->EfiToLegacy16InitTable.OsMemoryAbove1Mb = Private->IntThunk->EfiToLegacy16BootTable.OsMemoryAbove1Mb;\r
\r
  //\r
  // Print DEBUG information\r
  //\r
  for (TempIndex = 0; TempIndex < Index; TempIndex++) {\r
    DEBUG ((\r
      DEBUG_INFO,\r
      "E820[%2d]: 0x%016lx - 0x%016lx, Type = %d\n",\r
      TempIndex,\r
      E820Table[TempIndex].BaseAddr,\r
      (E820Table[TempIndex].BaseAddr + E820Table[TempIndex].Length),\r
      E820Table[TempIndex].Type\r
      ));\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Fill in the standard BDA and EBDA stuff prior to legacy Boot\r
\r
  @param  Private      Legacy BIOS Instance data\r
\r
  @retval EFI_SUCCESS  It should always work.\r
\r
**/\r
EFI_STATUS\r
LegacyBiosCompleteBdaBeforeBoot (\r
  IN  LEGACY_BIOS_INSTANCE  *Private\r
  )\r
{\r
  BDA_STRUC                    *Bda;\r
  UINT16                       MachineConfig;\r
  DEVICE_PRODUCER_DATA_HEADER  *SioPtr;\r
\r
  Bda           = (BDA_STRUC *)((UINTN)0x400);\r
  MachineConfig = 0;\r
\r
  SioPtr    = &(Private->IntThunk->EfiToLegacy16BootTable.SioData);\r
  Bda->Com1 = SioPtr->Serial[0].Address;\r
  Bda->Com2 = SioPtr->Serial[1].Address;\r
  Bda->Com3 = SioPtr->Serial[2].Address;\r
  Bda->Com4 = SioPtr->Serial[3].Address;\r
\r
  if (SioPtr->Serial[0].Address != 0x00) {\r
    MachineConfig += 0x200;\r
  }\r
\r
  if (SioPtr->Serial[1].Address != 0x00) {\r
    MachineConfig += 0x200;\r
  }\r
\r
  if (SioPtr->Serial[2].Address != 0x00) {\r
    MachineConfig += 0x200;\r
  }\r
\r
  if (SioPtr->Serial[3].Address != 0x00) {\r
    MachineConfig += 0x200;\r
  }\r
\r
  Bda->Lpt1 = SioPtr->Parallel[0].Address;\r
  Bda->Lpt2 = SioPtr->Parallel[1].Address;\r
  Bda->Lpt3 = SioPtr->Parallel[2].Address;\r
\r
  if (SioPtr->Parallel[0].Address != 0x00) {\r
    MachineConfig += 0x4000;\r
  }\r
\r
  if (SioPtr->Parallel[1].Address != 0x00) {\r
    MachineConfig += 0x4000;\r
  }\r
\r
  if (SioPtr->Parallel[2].Address != 0x00) {\r
    MachineConfig += 0x4000;\r
  }\r
\r
  Bda->NumberOfDrives = (UINT8)(Bda->NumberOfDrives + Private->IdeDriveCount);\r
  if (SioPtr->Floppy.NumberOfFloppy != 0x00) {\r
    MachineConfig    = (UINT16)(MachineConfig + 0x01 + (SioPtr->Floppy.NumberOfFloppy - 1) * 0x40);\r
    Bda->FloppyXRate = 0x07;\r
  }\r
\r
  Bda->Lpt1_2Timeout = 0x1414;\r
  Bda->Lpt3_4Timeout = 0x1414;\r
  Bda->Com1_2Timeout = 0x0101;\r
  Bda->Com3_4Timeout = 0x0101;\r
\r
  //\r
  // Force VGA and Coprocessor, indicate 101/102 keyboard\r
  //\r
  MachineConfig      = (UINT16)(MachineConfig + 0x00 + 0x02 + (SioPtr->MousePresent * 0x04));\r
  Bda->MachineConfig = MachineConfig;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Fill in the standard BDA for Keyboard LEDs\r
\r
  @param  This         Protocol instance pointer.\r
  @param  Leds         Current LED status\r
\r
  @retval EFI_SUCCESS  It should always work.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
LegacyBiosUpdateKeyboardLedStatus (\r
  IN EFI_LEGACY_BIOS_PROTOCOL  *This,\r
  IN  UINT8                    Leds\r
  )\r
{\r
  LEGACY_BIOS_INSTANCE   *Private;\r
  BDA_STRUC              *Bda;\r
  UINT8                  LocalLeds;\r
  EFI_IA32_REGISTER_SET  Regs;\r
\r
  Private = LEGACY_BIOS_INSTANCE_FROM_THIS (This);\r
\r
  ACCESS_PAGE0_CODE (\r
    Bda                 = (BDA_STRUC *)((UINTN)0x400);\r
    LocalLeds           = Leds;\r
    Bda->LedStatus      = (UINT8)((Bda->LedStatus &~0x07) | LocalLeds);\r
    LocalLeds           = (UINT8)(LocalLeds << 4);\r
    Bda->ShiftStatus    = (UINT8)((Bda->ShiftStatus &~0x70) | LocalLeds);\r
    LocalLeds           = (UINT8)(Leds & 0x20);\r
    Bda->KeyboardStatus = (UINT8)((Bda->KeyboardStatus &~0x20) | LocalLeds);\r
    );\r
\r
  //\r
  // Call into Legacy16 code to allow it to do any processing\r
  //\r
  ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));\r
  Regs.X.AX = Legacy16SetKeyboardLeds;\r
  Regs.H.CL = Leds;\r
\r
  Private->LegacyBios.FarCall86 (\r
                        &Private->LegacyBios,\r
                        Private->Legacy16Table->Compatibility16CallSegment,\r
                        Private->Legacy16Table->Compatibility16CallOffset,\r
                        &Regs,\r
                        NULL,\r
                        0\r
                        );\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Fill in the standard CMOS stuff prior to legacy Boot\r
\r
  @param  Private      Legacy BIOS Instance data\r
\r
  @retval EFI_SUCCESS  It should always work.\r
\r
**/\r
EFI_STATUS\r
LegacyBiosCompleteStandardCmosBeforeBoot (\r
  IN  LEGACY_BIOS_INSTANCE  *Private\r
  )\r
{\r
  UINT8   Bda;\r
  UINT8   Floppy;\r
  UINT32  Size;\r
\r
  //\r
  // Update CMOS locations\r
  // 10 floppy\r
  // 12,19,1A - ignore as OS don't use them and there is no standard due\r
  //            to large capacity drives\r
  // CMOS 14 = BDA 40:10 plus bit 3(display enabled)\r
  //\r
  ACCESS_PAGE0_CODE (\r
    Bda = (UINT8)(*((UINT8 *)((UINTN)0x410)) | BIT3);\r
    );\r
\r
  //\r
  // Force display enabled\r
  //\r
  Floppy = 0x00;\r
  if ((Bda & BIT0) != 0) {\r
    Floppy = BIT6;\r
  }\r
\r
  //\r
  // Check if 2.88MB floppy set\r
  //\r
  if ((Bda & (BIT7 | BIT6)) != 0) {\r
    Floppy = (UINT8)(Floppy | BIT1);\r
  }\r
\r
  LegacyWriteStandardCmos (CMOS_10, Floppy);\r
  LegacyWriteStandardCmos (CMOS_14, Bda);\r
\r
  //\r
  // Force Status Register A to set rate selection bits and divider\r
  //\r
  LegacyWriteStandardCmos (CMOS_0A, 0x26);\r
\r
  //\r
  // redo memory size since it can change\r
  //\r
  Size = (15 * SIZE_1MB) >> 10;\r
  if (Private->IntThunk->EfiToLegacy16InitTable.OsMemoryAbove1Mb < (15 * SIZE_1MB)) {\r
    Size = Private->IntThunk->EfiToLegacy16InitTable.OsMemoryAbove1Mb >> 10;\r
  }\r
\r
  LegacyWriteStandardCmos (CMOS_17, (UINT8)(Size & 0xFF));\r
  LegacyWriteStandardCmos (CMOS_30, (UINT8)(Size & 0xFF));\r
  LegacyWriteStandardCmos (CMOS_18, (UINT8)(Size >> 8));\r
  LegacyWriteStandardCmos (CMOS_31, (UINT8)(Size >> 8));\r
\r
  LegacyCalculateWriteStandardCmosChecksum ();\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Relocate this image under 4G memory for IPF.\r
\r
  @param  ImageHandle  Handle of driver image.\r
  @param  SystemTable  Pointer to system table.\r
\r
  @retval EFI_SUCCESS  Image successfully relocated.\r
  @retval EFI_ABORTED  Failed to relocate image.\r
\r
**/\r
EFI_STATUS\r
RelocateImageUnder4GIfNeeded (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  return EFI_SUCCESS;\r
}\r