[mirror_edk2.git] / IntelFrameworkModulePkg / 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 ((EFI_D_INFO, "\n"));\r
  DEBUG ((EFI_D_INFO, " NO  Prio bb/dd/ff cl/sc Type Stat segm:offs mfgs:mfgo dess:deso\n"));\r
  DEBUG ((EFI_D_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
      EFI_D_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
      EFI_D_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 ((EFI_D_INFO," ("));\r
      for (SubIndex = 0; String[SubIndex] != 0; SubIndex++) {\r
        DEBUG ((EFI_D_INFO, "%c", String[SubIndex]));\r
      }\r
      DEBUG ((EFI_D_INFO,")"));\r
    }\r
    DEBUG ((EFI_D_INFO,"\n"));\r
  }\r
\r
  DEBUG ((EFI_D_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 ((EFI_D_INFO, "\n"));\r
  for (Index = 0; Index < MAX_IDE_CONTROLLER; Index++) {\r
    DEBUG ((EFI_D_INFO, "Index - %04x\n", Index));\r
    DEBUG ((EFI_D_INFO, "  Status    - %04x\n", (UINTN)HddInfo[Index].Status));\r
    DEBUG ((EFI_D_INFO, "  B/D/F     - %02x/%02x/%02x\n", (UINTN)HddInfo[Index].Bus, (UINTN)HddInfo[Index].Device, (UINTN)HddInfo[Index].Function));\r
    DEBUG ((EFI_D_INFO, "  Command   - %04x\n", HddInfo[Index].CommandBaseAddress));\r
    DEBUG ((EFI_D_INFO, "  Control   - %04x\n", HddInfo[Index].ControlBaseAddress));\r
    DEBUG ((EFI_D_INFO, "  BusMaster - %04x\n", HddInfo[Index].BusMasterAddress));\r
    DEBUG ((EFI_D_INFO, "  HddIrq    - %02x\n", HddInfo[Index].HddIrq));\r
    DEBUG ((EFI_D_INFO, "  IdentifyDrive[0].Raw[0] - %x\n", HddInfo[Index].IdentifyDrive[0].Raw[0]));\r
    DEBUG ((EFI_D_INFO, "  IdentifyDrive[1].Raw[0] - %x\n", HddInfo[Index].IdentifyDrive[1].Raw[0]));\r
  }\r
\r
  DEBUG ((EFI_D_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 ((EFI_D_INFO, "\n"));\r
  DEBUG ((EFI_D_INFO, " bb/dd/ff interrupt line interrupt pin\n"));\r
  DEBUG ((EFI_D_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
    if (!EFI_ERROR (Status)) {\r
      Status = PciIo->GetLocation (\r
                        PciIo,\r
                        &Segment,\r
                        &Bus,\r
                        &Device,\r
                        &Function\r
                        );\r
    }\r
    if (!EFI_ERROR (Status)) {\r
      DEBUG ((EFI_D_INFO, " %02x/%02x/%02x 0x%02x           0x%02x\n",\r
              Bus, Device, Function, Interrupt[0], Interrupt[1]));\r
    }\r
  }\r
  DEBUG ((EFI_D_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
\r
  if (HandleBuffer != NULL) {\r
    FreePool (HandleBuffer);\r
  }\r
\r
  return EFI_SUCCESS;\r
\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
  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
/**\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
  // 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
/**\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 ((EFI_D_INFO, "LegacyGetDataOrTable - ID: %x, %r\n", (UINTN)Id, Status));\r
        DEBUG ((EFI_D_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 ((EFI_D_ERROR, "Table ID %x length insufficient\n", Id));\r
      return EFI_OUT_OF_RESOURCES;\r
    } else {\r
      break;\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 ((EFI_D_INFO, "MP table in legacy region - %x\n", (UINTN)Legacy16Table->MpTablePtr));\r
      break;\r
    }\r
\r
  case EfiGetPlatformBinaryOemIntData:\r
    {\r
\r
      Legacy16Table->OemIntSegment  = Regs.X.DS;\r
      Legacy16Table->OemIntOffset   = Regs.X.BX;\r
      DEBUG ((EFI_D_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 ((EFI_D_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 ((EFI_D_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
  // 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
    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 ((EFI_D_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
  // 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.CX = (UINT16) CopySize;\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 ((EFI_D_ERROR, "Legacy16 E820 length insufficient\n"));\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 possbile that a platform does not produce SmbiosTable.\r
  //\r
  if (mReserveSmbiosEntryPoint == 0) {\r
    DEBUG ((EFI_D_INFO, "Smbios table is not found!\n"));\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
  // We do not ASSERT if AcpiTable not found. It is possbile that a platform does not produce AcpiTable.\r
  //\r
  if (AcpiTable == NULL) {\r
    DEBUG ((EFI_D_INFO, "ACPI table is not found!\n"));\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
\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
  // 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
  // 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
      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
      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
        break;\r
      }\r
    }\r
    if (Index == BbsCount) {\r
      return EFI_DEVICE_ERROR;\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
  // 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
    // Here we could reduce UmaAddress down as far as Private->OptionRom, taking into\r
    // account the granularity of the access control.\r
    //\r
    DEBUG((EFI_D_INFO, "Unlocking UMB RAM region 0x%x-0x%x\n", Private->Legacy16Table->UmaAddress,\r
                        Private->Legacy16Table->UmaAddress + Private->Legacy16Table->UmaSize));\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
    //\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 ((EFI_D_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
    //\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
    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
  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
/**\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
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (((Attributes.DirectoryServiceValidity != 0) && (ServiceAreaData == NULL)) ||\r
      (((Attributes.DirectoryServiceValidity | Attributes.RabcaUsedFlag) != 0) && (BeerData == NULL))\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
  // 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
  // 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
  // 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 back plus 1 descriptor 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. Otherwize\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 is 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
    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
        ++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
        //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
          Index--;\r
       }\r
    }\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) { // 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((EFI_D_INFO, "E820[%2d]: 0x%16lx ---- 0x%16lx, Type = 0x%x \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
/**\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
/**\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