IntelFrameworkModulePkg/Csm/LegacyBiosDxe/LegacyBootSupport.c

   1 /** @file
   2
   3 Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
   4
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions
   7 of the BSD License which accompanies this distribution.  The
   8 full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "LegacyBiosInterface.h"
  17 #include <IndustryStandard/Pci.h>
  18
  19 #define BOOT_LEGACY_OS              0
  20 #define BOOT_EFI_OS                 1
  21 #define BOOT_UNCONVENTIONAL_DEVICE  2
  22
  23 UINT32              mLoadOptionsSize    = 0;
  24 UINTN               mBootMode           = BOOT_LEGACY_OS;
  25 VOID                *mLoadOptions       = NULL;
  26 BBS_BBS_DEVICE_PATH *mBbsDevicePathPtr  = NULL;
  27 BBS_BBS_DEVICE_PATH mBbsDevicePathNode;
  28 UDC_ATTRIBUTES      mAttributes         = { 0, 0, 0, 0 };
  29 UINTN               mBbsEntry           = 0;
  30 VOID                *mBeerData          = NULL;
  31 VOID                *mServiceAreaData   = NULL;
  32 UINT64              mLowWater           = 0xffffffffffffffffULL;
  33
  34 extern BBS_TABLE           *mBbsTable;
  35
  36 extern VOID                  *mRuntimeSmbiosEntryPoint;
  37 extern EFI_PHYSICAL_ADDRESS  mReserveSmbiosEntryPoint;
  38 extern EFI_PHYSICAL_ADDRESS  mStructureTableAddress;
  39
  40 /**
  41   Print the BBS Table.
  42
  43   @param BbsTable   The BBS table.
  44
  45
  46 **/
  47 VOID
  48 PrintBbsTable (
  49   IN BBS_TABLE *BbsTable
  50   )
  51 {
  52   UINT16 Index;
  53   UINT16 SubIndex;
  54   CHAR8  *String;
  55
  56   DEBUG ((EFI_D_INFO, "\n"));
  57   DEBUG ((EFI_D_INFO, " NO  Prio bb/dd/ff cl/sc Type Stat segm:offs mfgs:mfgo dess:deso\n"));
  58   DEBUG ((EFI_D_INFO, "=================================================================\n"));
  59   for (Index = 0; Index < MAX_BBS_ENTRIES; Index++) {
  60     //
  61     // Filter
  62     //
  63     if (BbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) {
  64       continue;
  65     }
  66
  67     DEBUG ((
  68       EFI_D_INFO,
  69       " %02x: %04x %02x/%02x/%02x %02x/%02x %04x %04x",
  70       (UINTN) Index,
  71       (UINTN) BbsTable[Index].BootPriority,
  72       (UINTN) BbsTable[Index].Bus,
  73       (UINTN) BbsTable[Index].Device,
  74       (UINTN) BbsTable[Index].Function,
  75       (UINTN) BbsTable[Index].Class,
  76       (UINTN) BbsTable[Index].SubClass,
  77       (UINTN) BbsTable[Index].DeviceType,
  78       (UINTN) * (UINT16 *) &BbsTable[Index].StatusFlags
  79       ));
  80     DEBUG ((
  81       EFI_D_INFO,
  82       " %04x:%04x %04x:%04x %04x:%04x",
  83       (UINTN) BbsTable[Index].BootHandlerSegment,
  84       (UINTN) BbsTable[Index].BootHandlerOffset,
  85       (UINTN) BbsTable[Index].MfgStringSegment,
  86       (UINTN) BbsTable[Index].MfgStringOffset,
  87       (UINTN) BbsTable[Index].DescStringSegment,
  88       (UINTN) BbsTable[Index].DescStringOffset
  89       ));
  90
  91     //
  92     // Print DescString
  93     //
  94     String = (CHAR8 *)(((UINTN)BbsTable[Index].DescStringSegment << 4) + BbsTable[Index].DescStringOffset);
  95     if (String != NULL) {
  96       DEBUG ((EFI_D_INFO," ("));
  97       for (SubIndex = 0; String[SubIndex] != 0; SubIndex++) {
  98         DEBUG ((EFI_D_INFO, "%c", String[SubIndex]));
  99       }
 100       DEBUG ((EFI_D_INFO,")"));
 101     }
 102     DEBUG ((EFI_D_INFO,"\n"));
 103   }
 104
 105   DEBUG ((EFI_D_INFO, "\n"));
 106
 107   return ;
 108 }
 109
 110 /**
 111   Print the BBS Table.
 112
 113   @param HddInfo   The HddInfo table.
 114
 115
 116 **/
 117 VOID
 118 PrintHddInfo (
 119   IN HDD_INFO *HddInfo
 120   )
 121 {
 122   UINTN Index;
 123
 124   DEBUG ((EFI_D_INFO, "\n"));
 125   for (Index = 0; Index < MAX_IDE_CONTROLLER; Index++) {
 126     DEBUG ((EFI_D_INFO, "Index - %04x\n", Index));
 127     DEBUG ((EFI_D_INFO, "  Status    - %04x\n", (UINTN)HddInfo[Index].Status));
 128     DEBUG ((EFI_D_INFO, "  B/D/F     - %02x/%02x/%02x\n", (UINTN)HddInfo[Index].Bus, (UINTN)HddInfo[Index].Device, (UINTN)HddInfo[Index].Function));
 129     DEBUG ((EFI_D_INFO, "  Command   - %04x\n", HddInfo[Index].CommandBaseAddress));
 130     DEBUG ((EFI_D_INFO, "  Control   - %04x\n", HddInfo[Index].ControlBaseAddress));
 131     DEBUG ((EFI_D_INFO, "  BusMaster - %04x\n", HddInfo[Index].BusMasterAddress));
 132     DEBUG ((EFI_D_INFO, "  HddIrq    - %02x\n", HddInfo[Index].HddIrq));
 133     DEBUG ((EFI_D_INFO, "  IdentifyDrive[0].Raw[0] - %x\n", HddInfo[Index].IdentifyDrive[0].Raw[0]));
 134     DEBUG ((EFI_D_INFO, "  IdentifyDrive[1].Raw[0] - %x\n", HddInfo[Index].IdentifyDrive[1].Raw[0]));
 135   }
 136
 137   DEBUG ((EFI_D_INFO, "\n"));
 138
 139   return ;
 140 }
 141
 142 /**
 143   Print the PCI Interrupt Line and Interrupt Pin registers.
 144 **/
 145 VOID
 146 PrintPciInterruptRegister (
 147   VOID
 148   )
 149 {
 150   EFI_STATUS                  Status;
 151   UINTN                       Index;
 152   EFI_HANDLE                  *Handles;
 153   UINTN                       HandleNum;
 154   EFI_PCI_IO_PROTOCOL         *PciIo;
 155   UINT8                       Interrupt[2];
 156   UINTN                       Segment;
 157   UINTN                       Bus;
 158   UINTN                       Device;
 159   UINTN                       Function;
 160
 161   gBS->LocateHandleBuffer (
 162          ByProtocol,
 163          &gEfiPciIoProtocolGuid,
 164          NULL,
 165          &HandleNum,
 166          &Handles
 167          );
 168
 169   Bus      = 0;
 170   Device   = 0;
 171   Function = 0;
 172
 173   DEBUG ((EFI_D_INFO, "\n"));
 174   DEBUG ((EFI_D_INFO, " bb/dd/ff interrupt line interrupt pin\n"));
 175   DEBUG ((EFI_D_INFO, "======================================\n"));
 176   for (Index = 0; Index < HandleNum; Index++) {
 177     Status = gBS->HandleProtocol (Handles[Index], &gEfiPciIoProtocolGuid, (VOID **) &PciIo);
 178     if (!EFI_ERROR (Status)) {
 179       Status = PciIo->Pci.Read (
 180                             PciIo,
 181                             EfiPciIoWidthUint8,
 182                             PCI_INT_LINE_OFFSET,
 183                             2,
 184                             Interrupt
 185                             );
 186     }
 187     if (!EFI_ERROR (Status)) {
 188       Status = PciIo->GetLocation (
 189                         PciIo,
 190                         &Segment,
 191                         &Bus,
 192                         &Device,
 193                         &Function
 194                         );
 195     }
 196     if (!EFI_ERROR (Status)) {
 197       DEBUG ((EFI_D_INFO, " %02x/%02x/%02x 0x%02x           0x%02x\n",
 198               Bus, Device, Function, Interrupt[0], Interrupt[1]));
 199     }
 200   }
 201   DEBUG ((EFI_D_INFO, "\n"));
 202
 203   if (Handles != NULL) {
 204     FreePool (Handles);
 205   }
 206 }
 207
 208 /**
 209   Identify drive data must be updated to actual parameters before boot.
 210
 211   @param  IdentifyDriveData       ATA Identify Data
 212
 213 **/
 214 VOID
 215 UpdateIdentifyDriveData (
 216   IN  UINT8     *IdentifyDriveData
 217   );
 218
 219 /**
 220   Update SIO data.
 221
 222   @param  Private                 Legacy BIOS Instance data
 223
 224   @retval EFI_SUCCESS             Removable media not present
 225
 226 **/
 227 EFI_STATUS
 228 UpdateSioData (
 229   IN  LEGACY_BIOS_INSTANCE      *Private
 230   )
 231 {
 232   EFI_STATUS                          Status;
 233   UINTN                               Index;
 234   UINTN                               Index1;
 235   UINT8                               LegacyInterrupts[16];
 236   EFI_LEGACY_IRQ_ROUTING_ENTRY        *RoutingTable;
 237   UINTN                               RoutingTableEntries;
 238   EFI_LEGACY_IRQ_PRIORITY_TABLE_ENTRY *IrqPriorityTable;
 239   UINTN                               NumberPriorityEntries;
 240   EFI_TO_COMPATIBILITY16_BOOT_TABLE   *EfiToLegacy16BootTable;
 241   UINT8                               HddIrq;
 242   UINT16                              LegacyInt;
 243   UINT16                              LegMask;
 244   UINT32                              Register;
 245   UINTN                               HandleCount;
 246   EFI_HANDLE                          *HandleBuffer;
 247   EFI_ISA_IO_PROTOCOL                 *IsaIo;
 248
 249   LegacyInt               = 0;
 250   HandleBuffer            = NULL;
 251
 252   EfiToLegacy16BootTable  = &Private->IntThunk->EfiToLegacy16BootTable;
 253   LegacyBiosBuildSioData (Private);
 254   SetMem (LegacyInterrupts, sizeof (LegacyInterrupts), 0);
 255
 256   //
 257   // Create list of legacy interrupts.
 258   //
 259   for (Index = 0; Index < 4; Index++) {
 260     LegacyInterrupts[Index] = EfiToLegacy16BootTable->SioData.Serial[Index].Irq;
 261   }
 262
 263   for (Index = 4; Index < 7; Index++) {
 264     LegacyInterrupts[Index] = EfiToLegacy16BootTable->SioData.Parallel[Index - 4].Irq;
 265   }
 266
 267   LegacyInterrupts[7] = EfiToLegacy16BootTable->SioData.Floppy.Irq;
 268
 269   //
 270   // Get Legacy Hdd IRQs. If native mode treat as PCI
 271   //
 272   for (Index = 0; Index < 2; Index++) {
 273     HddIrq = EfiToLegacy16BootTable->HddInfo[Index].HddIrq;
 274     if ((HddIrq != 0) && ((HddIrq == 15) || (HddIrq == 14))) {
 275       LegacyInterrupts[Index + 8] = HddIrq;
 276     }
 277   }
 278
 279   Private->LegacyBiosPlatform->GetRoutingTable (
 280                                 Private->LegacyBiosPlatform,
 281                                 (VOID *) &RoutingTable,
 282                                 &RoutingTableEntries,
 283                                 NULL,
 284                                 NULL,
 285                                 (VOID **) &IrqPriorityTable,
 286                                 &NumberPriorityEntries
 287                                 );
 288   //
 289   // Remove legacy interrupts from the list of PCI interrupts available.
 290   //
 291   for (Index = 0; Index <= 0x0b; Index++) {
 292     for (Index1 = 0; Index1 <= NumberPriorityEntries; Index1++) {
 293       if (LegacyInterrupts[Index] != 0) {
 294         LegacyInt = (UINT16) (LegacyInt | (1 << LegacyInterrupts[Index]));
 295         if (LegacyInterrupts[Index] == IrqPriorityTable[Index1].Irq) {
 296           IrqPriorityTable[Index1].Used = LEGACY_USED;
 297         }
 298       }
 299     }
 300   }
 301
 302   Private->Legacy8259->GetMask (
 303                         Private->Legacy8259,
 304                         &LegMask,
 305                         NULL,
 306                         NULL,
 307                         NULL
 308                         );
 309
 310   //
 311   // Set SIO interrupts and disable mouse. Let mouse driver
 312   // re-enable it.
 313   //
 314   LegMask = (UINT16) ((LegMask &~LegacyInt) | 0x1000);
 315   Private->Legacy8259->SetMask (
 316                         Private->Legacy8259,
 317                         &LegMask,
 318                         NULL,
 319                         NULL,
 320                         NULL
 321                         );
 322
 323   //
 324   // Disable mouse in keyboard controller
 325   //
 326   Register = 0xA7;
 327   Status = gBS->LocateHandleBuffer (
 328                   ByProtocol,
 329                   &gEfiIsaIoProtocolGuid,
 330                   NULL,
 331                   &HandleCount,
 332                   &HandleBuffer
 333                   );
 334   if (EFI_ERROR (Status)) {
 335     return Status;
 336   }
 337
 338   for (Index = 0; Index < HandleCount; Index++) {
 339     Status = gBS->HandleProtocol (
 340                     HandleBuffer[Index],
 341                     &gEfiIsaIoProtocolGuid,
 342                     (VOID **) &IsaIo
 343                     );
 344     ASSERT_EFI_ERROR (Status);
 345     IsaIo->Io.Write (IsaIo, EfiIsaIoWidthUint8, 0x64, 1, &Register);
 346
 347   }
 348
 349   if (HandleBuffer != NULL) {
 350     FreePool (HandleBuffer);
 351   }
 352
 353   return EFI_SUCCESS;
 354
 355 }
 356
 357 /**
 358   Identify drive data must be updated to actual parameters before boot.
 359   This requires updating the checksum, if it exists.
 360
 361   @param  IdentifyDriveData       ATA Identify Data
 362   @param  Checksum                checksum of the ATA Identify Data
 363
 364   @retval EFI_SUCCESS             checksum calculated
 365   @retval EFI_SECURITY_VIOLATION  IdentifyData invalid
 366
 367 **/
 368 EFI_STATUS
 369 CalculateIdentifyDriveChecksum (
 370   IN  UINT8     *IdentifyDriveData,
 371   OUT UINT8     *Checksum
 372   )
 373 {
 374   UINTN Index;
 375   UINT8 LocalChecksum;
 376   LocalChecksum = 0;
 377   *Checksum     = 0;
 378   if (IdentifyDriveData[510] != 0xA5) {
 379     return EFI_SECURITY_VIOLATION;
 380   }
 381
 382   for (Index = 0; Index < 512; Index++) {
 383     LocalChecksum = (UINT8) (LocalChecksum + IdentifyDriveData[Index]);
 384   }
 385
 386   *Checksum = LocalChecksum;
 387   return EFI_SUCCESS;
 388 }
 389
 390
 391 /**
 392   Identify drive data must be updated to actual parameters before boot.
 393
 394   @param  IdentifyDriveData       ATA Identify Data
 395
 396
 397 **/
 398 VOID
 399 UpdateIdentifyDriveData (
 400   IN  UINT8     *IdentifyDriveData
 401   )
 402 {
 403   UINT16          NumberCylinders;
 404   UINT16          NumberHeads;
 405   UINT16          NumberSectorsTrack;
 406   UINT32          CapacityInSectors;
 407   UINT8           OriginalChecksum;
 408   UINT8           FinalChecksum;
 409   EFI_STATUS      Status;
 410   ATAPI_IDENTIFY  *ReadInfo;
 411
 412   //
 413   // Status indicates if Integrity byte is correct. Checksum should be
 414   // 0 if valid.
 415   //
 416   ReadInfo  = (ATAPI_IDENTIFY *) IdentifyDriveData;
 417   Status    = CalculateIdentifyDriveChecksum (IdentifyDriveData, &OriginalChecksum);
 418   if (OriginalChecksum != 0) {
 419     Status = EFI_SECURITY_VIOLATION;
 420   }
 421   //
 422   // If NumberCylinders = 0 then do data(Controller present but don drive attached).
 423   //
 424   NumberCylinders = ReadInfo->Raw[1];
 425   if (NumberCylinders != 0) {
 426     ReadInfo->Raw[54]   = NumberCylinders;
 427
 428     NumberHeads         = ReadInfo->Raw[3];
 429     ReadInfo->Raw[55]   = NumberHeads;
 430
 431     NumberSectorsTrack  = ReadInfo->Raw[6];
 432     ReadInfo->Raw[56]   = NumberSectorsTrack;
 433
 434     //
 435     // Copy Multisector info and set valid bit.
 436     //
 437     ReadInfo->Raw[59] = (UINT16) (ReadInfo->Raw[47] + 0x100);
 438     CapacityInSectors = (UINT32) ((UINT32) (NumberCylinders) * (UINT32) (NumberHeads) * (UINT32) (NumberSectorsTrack));
 439     ReadInfo->Raw[57] = (UINT16) (CapacityInSectors >> 16);
 440     ReadInfo->Raw[58] = (UINT16) (CapacityInSectors & 0xffff);
 441     if (Status == EFI_SUCCESS) {
 442       //
 443       // Forece checksum byte to 0 and get new checksum.
 444       //
 445       ReadInfo->Raw[255] &= 0xff;
 446       CalculateIdentifyDriveChecksum (IdentifyDriveData, &FinalChecksum);
 447
 448       //
 449       // Force new checksum such that sum is 0.
 450       //
 451       FinalChecksum = (UINT8) ((UINT8)0 - FinalChecksum);
 452       ReadInfo->Raw[255] = (UINT16) (ReadInfo->Raw[255] | (FinalChecksum << 8));
 453     }
 454   }
 455 }
 456
 457 /**
 458   Identify drive data must be updated to actual parameters before boot.
 459   Do for all drives.
 460
 461   @param  Private                 Legacy BIOS Instance data
 462
 463
 464 **/
 465 VOID
 466 UpdateAllIdentifyDriveData (
 467   IN LEGACY_BIOS_INSTANCE                 *Private
 468   )
 469 {
 470   UINTN     Index;
 471   HDD_INFO  *HddInfo;
 472
 473   HddInfo = &Private->IntThunk->EfiToLegacy16BootTable.HddInfo[0];
 474
 475   for (Index = 0; Index < MAX_IDE_CONTROLLER; Index++) {
 476     //
 477     // Each controller can have 2 devices. Update for each device
 478     //
 479     if ((HddInfo[Index].Status & HDD_MASTER_IDE) != 0) {
 480       UpdateIdentifyDriveData ((UINT8 *) (&HddInfo[Index].IdentifyDrive[0].Raw[0]));
 481     }
 482
 483     if ((HddInfo[Index].Status & HDD_SLAVE_IDE) != 0) {
 484       UpdateIdentifyDriveData ((UINT8 *) (&HddInfo[Index].IdentifyDrive[1].Raw[0]));
 485     }
 486   }
 487 }
 488
 489 /**
 490   Enable ide controller.  This gets disabled when LegacyBoot.c is about
 491   to run the Option ROMs.
 492
 493   @param  Private        Legacy BIOS Instance data
 494
 495
 496 **/
 497 VOID
 498 EnableIdeController (
 499   IN LEGACY_BIOS_INSTANCE              *Private
 500   )
 501 {
 502   EFI_PCI_IO_PROTOCOL *PciIo;
 503   EFI_STATUS          Status;
 504   EFI_HANDLE          IdeController;
 505   UINT8               ByteBuffer;
 506   UINTN               HandleCount;
 507   EFI_HANDLE          *HandleBuffer;
 508
 509   Status = Private->LegacyBiosPlatform->GetPlatformHandle (
 510                                           Private->LegacyBiosPlatform,
 511                                           EfiGetPlatformIdeHandle,
 512                                           0,
 513                                           &HandleBuffer,
 514                                           &HandleCount,
 515                                           NULL
 516                                           );
 517   if (!EFI_ERROR (Status)) {
 518     IdeController = HandleBuffer[0];
 519     Status = gBS->HandleProtocol (
 520                     IdeController,
 521                     &gEfiPciIoProtocolGuid,
 522                     (VOID **) &PciIo
 523                     );
 524     ByteBuffer = 0x1f;
 525     if (!EFI_ERROR (Status)) {
 526       PciIo->Pci.Write (PciIo, EfiPciIoWidthUint8, 0x04, 1, &ByteBuffer);
 527     }
 528   }
 529 }
 530
 531
 532 /**
 533   Enable ide controller.  This gets disabled when LegacyBoot.c is about
 534   to run the Option ROMs.
 535
 536   @param  Private                 Legacy BIOS Instance data
 537
 538
 539 **/
 540 VOID
 541 EnableAllControllers (
 542   IN LEGACY_BIOS_INSTANCE              *Private
 543   )
 544 {
 545   UINTN               HandleCount;
 546   EFI_HANDLE          *HandleBuffer;
 547   UINTN               Index;
 548   EFI_PCI_IO_PROTOCOL *PciIo;
 549   PCI_TYPE01          PciConfigHeader;
 550   EFI_STATUS          Status;
 551
 552   //
 553   //
 554   //
 555   EnableIdeController (Private);
 556
 557   //
 558   // Assumption is table is built from low bus to high bus numbers.
 559   //
 560   Status = gBS->LocateHandleBuffer (
 561                   ByProtocol,
 562                   &gEfiPciIoProtocolGuid,
 563                   NULL,
 564                   &HandleCount,
 565                   &HandleBuffer
 566                   );
 567   ASSERT_EFI_ERROR (Status);
 568
 569   for (Index = 0; Index < HandleCount; Index++) {
 570     Status = gBS->HandleProtocol (
 571                     HandleBuffer[Index],
 572                     &gEfiPciIoProtocolGuid,
 573                     (VOID **) &PciIo
 574                     );
 575     ASSERT_EFI_ERROR (Status);
 576
 577     PciIo->Pci.Read (
 578                 PciIo,
 579                 EfiPciIoWidthUint32,
 580                 0,
 581                 sizeof (PciConfigHeader) / sizeof (UINT32),
 582                 &PciConfigHeader
 583                 );
 584
 585     //
 586     // We do not enable PPB here. This is for HotPlug Consideration.
 587     // The Platform HotPlug Driver is responsible for Padding enough hot plug
 588     // resources. It is also responsible for enable this bridge. If it
 589     // does not pad it. It will cause some early Windows fail to installation.
 590     // If the platform driver does not pad resource for PPB, PPB should be in
 591     // un-enabled state to let Windows know that this PPB is not configured by
 592     // BIOS. So Windows will allocate default resource for PPB.
 593     //
 594     // The reason for why we enable the command register is:
 595     // The CSM will use the IO bar to detect some IRQ status, if the command
 596     // is disabled, the IO resource will be out of scope.
 597     // For example:
 598     // We installed a legacy IRQ handle for a PCI IDE controller. When IRQ
 599     // comes up, the handle will check the IO space to identify is the
 600     // controller generated the IRQ source.
 601     // If the IO command is not enabled, the IRQ handler will has wrong
 602     // information. It will cause IRQ storm when the correctly IRQ handler fails
 603     // to run.
 604     //
 605     if (!(IS_PCI_VGA (&PciConfigHeader)     ||
 606           IS_PCI_OLD_VGA (&PciConfigHeader) ||
 607           IS_PCI_IDE (&PciConfigHeader)     ||
 608           IS_PCI_P2P (&PciConfigHeader)     ||
 609           IS_PCI_P2P_SUB (&PciConfigHeader) ||
 610           IS_PCI_LPC (&PciConfigHeader)     )) {
 611
 612       PciConfigHeader.Hdr.Command |= 0x1f;
 613
 614       PciIo->Pci.Write (PciIo, EfiPciIoWidthUint32, 4, 1, &PciConfigHeader.Hdr.Command);
 615     }
 616   }
 617 }
 618
 619 /**
 620   The following routines are identical in operation, so combine
 621   for code compaction:
 622   EfiGetPlatformBinaryGetMpTable
 623   EfiGetPlatformBinaryGetOemIntData
 624   EfiGetPlatformBinaryGetOem32Data
 625   EfiGetPlatformBinaryGetOem16Data
 626
 627   @param  This                    Protocol instance pointer.
 628   @param  Id                      Table/Data identifier
 629
 630   @retval EFI_SUCCESS             Success
 631   @retval EFI_INVALID_PARAMETER   Invalid ID
 632   @retval EFI_OUT_OF_RESOURCES    no resource to get data or table
 633
 634 **/
 635 EFI_STATUS
 636 LegacyGetDataOrTable (
 637   IN EFI_LEGACY_BIOS_PROTOCOL         *This,
 638   IN EFI_GET_PLATFORM_INFO_MODE       Id
 639   )
 640 {
 641   VOID                              *Table;
 642   UINT32                            TablePtr;
 643   UINTN                             TableSize;
 644   UINTN                             Alignment;
 645   UINTN                             Location;
 646   EFI_STATUS                        Status;
 647   EFI_LEGACY_BIOS_PLATFORM_PROTOCOL *LegacyBiosPlatform;
 648   EFI_COMPATIBILITY16_TABLE         *Legacy16Table;
 649   EFI_IA32_REGISTER_SET             Regs;
 650   LEGACY_BIOS_INSTANCE              *Private;
 651
 652   Private             = LEGACY_BIOS_INSTANCE_FROM_THIS (This);
 653
 654   LegacyBiosPlatform  = Private->LegacyBiosPlatform;
 655   Legacy16Table       = Private->Legacy16Table;
 656
 657   //
 658   // Phase 1 - get an address allocated in 16-bit code
 659   //
 660   while (TRUE) {
 661     switch (Id) {
 662     case EfiGetPlatformBinaryMpTable:
 663     case EfiGetPlatformBinaryOemIntData:
 664     case EfiGetPlatformBinaryOem32Data:
 665     case EfiGetPlatformBinaryOem16Data:
 666       {
 667         Status = LegacyBiosPlatform->GetPlatformInfo (
 668                                       LegacyBiosPlatform,
 669                                       Id,
 670                                       (VOID *) &Table,
 671                                       &TableSize,
 672                                       &Location,
 673                                       &Alignment,
 674                                       0,
 675                                       0
 676                                       );
 677         DEBUG ((EFI_D_INFO, "LegacyGetDataOrTable - ID: %x, %r\n", (UINTN)Id, Status));
 678         DEBUG ((EFI_D_INFO, "  Table - %x, Size - %x, Location - %x, Alignment - %x\n", (UINTN)Table, (UINTN)TableSize, (UINTN)Location, (UINTN)Alignment));
 679         break;
 680       }
 681
 682     default:
 683       {
 684         return EFI_INVALID_PARAMETER;
 685       }
 686     }
 687
 688     if (EFI_ERROR (Status)) {
 689       return Status;
 690     }
 691
 692     ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
 693     Regs.X.AX = Legacy16GetTableAddress;
 694     Regs.X.CX = (UINT16) TableSize;
 695     Regs.X.BX = (UINT16) Location;
 696     Regs.X.DX = (UINT16) Alignment;
 697     Private->LegacyBios.FarCall86 (
 698       This,
 699       Private->Legacy16CallSegment,
 700       Private->Legacy16CallOffset,
 701       &Regs,
 702       NULL,
 703       0
 704       );
 705
 706     if (Regs.X.AX != 0) {
 707       DEBUG ((EFI_D_ERROR, "Table ID %x length insufficient\n", Id));
 708       return EFI_OUT_OF_RESOURCES;
 709     } else {
 710       break;
 711     }
 712   }
 713   //
 714   // Phase 2 Call routine second time with address to allow address adjustment
 715   //
 716   Status = LegacyBiosPlatform->GetPlatformInfo (
 717                                 LegacyBiosPlatform,
 718                                 Id,
 719                                 (VOID *) &Table,
 720                                 &TableSize,
 721                                 &Location,
 722                                 &Alignment,
 723                                 Regs.X.DS,
 724                                 Regs.X.BX
 725                                 );
 726   switch (Id) {
 727   case EfiGetPlatformBinaryMpTable:
 728     {
 729       Legacy16Table->MpTablePtr     = (UINT32) (Regs.X.DS * 16 + Regs.X.BX);
 730       Legacy16Table->MpTableLength  = (UINT32)TableSize;
 731       DEBUG ((EFI_D_INFO, "MP table in legacy region - %x\n", (UINTN)Legacy16Table->MpTablePtr));
 732       break;
 733     }
 734
 735   case EfiGetPlatformBinaryOemIntData:
 736     {
 737
 738       Legacy16Table->OemIntSegment  = Regs.X.DS;
 739       Legacy16Table->OemIntOffset   = Regs.X.BX;
 740       DEBUG ((EFI_D_INFO, "OemInt table in legacy region - %04x:%04x\n", (UINTN)Legacy16Table->OemIntSegment, (UINTN)Legacy16Table->OemIntOffset));
 741       break;
 742     }
 743
 744   case EfiGetPlatformBinaryOem32Data:
 745     {
 746       Legacy16Table->Oem32Segment = Regs.X.DS;
 747       Legacy16Table->Oem32Offset  = Regs.X.BX;
 748       DEBUG ((EFI_D_INFO, "Oem32 table in legacy region - %04x:%04x\n", (UINTN)Legacy16Table->Oem32Segment, (UINTN)Legacy16Table->Oem32Offset));
 749       break;
 750     }
 751
 752   case EfiGetPlatformBinaryOem16Data:
 753     {
 754       //
 755       //          Legacy16Table->Oem16Segment = Regs.X.DS;
 756       //          Legacy16Table->Oem16Offset  = Regs.X.BX;
 757       DEBUG ((EFI_D_INFO, "Oem16 table in legacy region - %04x:%04x\n", (UINTN)Legacy16Table->Oem16Segment, (UINTN)Legacy16Table->Oem16Offset));
 758       break;
 759     }
 760
 761   default:
 762     {
 763       return EFI_INVALID_PARAMETER;
 764     }
 765   }
 766
 767   if (EFI_ERROR (Status)) {
 768     return Status;
 769   }
 770   //
 771   // Phase 3 Copy table to final location
 772   //
 773   TablePtr = (UINT32) (Regs.X.DS * 16 + Regs.X.BX);
 774
 775   CopyMem (
 776     (VOID *) (UINTN)TablePtr,
 777     Table,
 778     TableSize
 779     );
 780
 781   return EFI_SUCCESS;
 782 }
 783
 784 /**
 785   Copy SMBIOS table to EfiReservedMemoryType of memory for legacy boot.
 786
 787 **/
 788 VOID
 789 CreateSmbiosTableInReservedMemory (
 790   VOID
 791   )
 792 {
 793   SMBIOS_TABLE_ENTRY_POINT    *EntryPointStructure;
 794
 795   if ((mRuntimeSmbiosEntryPoint == NULL) ||
 796       (mReserveSmbiosEntryPoint == 0) ||
 797       (mStructureTableAddress == 0)) {
 798     return;
 799   }
 800
 801   EntryPointStructure = (SMBIOS_TABLE_ENTRY_POINT *) mRuntimeSmbiosEntryPoint;
 802
 803   //
 804   // Copy SMBIOS Entry Point Structure
 805   //
 806   CopyMem (
 807     (VOID *)(UINTN) mReserveSmbiosEntryPoint,
 808     EntryPointStructure,
 809     EntryPointStructure->EntryPointLength
 810   );
 811
 812   //
 813   // Copy SMBIOS Structure Table into EfiReservedMemoryType memory
 814   //
 815   CopyMem (
 816     (VOID *)(UINTN) mStructureTableAddress,
 817     (VOID *)(UINTN) EntryPointStructure->TableAddress,
 818     EntryPointStructure->TableLength
 819   );
 820
 821   //
 822   // Update TableAddress in Entry Point Structure
 823   //
 824   EntryPointStructure = (SMBIOS_TABLE_ENTRY_POINT *)(UINTN) mReserveSmbiosEntryPoint;
 825   EntryPointStructure->TableAddress = (UINT32)(UINTN) mStructureTableAddress;
 826
 827   //
 828   // Fixup checksums in the Entry Point Structure
 829   //
 830   EntryPointStructure->IntermediateChecksum = 0;
 831   EntryPointStructure->EntryPointStructureChecksum = 0;
 832
 833   EntryPointStructure->IntermediateChecksum =
 834     CalculateCheckSum8 (
 835       (UINT8 *) EntryPointStructure + OFFSET_OF (SMBIOS_TABLE_ENTRY_POINT, IntermediateAnchorString),
 836       EntryPointStructure->EntryPointLength - OFFSET_OF (SMBIOS_TABLE_ENTRY_POINT, IntermediateAnchorString)
 837       );
 838   EntryPointStructure->EntryPointStructureChecksum =
 839     CalculateCheckSum8 ((UINT8 *) EntryPointStructure, EntryPointStructure->EntryPointLength);
 840 }
 841
 842 /**
 843   Assign drive number to legacy HDD drives prior to booting an EFI
 844   aware OS so the OS can access drives without an EFI driver.
 845   Note: BBS compliant drives ARE NOT available until this call by
 846   either shell or EFI.
 847
 848   @param  This                    Protocol instance pointer.
 849
 850   @retval EFI_SUCCESS             Drive numbers assigned
 851
 852 **/
 853 EFI_STATUS
 854 GenericLegacyBoot (
 855   IN EFI_LEGACY_BIOS_PROTOCOL           *This
 856   )
 857 {
 858   EFI_STATUS                        Status;
 859   LEGACY_BIOS_INSTANCE              *Private;
 860   EFI_IA32_REGISTER_SET             Regs;
 861   EFI_TO_COMPATIBILITY16_BOOT_TABLE *EfiToLegacy16BootTable;
 862   EFI_LEGACY_BIOS_PLATFORM_PROTOCOL *LegacyBiosPlatform;
 863   UINTN                             CopySize;
 864   VOID                              *AcpiPtr;
 865   HDD_INFO                          *HddInfo;
 866   HDD_INFO                          *LocalHddInfo;
 867   UINTN                             Index;
 868   EFI_COMPATIBILITY16_TABLE         *Legacy16Table;
 869   UINT32                            *BdaPtr;
 870   UINT16                            HddCount;
 871   UINT16                            BbsCount;
 872   BBS_TABLE                         *LocalBbsTable;
 873   UINT32                            *BaseVectorMaster;
 874   EFI_TIME                          BootTime;
 875   UINT32                            LocalTime;
 876   EFI_HANDLE                        IdeController;
 877   UINTN                             HandleCount;
 878   EFI_HANDLE                        *HandleBuffer;
 879   VOID                              *AcpiTable;
 880   UINTN                             ShadowAddress;
 881   UINT32                            Granularity;
 882
 883   LocalHddInfo  = NULL;
 884   HddCount      = 0;
 885   BbsCount      = 0;
 886   LocalBbsTable = NULL;
 887
 888   Private       = LEGACY_BIOS_INSTANCE_FROM_THIS (This);
 889   DEBUG_CODE (
 890     DEBUG ((EFI_D_ERROR, "Start of legacy boot\n"));
 891   );
 892
 893   Legacy16Table                         = Private->Legacy16Table;
 894   EfiToLegacy16BootTable                = &Private->IntThunk->EfiToLegacy16BootTable;
 895   HddInfo = &EfiToLegacy16BootTable->HddInfo[0];
 896
 897   LegacyBiosPlatform = Private->LegacyBiosPlatform;
 898
 899   EfiToLegacy16BootTable->MajorVersion = EFI_TO_LEGACY_MAJOR_VERSION;
 900   EfiToLegacy16BootTable->MinorVersion = EFI_TO_LEGACY_MINOR_VERSION;
 901
 902   //
 903   // If booting to a legacy OS then force HDD drives to the appropriate
 904   // boot mode by calling GetIdeHandle.
 905   // A reconnect -r can force all HDDs back to native mode.
 906   //
 907   IdeController = NULL;
 908   if ((mBootMode == BOOT_LEGACY_OS) || (mBootMode == BOOT_UNCONVENTIONAL_DEVICE)) {
 909     Status = LegacyBiosPlatform->GetPlatformHandle (
 910                                   Private->LegacyBiosPlatform,
 911                                   EfiGetPlatformIdeHandle,
 912                                   0,
 913                                   &HandleBuffer,
 914                                   &HandleCount,
 915                                   NULL
 916                                   );
 917     if (!EFI_ERROR (Status)) {
 918       IdeController = HandleBuffer[0];
 919     }
 920   }
 921   //
 922   // Unlock the Legacy BIOS region
 923   //
 924   Private->LegacyRegion->UnLock (
 925                            Private->LegacyRegion,
 926                            0xE0000,
 927                            0x20000,
 928                            &Granularity
 929                            );
 930
 931   //
 932   // Reconstruct the Legacy16 boot memory map
 933   //
 934   LegacyBiosBuildE820 (Private, &CopySize);
 935   if (CopySize > Private->Legacy16Table->E820Length) {
 936     ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
 937     Regs.X.AX = Legacy16GetTableAddress;
 938     Regs.X.CX = (UINT16) CopySize;
 939     Private->LegacyBios.FarCall86 (
 940       &Private->LegacyBios,
 941       Private->Legacy16Table->Compatibility16CallSegment,
 942       Private->Legacy16Table->Compatibility16CallOffset,
 943       &Regs,
 944       NULL,
 945       0
 946       );
 947
 948     Private->Legacy16Table->E820Pointer = (UINT32) (Regs.X.DS * 16 + Regs.X.BX);
 949     Private->Legacy16Table->E820Length  = (UINT32) CopySize;
 950     if (Regs.X.AX != 0) {
 951       DEBUG ((EFI_D_ERROR, "Legacy16 E820 length insufficient\n"));
 952     } else {
 953       CopyMem (
 954         (VOID *)(UINTN) Private->Legacy16Table->E820Pointer,
 955         Private->E820Table,
 956         CopySize
 957         );
 958     }
 959   } else {
 960     CopyMem (
 961       (VOID *)(UINTN) Private->Legacy16Table->E820Pointer,
 962       Private->E820Table,
 963       CopySize
 964       );
 965     Private->Legacy16Table->E820Length = (UINT32) CopySize;
 966   }
 967
 968   //
 969   // We do not ASSERT if SmbiosTable not found. It is possbile that a platform does not produce SmbiosTable.
 970   //
 971   if (mReserveSmbiosEntryPoint == 0) {
 972     DEBUG ((EFI_D_INFO, "Smbios table is not found!\n"));
 973   }
 974   CreateSmbiosTableInReservedMemory ();
 975   EfiToLegacy16BootTable->SmbiosTable = (UINT32)(UINTN)mReserveSmbiosEntryPoint;
 976
 977   AcpiTable = NULL;
 978   Status = EfiGetSystemConfigurationTable (
 979              &gEfiAcpi20TableGuid,
 980              &AcpiTable
 981              );
 982   if (EFI_ERROR (Status)) {
 983     Status = EfiGetSystemConfigurationTable (
 984                &gEfiAcpi10TableGuid,
 985                &AcpiTable
 986                );
 987   }
 988   //
 989   // We do not ASSERT if AcpiTable not found. It is possbile that a platform does not produce AcpiTable.
 990   //
 991   if (AcpiTable == NULL) {
 992     DEBUG ((EFI_D_INFO, "ACPI table is not found!\n"));
 993   }
 994   EfiToLegacy16BootTable->AcpiTable = (UINT32)(UINTN)AcpiTable;
 995
 996   //
 997   // Get RSD Ptr table rev at offset 15 decimal
 998   // Rev = 0 Length is 20 decimal
 999   // Rev != 0 Length is UINT32 at offset 20 decimal
1000   //
1001   if (AcpiTable != NULL) {
1002
1003     AcpiPtr = AcpiTable;
1004     if (*((UINT8 *) AcpiPtr + 15) == 0) {
1005       CopySize = 20;
1006     } else {
1007       AcpiPtr   = ((UINT8 *) AcpiPtr + 20);
1008       CopySize  = (*(UINT32 *) AcpiPtr);
1009     }
1010
1011     CopyMem (
1012       (VOID *)(UINTN) Private->Legacy16Table->AcpiRsdPtrPointer,
1013       AcpiTable,
1014       CopySize
1015       );
1016   }
1017   //
1018   // Make sure all PCI Interrupt Line register are programmed to match 8259
1019   //
1020   PciProgramAllInterruptLineRegisters (Private);
1021
1022   //
1023   // Unlock the Legacy BIOS region as PciProgramAllInterruptLineRegisters
1024   // can lock it.
1025   //
1026   Private->LegacyRegion->UnLock (
1027                            Private->LegacyRegion,
1028                            Private->BiosStart,
1029                            Private->LegacyBiosImageSize,
1030                            &Granularity
1031                            );
1032
1033   //
1034   // Configure Legacy Device Magic
1035   //
1036   // Only do this code if booting legacy OS
1037   //
1038   if ((mBootMode == BOOT_LEGACY_OS) || (mBootMode == BOOT_UNCONVENTIONAL_DEVICE)) {
1039     UpdateSioData (Private);
1040   }
1041   //
1042   // Setup BDA and EBDA standard areas before Legacy Boot
1043   //
1044   ACCESS_PAGE0_CODE (
1045     LegacyBiosCompleteBdaBeforeBoot (Private);
1046   );
1047   LegacyBiosCompleteStandardCmosBeforeBoot (Private);
1048
1049   //
1050   // We must build IDE data, if it hasn't been done, before PciShadowRoms
1051   // to insure EFI drivers are connected.
1052   //
1053   LegacyBiosBuildIdeData (Private, &HddInfo, 1);
1054   UpdateAllIdentifyDriveData (Private);
1055
1056   //
1057   // Clear IO BAR, if IDE controller in legacy mode.
1058   //
1059   InitLegacyIdeController (IdeController);
1060
1061   //
1062   // Generate number of ticks since midnight for BDA. DOS requires this
1063   // for its time. We have to make assumptions as to how long following
1064   // code takes since after PciShadowRoms PciIo is gone. Place result in
1065   // 40:6C-6F
1066   //
1067   // Adjust value by 1 second.
1068   //
1069   gRT->GetTime (&BootTime, NULL);
1070   LocalTime = BootTime.Hour * 3600 + BootTime.Minute * 60 + BootTime.Second;
1071   LocalTime += 1;
1072
1073   //
1074   // Multiply result by 18.2 for number of ticks since midnight.
1075   // Use 182/10 to avoid floating point math.
1076   //
1077   LocalTime = (LocalTime * 182) / 10;
1078   ACCESS_PAGE0_CODE (
1079     BdaPtr    = (UINT32 *) (UINTN)0x46C;
1080     *BdaPtr   = LocalTime;
1081   );
1082
1083   //
1084   // Shadow PCI ROMs. We must do this near the end since this will kick
1085   // of Native EFI drivers that may be needed to collect info for Legacy16
1086   //
1087   //  WARNING: PciIo is gone after this call.
1088   //
1089   PciShadowRoms (Private);
1090
1091   //
1092   // Shadow PXE base code, BIS etc.
1093   //
1094   Private->LegacyRegion->UnLock (Private->LegacyRegion, 0xc0000, 0x40000, &Granularity);
1095   ShadowAddress = Private->OptionRom;
1096   Private->LegacyBiosPlatform->PlatformHooks (
1097                                  Private->LegacyBiosPlatform,
1098                                  EfiPlatformHookShadowServiceRoms,
1099                                  0,
1100                                  0,
1101                                  &ShadowAddress,
1102                                  Legacy16Table,
1103                                  NULL
1104                                  );
1105   Private->OptionRom = (UINT32)ShadowAddress;
1106   //
1107   // Register Legacy SMI Handler
1108   //
1109   LegacyBiosPlatform->SmmInit (
1110                         LegacyBiosPlatform,
1111                         EfiToLegacy16BootTable
1112                         );
1113
1114   //
1115   // Let platform code know the boot options
1116   //
1117   LegacyBiosGetBbsInfo (
1118     This,
1119     &HddCount,
1120     &LocalHddInfo,
1121     &BbsCount,
1122     &LocalBbsTable
1123     );
1124
1125   DEBUG_CODE (
1126     PrintPciInterruptRegister ();
1127     PrintBbsTable (LocalBbsTable);
1128     PrintHddInfo (LocalHddInfo);
1129     );
1130   //
1131   // If drive wasn't spun up then BuildIdeData may have found new drives.
1132   // Need to update BBS boot priority.
1133   //
1134   for (Index = 0; Index < MAX_IDE_CONTROLLER; Index++) {
1135     if ((LocalHddInfo[Index].IdentifyDrive[0].Raw[0] != 0) &&
1136         (LocalBbsTable[2 * Index + 1].BootPriority == BBS_IGNORE_ENTRY)
1137         ) {
1138       LocalBbsTable[2 * Index + 1].BootPriority = BBS_UNPRIORITIZED_ENTRY;
1139     }
1140
1141     if ((LocalHddInfo[Index].IdentifyDrive[1].Raw[0] != 0) &&
1142         (LocalBbsTable[2 * Index + 2].BootPriority == BBS_IGNORE_ENTRY)
1143         ) {
1144       LocalBbsTable[2 * Index + 2].BootPriority = BBS_UNPRIORITIZED_ENTRY;
1145     }
1146   }
1147
1148   Private->LegacyRegion->UnLock (
1149                            Private->LegacyRegion,
1150                            0xc0000,
1151                            0x40000,
1152                            &Granularity
1153                            );
1154
1155   LegacyBiosPlatform->PrepareToBoot (
1156                         LegacyBiosPlatform,
1157                         mBbsDevicePathPtr,
1158                         mBbsTable,
1159                         mLoadOptionsSize,
1160                         mLoadOptions,
1161                         (VOID *) &Private->IntThunk->EfiToLegacy16BootTable
1162                         );
1163
1164   //
1165   // If no boot device return to BDS
1166   //
1167   if ((mBootMode == BOOT_LEGACY_OS) || (mBootMode == BOOT_UNCONVENTIONAL_DEVICE)) {
1168     for (Index = 0; Index < BbsCount; Index++){
1169       if ((LocalBbsTable[Index].BootPriority != BBS_DO_NOT_BOOT_FROM) &&
1170           (LocalBbsTable[Index].BootPriority != BBS_UNPRIORITIZED_ENTRY) &&
1171           (LocalBbsTable[Index].BootPriority != BBS_IGNORE_ENTRY)) {
1172         break;
1173       }
1174     }
1175     if (Index == BbsCount) {
1176       return EFI_DEVICE_ERROR;
1177     }
1178   }
1179   //
1180   // Let the Legacy16 code know the device path type for legacy boot
1181   //
1182   EfiToLegacy16BootTable->DevicePathType = mBbsDevicePathPtr->DeviceType;
1183
1184   //
1185   // Copy MP table, if it exists.
1186   //
1187   LegacyGetDataOrTable (This, EfiGetPlatformBinaryMpTable);
1188
1189   if (!Private->LegacyBootEntered) {
1190     //
1191     // Copy OEM INT Data, if it exists. Note: This code treats any data
1192     // as a bag of bits and knows nothing of the contents nor cares.
1193     // Contents are IBV specific.
1194     //
1195     LegacyGetDataOrTable (This, EfiGetPlatformBinaryOemIntData);
1196
1197     //
1198     // Copy OEM16 Data, if it exists.Note: This code treats any data
1199     // as a bag of bits and knows nothing of the contents nor cares.
1200     // Contents are IBV specific.
1201     //
1202     LegacyGetDataOrTable (This, EfiGetPlatformBinaryOem16Data);
1203
1204     //
1205     // Copy OEM32 Data, if it exists.Note: This code treats any data
1206     // as a bag of bits and knows nothing of the contents nor cares.
1207     // Contents are IBV specific.
1208     //
1209     LegacyGetDataOrTable (This, EfiGetPlatformBinaryOem32Data);
1210   }
1211
1212   //
1213   // Call into Legacy16 code to prepare for INT 19h
1214   //
1215   ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
1216   Regs.X.AX = Legacy16PrepareToBoot;
1217
1218   //
1219   // Pass in handoff data
1220   //
1221   Regs.X.ES = NORMALIZE_EFI_SEGMENT ((UINTN)EfiToLegacy16BootTable);
1222   Regs.X.BX = NORMALIZE_EFI_OFFSET ((UINTN)EfiToLegacy16BootTable);
1223
1224   Private->LegacyBios.FarCall86 (
1225     This,
1226     Private->Legacy16CallSegment,
1227     Private->Legacy16CallOffset,
1228     &Regs,
1229     NULL,
1230     0
1231     );
1232
1233   if (Regs.X.AX != 0) {
1234     return EFI_DEVICE_ERROR;
1235   }
1236   //
1237   // Lock the Legacy BIOS region
1238   //
1239   Private->LegacyRegion->Lock (
1240                            Private->LegacyRegion,
1241                            0xc0000,
1242                            0x40000,
1243                            &Granularity
1244                            );
1245
1246   if ((Private->Legacy16Table->TableLength >= OFFSET_OF (EFI_COMPATIBILITY16_TABLE, HiPermanentMemoryAddress)) &&
1247       ((Private->Legacy16Table->UmaAddress != 0) && (Private->Legacy16Table->UmaSize != 0))) {
1248     //
1249     // Here we could reduce UmaAddress down as far as Private->OptionRom, taking into
1250     // account the granularity of the access control.
1251     //
1252     DEBUG((EFI_D_INFO, "Unlocking UMB RAM region 0x%x-0x%x\n", Private->Legacy16Table->UmaAddress,
1253                         Private->Legacy16Table->UmaAddress + Private->Legacy16Table->UmaSize));
1254
1255     Private->LegacyRegion->UnLock (
1256                              Private->LegacyRegion,
1257                              Private->Legacy16Table->UmaAddress,
1258                              Private->Legacy16Table->UmaSize,
1259                              &Granularity
1260                              );
1261   }
1262
1263   //
1264   // Lock attributes of the Legacy Region if chipset supports
1265   //
1266   Private->LegacyRegion->BootLock (
1267                            Private->LegacyRegion,
1268                            0xc0000,
1269                            0x40000,
1270                            &Granularity
1271                            );
1272
1273   //
1274   // Call into Legacy16 code to do the INT 19h
1275   //
1276   EnableAllControllers (Private);
1277   if ((mBootMode == BOOT_LEGACY_OS) || (mBootMode == BOOT_UNCONVENTIONAL_DEVICE)) {
1278
1279     //
1280     // Signal all the events that are waiting on EVT_SIGNAL_LEGACY_BOOT
1281     //
1282     EfiSignalEventLegacyBoot ();
1283
1284     //
1285     // Report Status Code to indicate legacy boot event was signalled
1286     //
1287     REPORT_STATUS_CODE (
1288       EFI_PROGRESS_CODE,
1289       (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_PC_LEGACY_BOOT_EVENT)
1290       );
1291
1292     DEBUG ((EFI_D_INFO, "Legacy INT19 Boot...\n"));
1293
1294     //
1295     // Disable DXE Timer while executing in real mode
1296     //
1297     Private->Timer->SetTimerPeriod (Private->Timer, 0);
1298
1299     //
1300     // Save and disable interrupt of debug timer
1301     //
1302     SaveAndSetDebugTimerInterrupt (FALSE);
1303
1304
1305     //
1306     // Put the 8259 into its legacy mode by reprogramming the vector bases
1307     //
1308     Private->Legacy8259->SetVectorBase (Private->Legacy8259, LEGACY_MODE_BASE_VECTOR_MASTER, LEGACY_MODE_BASE_VECTOR_SLAVE);
1309     //
1310     // PC History
1311     //   The original PC used INT8-F for master PIC. Since these mapped over
1312     //   processor exceptions TIANO moved the master PIC to INT68-6F.
1313     // We need to set these back to the Legacy16 unexpected interrupt(saved
1314     // in LegacyBios.c) since some OS see that these have values different from
1315     // what is expected and invoke them. Since the legacy OS corrupts EFI
1316     // memory, there is no handler for these interrupts and OS blows up.
1317     //
1318     // We need to save the TIANO values for the rare case that the Legacy16
1319     // code cannot boot but knows memory hasn't been destroyed.
1320     //
1321     // To compound the problem, video takes over one of these INTS and must be
1322     // be left.
1323     // @bug - determine if video hooks INT(in which case we must find new
1324     //          set of TIANO vectors) or takes it over.
1325     //
1326     //
1327     ACCESS_PAGE0_CODE (
1328       BaseVectorMaster = (UINT32 *) (sizeof (UINT32) * PROTECTED_MODE_BASE_VECTOR_MASTER);
1329       for (Index = 0; Index < 8; Index++) {
1330         Private->ThunkSavedInt[Index] = BaseVectorMaster[Index];
1331         if (Private->ThunkSeg == (UINT16) (BaseVectorMaster[Index] >> 16)) {
1332           BaseVectorMaster[Index] = (UINT32) (Private->BiosUnexpectedInt);
1333         }
1334       }
1335     );
1336
1337     ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
1338     Regs.X.AX = Legacy16Boot;
1339
1340     Private->LegacyBios.FarCall86 (
1341       This,
1342       Private->Legacy16CallSegment,
1343       Private->Legacy16CallOffset,
1344       &Regs,
1345       NULL,
1346       0
1347       );
1348
1349     ACCESS_PAGE0_CODE (
1350       BaseVectorMaster = (UINT32 *) (sizeof (UINT32) * PROTECTED_MODE_BASE_VECTOR_MASTER);
1351       for (Index = 0; Index < 8; Index++) {
1352         BaseVectorMaster[Index] = Private->ThunkSavedInt[Index];
1353       }
1354     );
1355   }
1356   Private->LegacyBootEntered = TRUE;
1357   if ((mBootMode == BOOT_LEGACY_OS) || (mBootMode == BOOT_UNCONVENTIONAL_DEVICE)) {
1358     //
1359     // Should never return unless never passed control to 0:7c00(first stage
1360     // OS loader) and only then if no bootable device found.
1361     //
1362     return EFI_DEVICE_ERROR;
1363   } else {
1364     //
1365     // If boot to EFI then expect to return to caller
1366     //
1367     return EFI_SUCCESS;
1368   }
1369 }
1370
1371
1372 /**
1373   Assign drive number to legacy HDD drives prior to booting an EFI
1374   aware OS so the OS can access drives without an EFI driver.
1375   Note: BBS compliant drives ARE NOT available until this call by
1376   either shell or EFI.
1377
1378   @param  This                    Protocol instance pointer.
1379   @param  BbsCount                Number of BBS_TABLE structures
1380   @param  BbsTable                List BBS entries
1381
1382   @retval EFI_SUCCESS             Drive numbers assigned
1383
1384 **/
1385 EFI_STATUS
1386 EFIAPI
1387 LegacyBiosPrepareToBootEfi (
1388   IN EFI_LEGACY_BIOS_PROTOCOL         *This,
1389   OUT UINT16                          *BbsCount,
1390   OUT BBS_TABLE                       **BbsTable
1391   )
1392 {
1393   EFI_STATUS                        Status;
1394   EFI_TO_COMPATIBILITY16_BOOT_TABLE *EfiToLegacy16BootTable;
1395   LEGACY_BIOS_INSTANCE              *Private;
1396
1397   Private                 = LEGACY_BIOS_INSTANCE_FROM_THIS (This);
1398   EfiToLegacy16BootTable  = &Private->IntThunk->EfiToLegacy16BootTable;
1399   mBootMode               = BOOT_EFI_OS;
1400   mBbsDevicePathPtr       = NULL;
1401   Status                  = GenericLegacyBoot (This);
1402   *BbsTable               = (BBS_TABLE*)(UINTN)EfiToLegacy16BootTable->BbsTable;
1403   *BbsCount               = (UINT16) (sizeof (Private->IntThunk->BbsTable) / sizeof (BBS_TABLE));
1404   return Status;
1405 }
1406
1407 /**
1408   To boot from an unconventional device like parties and/or execute HDD diagnostics.
1409
1410   @param  This            Protocol instance pointer.
1411   @param  Attributes      How to interpret the other input parameters
1412   @param  BbsEntry        The 0-based index into the BbsTable for the parent
1413                           device.
1414   @param  BeerData        Pointer to the 128 bytes of ram BEER data.
1415   @param  ServiceAreaData Pointer to the 64 bytes of raw Service Area data. The
1416                           caller must provide a pointer to the specific Service
1417                           Area and not the start all Service Areas.
1418
1419   @retval EFI_INVALID_PARAMETER if error. Does NOT return if no error.
1420
1421 ***/
1422 EFI_STATUS
1423 EFIAPI
1424 LegacyBiosBootUnconventionalDevice (
1425   IN EFI_LEGACY_BIOS_PROTOCOL         *This,
1426   IN UDC_ATTRIBUTES                   Attributes,
1427   IN UINTN                            BbsEntry,
1428   IN VOID                             *BeerData,
1429   IN VOID                             *ServiceAreaData
1430   )
1431 {
1432   EFI_STATUS                        Status;
1433   EFI_TO_COMPATIBILITY16_BOOT_TABLE *EfiToLegacy16BootTable;
1434   LEGACY_BIOS_INSTANCE              *Private;
1435   UD_TABLE                          *UcdTable;
1436   UINTN                             Index;
1437   UINT16                            BootPriority;
1438   BBS_TABLE                         *BbsTable;
1439
1440   BootPriority = 0;
1441   Private = LEGACY_BIOS_INSTANCE_FROM_THIS (This);
1442   mBootMode = BOOT_UNCONVENTIONAL_DEVICE;
1443   mBbsDevicePathPtr = &mBbsDevicePathNode;
1444   mAttributes = Attributes;
1445   mBbsEntry = BbsEntry;
1446   mBeerData = BeerData, mServiceAreaData = ServiceAreaData;
1447
1448   EfiToLegacy16BootTable = &Private->IntThunk->EfiToLegacy16BootTable;
1449
1450   //
1451   // Do input parameter checking
1452   //
1453   if ((Attributes.DirectoryServiceValidity == 0) &&
1454       (Attributes.RabcaUsedFlag == 0) &&
1455       (Attributes.ExecuteHddDiagnosticsFlag == 0)
1456       ) {
1457     return EFI_INVALID_PARAMETER;
1458   }
1459
1460   if (((Attributes.DirectoryServiceValidity != 0) && (ServiceAreaData == NULL)) ||
1461       (((Attributes.DirectoryServiceValidity | Attributes.RabcaUsedFlag) != 0) && (BeerData == NULL))
1462       ) {
1463     return EFI_INVALID_PARAMETER;
1464   }
1465
1466   UcdTable = (UD_TABLE *) AllocatePool (
1467                             sizeof (UD_TABLE)
1468                             );
1469   if (NULL == UcdTable) {
1470     return EFI_OUT_OF_RESOURCES;
1471   }
1472
1473   EfiToLegacy16BootTable->UnconventionalDeviceTable = (UINT32)(UINTN)UcdTable;
1474   UcdTable->Attributes = Attributes;
1475   UcdTable->BbsTableEntryNumberForParentDevice = (UINT8) BbsEntry;
1476   //
1477   // Force all existing BBS entries to DoNotBoot. This allows 16-bit CSM
1478   // to assign drive numbers but bot boot from. Only newly created entries
1479   // will be valid.
1480   //
1481   BbsTable = (BBS_TABLE*)(UINTN)EfiToLegacy16BootTable->BbsTable;
1482   for (Index = 0; Index < EfiToLegacy16BootTable->NumberBbsEntries; Index++) {
1483     BbsTable[Index].BootPriority = BBS_DO_NOT_BOOT_FROM;
1484   }
1485   //
1486   // If parent is onboard IDE then assign controller & device number
1487   // else they are 0.
1488   //
1489   if (BbsEntry < MAX_IDE_CONTROLLER * 2) {
1490     UcdTable->DeviceNumber = (UINT8) ((BbsEntry - 1) % 2);
1491   }
1492
1493   if (BeerData != NULL) {
1494     CopyMem (
1495       (VOID *) UcdTable->BeerData,
1496       BeerData,
1497       (UINTN) 128
1498       );
1499   }
1500
1501   if (ServiceAreaData != NULL) {
1502     CopyMem (
1503       (VOID *) UcdTable->ServiceAreaData,
1504       ServiceAreaData,
1505       (UINTN) 64
1506       );
1507   }
1508   //
1509   // For each new entry do the following:
1510   //   1. Increment current number of BBS entries
1511   //   2. Copy parent entry to new entry.
1512   //   3. Zero out BootHandler Offset & segment
1513   //   4. Set appropriate device type. BEV(0x80) for HDD diagnostics
1514   //      and Floppy(0x01) for PARTIES boot.
1515   //   5. Assign new priority.
1516   //
1517   if ((Attributes.ExecuteHddDiagnosticsFlag) != 0) {
1518     EfiToLegacy16BootTable->NumberBbsEntries += 1;
1519
1520     CopyMem (
1521       (VOID *) &BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootPriority,
1522       (VOID *) &BbsTable[BbsEntry].BootPriority,
1523       sizeof (BBS_TABLE)
1524       );
1525
1526     BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootHandlerOffset  = 0;
1527     BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootHandlerSegment = 0;
1528     BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].DeviceType         = 0x80;
1529
1530     UcdTable->BbsTableEntryNumberForHddDiag = (UINT8) (EfiToLegacy16BootTable->NumberBbsEntries - 1);
1531
1532     BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootPriority = BootPriority;
1533     BootPriority += 1;
1534
1535     //
1536     // Set device type as BBS_TYPE_DEV for PARTIES diagnostic
1537     //
1538     mBbsDevicePathNode.DeviceType = BBS_TYPE_BEV;
1539   }
1540
1541   if (((Attributes.DirectoryServiceValidity | Attributes.RabcaUsedFlag)) != 0) {
1542     EfiToLegacy16BootTable->NumberBbsEntries += 1;
1543     CopyMem (
1544       (VOID *) &BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootPriority,
1545       (VOID *) &BbsTable[BbsEntry].BootPriority,
1546       sizeof (BBS_TABLE)
1547       );
1548
1549     BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootHandlerOffset  = 0;
1550     BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootHandlerSegment = 0;
1551     BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].DeviceType         = 0x01;
1552     UcdTable->BbsTableEntryNumberForBoot = (UINT8) (EfiToLegacy16BootTable->NumberBbsEntries - 1);
1553     BbsTable[EfiToLegacy16BootTable->NumberBbsEntries].BootPriority = BootPriority;
1554
1555     //
1556     // Set device type as BBS_TYPE_FLOPPY for PARTIES boot as floppy
1557     //
1558     mBbsDevicePathNode.DeviceType = BBS_TYPE_FLOPPY;
1559   }
1560   //
1561   // Build the BBS Device Path for this boot selection
1562   //
1563   mBbsDevicePathNode.Header.Type    = BBS_DEVICE_PATH;
1564   mBbsDevicePathNode.Header.SubType = BBS_BBS_DP;
1565   SetDevicePathNodeLength (&mBbsDevicePathNode.Header, sizeof (BBS_BBS_DEVICE_PATH));
1566   mBbsDevicePathNode.StatusFlag = 0;
1567   mBbsDevicePathNode.String[0]  = 0;
1568
1569   Status                        = GenericLegacyBoot (This);
1570   return Status;
1571 }
1572
1573 /**
1574   Attempt to legacy boot the BootOption. If the EFI contexted has been
1575   compromised this function will not return.
1576
1577   @param  This             Protocol instance pointer.
1578   @param  BbsDevicePath    EFI Device Path from BootXXXX variable.
1579   @param  LoadOptionsSize  Size of LoadOption in size.
1580   @param  LoadOptions      LoadOption from BootXXXX variable
1581
1582   @retval EFI_SUCCESS      Removable media not present
1583
1584 **/
1585 EFI_STATUS
1586 EFIAPI
1587 LegacyBiosLegacyBoot (
1588   IN EFI_LEGACY_BIOS_PROTOCOL           *This,
1589   IN  BBS_BBS_DEVICE_PATH               *BbsDevicePath,
1590   IN  UINT32                            LoadOptionsSize,
1591   IN  VOID                              *LoadOptions
1592   )
1593 {
1594   EFI_STATUS  Status;
1595
1596   mBbsDevicePathPtr = BbsDevicePath;
1597   mLoadOptionsSize  = LoadOptionsSize;
1598   mLoadOptions      = LoadOptions;
1599   mBootMode         = BOOT_LEGACY_OS;
1600   Status            = GenericLegacyBoot (This);
1601
1602   return Status;
1603 }
1604
1605 /**
1606   Convert EFI Memory Type to E820 Memory Type.
1607
1608   @param  Type  EFI Memory Type
1609
1610   @return ACPI Memory Type for EFI Memory Type
1611
1612 **/
1613 EFI_ACPI_MEMORY_TYPE
1614 EfiMemoryTypeToE820Type (
1615   IN  UINT32    Type
1616   )
1617 {
1618   switch (Type) {
1619   case EfiLoaderCode:
1620   case EfiLoaderData:
1621   case EfiBootServicesCode:
1622   case EfiBootServicesData:
1623   case EfiConventionalMemory:
1624   //
1625   // The memory of EfiRuntimeServicesCode and EfiRuntimeServicesData are
1626   // usable memory for legacy OS, because legacy OS is not aware of EFI runtime concept.
1627   // In ACPI specification, EfiRuntimeServiceCode and EfiRuntimeServiceData
1628   // should be mapped to AddressRangeReserved. This statement is for UEFI OS, not for legacy OS.
1629   //
1630   case EfiRuntimeServicesCode:
1631   case EfiRuntimeServicesData:
1632     return EfiAcpiAddressRangeMemory;
1633
1634   case EfiPersistentMemory:
1635     return EfiAddressRangePersistentMemory;
1636
1637   case EfiACPIReclaimMemory:
1638     return EfiAcpiAddressRangeACPI;
1639
1640   case EfiACPIMemoryNVS:
1641     return EfiAcpiAddressRangeNVS;
1642
1643   //
1644   // All other types map to reserved.
1645   // Adding the code just waists FLASH space.
1646   //
1647   //  case  EfiReservedMemoryType:
1648   //  case  EfiUnusableMemory:
1649   //  case  EfiMemoryMappedIO:
1650   //  case  EfiMemoryMappedIOPortSpace:
1651   //  case  EfiPalCode:
1652   //
1653   default:
1654     return EfiAcpiAddressRangeReserved;
1655   }
1656 }
1657
1658 /**
1659   Build the E820 table.
1660
1661   @param  Private  Legacy BIOS Instance data
1662   @param  Size     Size of E820 Table
1663
1664   @retval EFI_SUCCESS  It should always work.
1665
1666 **/
1667 EFI_STATUS
1668 LegacyBiosBuildE820 (
1669   IN  LEGACY_BIOS_INSTANCE    *Private,
1670   OUT UINTN                   *Size
1671   )
1672 {
1673   EFI_STATUS                  Status;
1674   EFI_E820_ENTRY64            *E820Table;
1675   EFI_MEMORY_DESCRIPTOR       *EfiMemoryMap;
1676   EFI_MEMORY_DESCRIPTOR       *EfiMemoryMapEnd;
1677   EFI_MEMORY_DESCRIPTOR       *EfiEntry;
1678   EFI_MEMORY_DESCRIPTOR       *NextEfiEntry;
1679   EFI_MEMORY_DESCRIPTOR       TempEfiEntry;
1680   UINTN                       EfiMemoryMapSize;
1681   UINTN                       EfiMapKey;
1682   UINTN                       EfiDescriptorSize;
1683   UINT32                      EfiDescriptorVersion;
1684   UINTN                       Index;
1685   EFI_PEI_HOB_POINTERS        Hob;
1686   EFI_HOB_RESOURCE_DESCRIPTOR *ResourceHob;
1687   UINTN                       TempIndex;
1688   UINTN                       IndexSort;
1689   UINTN                       TempNextIndex;
1690   EFI_E820_ENTRY64            TempE820;
1691   EFI_ACPI_MEMORY_TYPE        TempType;
1692   BOOLEAN                     ChangedFlag;
1693   UINTN                       Above1MIndex;
1694   UINT64                      MemoryBlockLength;
1695
1696   E820Table = (EFI_E820_ENTRY64 *) Private->E820Table;
1697
1698   //
1699   // Get the EFI memory map.
1700   //
1701   EfiMemoryMapSize  = 0;
1702   EfiMemoryMap      = NULL;
1703   Status = gBS->GetMemoryMap (
1704                   &EfiMemoryMapSize,
1705                   EfiMemoryMap,
1706                   &EfiMapKey,
1707                   &EfiDescriptorSize,
1708                   &EfiDescriptorVersion
1709                   );
1710   ASSERT (Status == EFI_BUFFER_TOO_SMALL);
1711
1712   do {
1713     //
1714     // Use size returned back plus 1 descriptor for the AllocatePool.
1715     // We don't just multiply by 2 since the "for" loop below terminates on
1716     // EfiMemoryMapEnd which is dependent upon EfiMemoryMapSize. Otherwize
1717     // we process bogus entries and create bogus E820 entries.
1718     //
1719     EfiMemoryMap = (EFI_MEMORY_DESCRIPTOR *) AllocatePool (EfiMemoryMapSize);
1720     ASSERT (EfiMemoryMap != NULL);
1721     Status = gBS->GetMemoryMap (
1722                     &EfiMemoryMapSize,
1723                     EfiMemoryMap,
1724                     &EfiMapKey,
1725                     &EfiDescriptorSize,
1726                     &EfiDescriptorVersion
1727                     );
1728     if (EFI_ERROR (Status)) {
1729       FreePool (EfiMemoryMap);
1730     }
1731   } while (Status == EFI_BUFFER_TOO_SMALL);
1732
1733   ASSERT_EFI_ERROR (Status);
1734
1735   //
1736   // Punch in the E820 table for memory less than 1 MB.
1737   // Assume ZeroMem () has been done on data structure.
1738   //
1739   //
1740   // First entry is 0 to (640k - EBDA)
1741   //
1742   ACCESS_PAGE0_CODE (
1743     E820Table[0].BaseAddr  = 0;
1744     E820Table[0].Length    = (UINT64) ((*(UINT16 *) (UINTN)0x40E) << 4);
1745     E820Table[0].Type      = EfiAcpiAddressRangeMemory;
1746   );
1747
1748   //
1749   // Second entry is (640k - EBDA) to 640k
1750   //
1751   E820Table[1].BaseAddr  = E820Table[0].Length;
1752   E820Table[1].Length    = (UINT64) ((640 * 1024) - E820Table[0].Length);
1753   E820Table[1].Type      = EfiAcpiAddressRangeReserved;
1754
1755   //
1756   // Third Entry is legacy BIOS
1757   // DO NOT CLAIM region from 0xA0000-0xDFFFF. OS can use free areas
1758   // to page in memory under 1MB.
1759   // Omit region from 0xE0000 to start of BIOS, if any. This can be
1760   // used for a multiple reasons including OPROMS.
1761   //
1762
1763   //
1764   // The CSM binary image size is not the actually size that CSM binary used,
1765   // to avoid memory corrupt, we declare the 0E0000 - 0FFFFF is used by CSM binary.
1766   //
1767   E820Table[2].BaseAddr  = 0xE0000;
1768   E820Table[2].Length    = 0x20000;
1769   E820Table[2].Type      = EfiAcpiAddressRangeReserved;
1770
1771   Above1MIndex = 2;
1772
1773   //
1774   // Process the EFI map to produce E820 map;
1775   //
1776
1777   //
1778   // Sort memory map from low to high
1779   //
1780   EfiEntry        = EfiMemoryMap;
1781   NextEfiEntry    = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);
1782   EfiMemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) EfiMemoryMap + EfiMemoryMapSize);
1783   while (EfiEntry < EfiMemoryMapEnd) {
1784     while (NextEfiEntry < EfiMemoryMapEnd) {
1785       if (EfiEntry->PhysicalStart > NextEfiEntry->PhysicalStart) {
1786         CopyMem (&TempEfiEntry, EfiEntry, sizeof (EFI_MEMORY_DESCRIPTOR));
1787         CopyMem (EfiEntry, NextEfiEntry, sizeof (EFI_MEMORY_DESCRIPTOR));
1788         CopyMem (NextEfiEntry, &TempEfiEntry, sizeof (EFI_MEMORY_DESCRIPTOR));
1789       }
1790
1791       NextEfiEntry = NEXT_MEMORY_DESCRIPTOR (NextEfiEntry, EfiDescriptorSize);
1792     }
1793
1794     EfiEntry      = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);
1795     NextEfiEntry  = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);
1796   }
1797
1798   EfiEntry        = EfiMemoryMap;
1799   EfiMemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) EfiMemoryMap + EfiMemoryMapSize);
1800   for (Index = Above1MIndex; (EfiEntry < EfiMemoryMapEnd) && (Index < EFI_MAX_E820_ENTRY - 1); ) {
1801     MemoryBlockLength = (UINT64) (LShiftU64 (EfiEntry->NumberOfPages, 12));
1802     if ((EfiEntry->PhysicalStart + MemoryBlockLength) < 0x100000) {
1803       //
1804       // Skip the memory block is under 1MB
1805       //
1806     } else {
1807       if (EfiEntry->PhysicalStart < 0x100000) {
1808         //
1809         // When the memory block spans below 1MB, ensure the memory block start address is at least 1MB
1810         //
1811         MemoryBlockLength       -= 0x100000 - EfiEntry->PhysicalStart;
1812         EfiEntry->PhysicalStart =  0x100000;
1813       }
1814
1815       //
1816       // Convert memory type to E820 type
1817       //
1818       TempType = EfiMemoryTypeToE820Type (EfiEntry->Type);
1819
1820       if ((E820Table[Index].Type == TempType) && (EfiEntry->PhysicalStart == (E820Table[Index].BaseAddr + E820Table[Index].Length))) {
1821         //
1822         // Grow an existing entry
1823         //
1824         E820Table[Index].Length += MemoryBlockLength;
1825       } else {
1826         //
1827         // Make a new entry
1828         //
1829         ++Index;
1830         E820Table[Index].BaseAddr  = EfiEntry->PhysicalStart;
1831         E820Table[Index].Length    = MemoryBlockLength;
1832         E820Table[Index].Type      = TempType;
1833       }
1834     }
1835     EfiEntry = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);
1836   }
1837
1838   FreePool (EfiMemoryMap);
1839
1840   //
1841   // Process the reserved memory map to produce E820 map ;
1842   //
1843   for (Hob.Raw = GetHobList (); !END_OF_HOB_LIST (Hob); Hob.Raw = GET_NEXT_HOB (Hob)) {
1844     if (Hob.Raw != NULL && GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_RESOURCE_DESCRIPTOR) {
1845       ResourceHob = Hob.ResourceDescriptor;
1846       if (((ResourceHob->ResourceType == EFI_RESOURCE_MEMORY_MAPPED_IO) ||
1847           (ResourceHob->ResourceType == EFI_RESOURCE_FIRMWARE_DEVICE)  ||
1848           (ResourceHob->ResourceType == EFI_RESOURCE_MEMORY_RESERVED)    ) &&
1849           (ResourceHob->PhysicalStart > 0x100000) &&
1850           (Index < EFI_MAX_E820_ENTRY - 1)) {
1851         ++Index;
1852         E820Table[Index].BaseAddr  = ResourceHob->PhysicalStart;
1853         E820Table[Index].Length    = ResourceHob->ResourceLength;
1854         E820Table[Index].Type      = EfiAcpiAddressRangeReserved;
1855       }
1856     }
1857   }
1858
1859   Index ++;
1860   Private->IntThunk->EfiToLegacy16InitTable.NumberE820Entries = (UINT32)Index;
1861   Private->IntThunk->EfiToLegacy16BootTable.NumberE820Entries = (UINT32)Index;
1862   Private->NumberE820Entries = (UINT32)Index;
1863   *Size = (UINTN) (Index * sizeof (EFI_E820_ENTRY64));
1864
1865   //
1866   // Sort E820Table from low to high
1867   //
1868   for (TempIndex = 0; TempIndex < Index; TempIndex++) {
1869     ChangedFlag = FALSE;
1870     for (TempNextIndex = 1; TempNextIndex < Index - TempIndex; TempNextIndex++) {
1871       if (E820Table[TempNextIndex - 1].BaseAddr > E820Table[TempNextIndex].BaseAddr) {
1872         ChangedFlag                       = TRUE;
1873         TempE820.BaseAddr                 = E820Table[TempNextIndex - 1].BaseAddr;
1874         TempE820.Length                   = E820Table[TempNextIndex - 1].Length;
1875         TempE820.Type                     = E820Table[TempNextIndex - 1].Type;
1876
1877         E820Table[TempNextIndex - 1].BaseAddr  = E820Table[TempNextIndex].BaseAddr;
1878         E820Table[TempNextIndex - 1].Length    = E820Table[TempNextIndex].Length;
1879         E820Table[TempNextIndex - 1].Type      = E820Table[TempNextIndex].Type;
1880
1881         E820Table[TempNextIndex].BaseAddr      = TempE820.BaseAddr;
1882         E820Table[TempNextIndex].Length        = TempE820.Length;
1883         E820Table[TempNextIndex].Type          = TempE820.Type;
1884       }
1885     }
1886
1887     if (!ChangedFlag) {
1888       break;
1889     }
1890   }
1891
1892   //
1893   // Remove the overlap range
1894   //
1895   for (TempIndex = 1; TempIndex < Index; TempIndex++) {
1896     if (E820Table[TempIndex - 1].BaseAddr <= E820Table[TempIndex].BaseAddr &&
1897         ((E820Table[TempIndex - 1].BaseAddr + E820Table[TempIndex - 1].Length) >=
1898          (E820Table[TempIndex].BaseAddr +E820Table[TempIndex].Length))) {
1899         //
1900         //Overlap range is found
1901         //
1902         ASSERT (E820Table[TempIndex - 1].Type == E820Table[TempIndex].Type);
1903
1904         if (TempIndex == Index - 1) {
1905           E820Table[TempIndex].BaseAddr = 0;
1906           E820Table[TempIndex].Length   = 0;
1907           E820Table[TempIndex].Type     = (EFI_ACPI_MEMORY_TYPE) 0;
1908           Index--;
1909           break;
1910         } else {
1911           for (IndexSort = TempIndex; IndexSort < Index - 1; IndexSort ++) {
1912             E820Table[IndexSort].BaseAddr = E820Table[IndexSort + 1].BaseAddr;
1913             E820Table[IndexSort].Length   = E820Table[IndexSort + 1].Length;
1914             E820Table[IndexSort].Type     = E820Table[IndexSort + 1].Type;
1915           }
1916           Index--;
1917        }
1918     }
1919   }
1920
1921
1922
1923   Private->IntThunk->EfiToLegacy16InitTable.NumberE820Entries = (UINT32)Index;
1924   Private->IntThunk->EfiToLegacy16BootTable.NumberE820Entries = (UINT32)Index;
1925   Private->NumberE820Entries = (UINT32)Index;
1926   *Size = (UINTN) (Index * sizeof (EFI_E820_ENTRY64));
1927
1928   //
1929   // Determine OS usable memory above 1Mb
1930   //
1931   Private->IntThunk->EfiToLegacy16BootTable.OsMemoryAbove1Mb = 0x0000;
1932   for (TempIndex = Above1MIndex; TempIndex < Index; TempIndex++) {
1933     if (E820Table[TempIndex].BaseAddr >= 0x100000 && E820Table[TempIndex].BaseAddr < 0x100000000ULL) { // not include above 4G memory
1934       //
1935       // ACPIReclaimMemory is also usable memory for ACPI OS, after OS dumps all ACPI tables.
1936       //
1937       if ((E820Table[TempIndex].Type == EfiAcpiAddressRangeMemory) || (E820Table[TempIndex].Type == EfiAcpiAddressRangeACPI)) {
1938         Private->IntThunk->EfiToLegacy16BootTable.OsMemoryAbove1Mb += (UINT32) (E820Table[TempIndex].Length);
1939       } else {
1940         break; // break at first not normal memory, because SMM may use reserved memory.
1941       }
1942     }
1943   }
1944
1945   Private->IntThunk->EfiToLegacy16InitTable.OsMemoryAbove1Mb = Private->IntThunk->EfiToLegacy16BootTable.OsMemoryAbove1Mb;
1946
1947   //
1948   // Print DEBUG information
1949   //
1950   for (TempIndex = 0; TempIndex < Index; TempIndex++) {
1951     DEBUG((EFI_D_INFO, "E820[%2d]: 0x%16lx ---- 0x%16lx, Type = 0x%x \n",
1952       TempIndex,
1953       E820Table[TempIndex].BaseAddr,
1954       (E820Table[TempIndex].BaseAddr + E820Table[TempIndex].Length),
1955       E820Table[TempIndex].Type
1956       ));
1957   }
1958
1959   return EFI_SUCCESS;
1960 }
1961
1962
1963 /**
1964   Fill in the standard BDA and EBDA stuff prior to legacy Boot
1965
1966   @param  Private      Legacy BIOS Instance data
1967
1968   @retval EFI_SUCCESS  It should always work.
1969
1970 **/
1971 EFI_STATUS
1972 LegacyBiosCompleteBdaBeforeBoot (
1973   IN  LEGACY_BIOS_INSTANCE    *Private
1974   )
1975 {
1976   BDA_STRUC                   *Bda;
1977   UINT16                      MachineConfig;
1978   DEVICE_PRODUCER_DATA_HEADER *SioPtr;
1979
1980   Bda           = (BDA_STRUC *) ((UINTN) 0x400);
1981   MachineConfig = 0;
1982
1983   SioPtr        = &(Private->IntThunk->EfiToLegacy16BootTable.SioData);
1984   Bda->Com1     = SioPtr->Serial[0].Address;
1985   Bda->Com2     = SioPtr->Serial[1].Address;
1986   Bda->Com3     = SioPtr->Serial[2].Address;
1987   Bda->Com4     = SioPtr->Serial[3].Address;
1988
1989   if (SioPtr->Serial[0].Address != 0x00) {
1990     MachineConfig += 0x200;
1991   }
1992
1993   if (SioPtr->Serial[1].Address != 0x00) {
1994     MachineConfig += 0x200;
1995   }
1996
1997   if (SioPtr->Serial[2].Address != 0x00) {
1998     MachineConfig += 0x200;
1999   }
2000
2001   if (SioPtr->Serial[3].Address != 0x00) {
2002     MachineConfig += 0x200;
2003   }
2004
2005   Bda->Lpt1 = SioPtr->Parallel[0].Address;
2006   Bda->Lpt2 = SioPtr->Parallel[1].Address;
2007   Bda->Lpt3 = SioPtr->Parallel[2].Address;
2008
2009   if (SioPtr->Parallel[0].Address != 0x00) {
2010     MachineConfig += 0x4000;
2011   }
2012
2013   if (SioPtr->Parallel[1].Address != 0x00) {
2014     MachineConfig += 0x4000;
2015   }
2016
2017   if (SioPtr->Parallel[2].Address != 0x00) {
2018     MachineConfig += 0x4000;
2019   }
2020
2021   Bda->NumberOfDrives = (UINT8) (Bda->NumberOfDrives + Private->IdeDriveCount);
2022   if (SioPtr->Floppy.NumberOfFloppy != 0x00) {
2023     MachineConfig     = (UINT16) (MachineConfig + 0x01 + (SioPtr->Floppy.NumberOfFloppy - 1) * 0x40);
2024     Bda->FloppyXRate  = 0x07;
2025   }
2026
2027   Bda->Lpt1_2Timeout  = 0x1414;
2028   Bda->Lpt3_4Timeout  = 0x1414;
2029   Bda->Com1_2Timeout  = 0x0101;
2030   Bda->Com3_4Timeout  = 0x0101;
2031
2032   //
2033   // Force VGA and Coprocessor, indicate 101/102 keyboard
2034   //
2035   MachineConfig       = (UINT16) (MachineConfig + 0x00 + 0x02 + (SioPtr->MousePresent * 0x04));
2036   Bda->MachineConfig  = MachineConfig;
2037
2038   return EFI_SUCCESS;
2039 }
2040
2041 /**
2042   Fill in the standard BDA for Keyboard LEDs
2043
2044   @param  This         Protocol instance pointer.
2045   @param  Leds         Current LED status
2046
2047   @retval EFI_SUCCESS  It should always work.
2048
2049 **/
2050 EFI_STATUS
2051 EFIAPI
2052 LegacyBiosUpdateKeyboardLedStatus (
2053   IN EFI_LEGACY_BIOS_PROTOCOL           *This,
2054   IN  UINT8                             Leds
2055   )
2056 {
2057   LEGACY_BIOS_INSTANCE  *Private;
2058   BDA_STRUC             *Bda;
2059   UINT8                 LocalLeds;
2060   EFI_IA32_REGISTER_SET Regs;
2061
2062   Private             = LEGACY_BIOS_INSTANCE_FROM_THIS (This);
2063
2064   ACCESS_PAGE0_CODE (
2065     Bda                 = (BDA_STRUC *) ((UINTN) 0x400);
2066     LocalLeds           = Leds;
2067     Bda->LedStatus      = (UINT8) ((Bda->LedStatus &~0x07) | LocalLeds);
2068     LocalLeds           = (UINT8) (LocalLeds << 4);
2069     Bda->ShiftStatus    = (UINT8) ((Bda->ShiftStatus &~0x70) | LocalLeds);
2070     LocalLeds           = (UINT8) (Leds & 0x20);
2071     Bda->KeyboardStatus = (UINT8) ((Bda->KeyboardStatus &~0x20) | LocalLeds);
2072   );
2073
2074   //
2075   // Call into Legacy16 code to allow it to do any processing
2076   //
2077   ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
2078   Regs.X.AX = Legacy16SetKeyboardLeds;
2079   Regs.H.CL = Leds;
2080
2081   Private->LegacyBios.FarCall86 (
2082     &Private->LegacyBios,
2083     Private->Legacy16Table->Compatibility16CallSegment,
2084     Private->Legacy16Table->Compatibility16CallOffset,
2085     &Regs,
2086     NULL,
2087     0
2088     );
2089
2090   return EFI_SUCCESS;
2091 }
2092
2093
2094 /**
2095   Fill in the standard CMOS stuff prior to legacy Boot
2096
2097   @param  Private      Legacy BIOS Instance data
2098
2099   @retval EFI_SUCCESS  It should always work.
2100
2101 **/
2102 EFI_STATUS
2103 LegacyBiosCompleteStandardCmosBeforeBoot (
2104   IN  LEGACY_BIOS_INSTANCE    *Private
2105   )
2106 {
2107   UINT8   Bda;
2108   UINT8   Floppy;
2109   UINT32  Size;
2110
2111   //
2112   // Update CMOS locations
2113   // 10 floppy
2114   // 12,19,1A - ignore as OS don't use them and there is no standard due
2115   //            to large capacity drives
2116   // CMOS 14 = BDA 40:10 plus bit 3(display enabled)
2117   //
2118   ACCESS_PAGE0_CODE (
2119     Bda = (UINT8)(*((UINT8 *)((UINTN)0x410)) | BIT3);
2120   );
2121
2122   //
2123   // Force display enabled
2124   //
2125   Floppy = 0x00;
2126   if ((Bda & BIT0) != 0) {
2127     Floppy = BIT6;
2128   }
2129
2130   //
2131   // Check if 2.88MB floppy set
2132   //
2133   if ((Bda & (BIT7 | BIT6)) != 0) {
2134     Floppy = (UINT8)(Floppy | BIT1);
2135   }
2136
2137   LegacyWriteStandardCmos (CMOS_10, Floppy);
2138   LegacyWriteStandardCmos (CMOS_14, Bda);
2139
2140   //
2141   // Force Status Register A to set rate selection bits and divider
2142   //
2143   LegacyWriteStandardCmos (CMOS_0A, 0x26);
2144
2145   //
2146   // redo memory size since it can change
2147   //
2148   Size = (15 * SIZE_1MB) >> 10;
2149   if (Private->IntThunk->EfiToLegacy16InitTable.OsMemoryAbove1Mb < (15 * SIZE_1MB)) {
2150     Size  = Private->IntThunk->EfiToLegacy16InitTable.OsMemoryAbove1Mb >> 10;
2151   }
2152
2153   LegacyWriteStandardCmos (CMOS_17, (UINT8)(Size & 0xFF));
2154   LegacyWriteStandardCmos (CMOS_30, (UINT8)(Size & 0xFF));
2155   LegacyWriteStandardCmos (CMOS_18, (UINT8)(Size >> 8));
2156   LegacyWriteStandardCmos (CMOS_31, (UINT8)(Size >> 8));
2157
2158   LegacyCalculateWriteStandardCmosChecksum ();
2159
2160   return EFI_SUCCESS;
2161 }
2162
2163 /**
2164   Relocate this image under 4G memory for IPF.
2165
2166   @param  ImageHandle  Handle of driver image.
2167   @param  SystemTable  Pointer to system table.
2168
2169   @retval EFI_SUCCESS  Image successfully relocated.
2170   @retval EFI_ABORTED  Failed to relocate image.
2171
2172 **/
2173 EFI_STATUS
2174 RelocateImageUnder4GIfNeeded (
2175   IN EFI_HANDLE           ImageHandle,
2176   IN EFI_SYSTEM_TABLE     *SystemTable
2177   )
2178 {
2179   return EFI_SUCCESS;
2180 }