1 /** @file 2 3 Copyright (c) 2006 - 2016, 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 #ifndef _LEGACY_BIOS_INTERFACE_ 17 #define _LEGACY_BIOS_INTERFACE_ 18 19 20 #include <FrameworkDxe.h> 21 #include <IndustryStandard/Pci.h> 22 #include <IndustryStandard/SmBios.h> 23 #include <IndustryStandard/Acpi10.h> 24 25 #include <Guid/SmBios.h> 26 #include <Guid/Acpi.h> 27 #include <Guid/DxeServices.h> 28 #include <Guid/LegacyBios.h> 29 #include <Guid/StatusCodeDataTypeId.h> 30 #include <Guid/ImageAuthentication.h> 31 32 #include <Protocol/BlockIo.h> 33 #include <Protocol/LoadedImage.h> 34 #include <Protocol/PciIo.h> 35 #include <Protocol/Cpu.h> 36 #include <Protocol/Timer.h> 37 #include <Protocol/IsaIo.h> 38 #include <Protocol/LegacyRegion2.h> 39 #include <Protocol/SimpleTextIn.h> 40 #include <Protocol/LegacyInterrupt.h> 41 #include <Protocol/LegacyBios.h> 42 #include <Protocol/DiskInfo.h> 43 #include <Protocol/GenericMemoryTest.h> 44 #include <Protocol/LegacyBiosPlatform.h> 45 #include <Protocol/DevicePath.h> 46 #include <Protocol/Legacy8259.h> 47 #include <Protocol/PciRootBridgeIo.h> 48 #include <Protocol/SerialIo.h> 49 #include <Protocol/SuperIo.h> 50 51 #include <Library/BaseLib.h> 52 #include <Library/DebugLib.h> 53 #include <Library/UefiLib.h> 54 #include <Library/BaseMemoryLib.h> 55 #include <Library/ReportStatusCodeLib.h> 56 #include <Library/UefiRuntimeServicesTableLib.h> 57 #include <Library/HobLib.h> 58 #include <Library/UefiDriverEntryPoint.h> 59 #include <Library/MemoryAllocationLib.h> 60 #include <Library/UefiBootServicesTableLib.h> 61 #include <Library/IoLib.h> 62 #include <Library/PcdLib.h> 63 #include <Library/DevicePathLib.h> 64 #include <Library/DxeServicesTableLib.h> 65 #include <Library/PeCoffLib.h> 66 #include <Library/CacheMaintenanceLib.h> 67 #include <Library/DebugAgentLib.h> 68 69 // 70 // BUGBUG: This entry maybe changed to PCD in future and wait for 71 // redesign of BDS library 72 // 73 #define MAX_BBS_ENTRIES 0x100 74 75 // 76 // Thunk Status Codes 77 // (These apply only to errors with the thunk and not to the code that was 78 // thunked to.) 79 // 80 #define THUNK_OK 0x00 81 #define THUNK_ERR_A20_UNSUP 0x01 82 #define THUNK_ERR_A20_FAILED 0x02 83 84 // 85 // Vector base definitions 86 // 87 // 88 // 8259 Hardware definitions 89 // 90 #define LEGACY_MODE_BASE_VECTOR_MASTER 0x08 91 #define LEGACY_MODE_BASE_VECTOR_SLAVE 0x70 92 93 // 94 // The original PC used INT8-F for master PIC. Since these mapped over 95 // processor exceptions TIANO moved the master PIC to INT68-6F. 96 // 97 // The vector base for slave PIC is set as 0x70 for PC-AT compatibility. 98 // 99 #define PROTECTED_MODE_BASE_VECTOR_MASTER 0x68 100 #define PROTECTED_MODE_BASE_VECTOR_SLAVE 0x70 101 102 // 103 // When we call CSM16 functions, some CSM16 use es:[offset + 0xabcd] to get data passed from CSM32, 104 // offset + 0xabcd could overflow which exceeds 0xFFFF which is invalid in real mode. 105 // So this will keep offset as small as possible to avoid offset overflow in real mode. 106 // 107 #define NORMALIZE_EFI_SEGMENT(_Adr) (UINT16) (((UINTN) (_Adr)) >> 4) 108 #define NORMALIZE_EFI_OFFSET(_Adr) (UINT16) (((UINT16) ((UINTN) (_Adr))) & 0xf) 109 110 // 111 // Trace defines 112 // 113 // 114 #define LEGACY_BDA_TRACE 0x000 115 #define LEGACY_BIOS_TRACE 0x040 116 #define LEGACY_BOOT_TRACE 0x080 117 #define LEGACY_CMOS_TRACE 0x0C0 118 #define LEGACY_IDE_TRACE 0x100 119 #define LEGACY_MP_TRACE 0x140 120 #define LEGACY_PCI_TRACE 0x180 121 #define LEGACY_SIO_TRACE 0x1C0 122 123 #define LEGACY_PCI_TRACE_000 LEGACY_PCI_TRACE + 0x00 124 #define LEGACY_PCI_TRACE_001 LEGACY_PCI_TRACE + 0x01 125 #define LEGACY_PCI_TRACE_002 LEGACY_PCI_TRACE + 0x02 126 #define LEGACY_PCI_TRACE_003 LEGACY_PCI_TRACE + 0x03 127 #define LEGACY_PCI_TRACE_004 LEGACY_PCI_TRACE + 0x04 128 #define LEGACY_PCI_TRACE_005 LEGACY_PCI_TRACE + 0x05 129 #define LEGACY_PCI_TRACE_006 LEGACY_PCI_TRACE + 0x06 130 #define LEGACY_PCI_TRACE_007 LEGACY_PCI_TRACE + 0x07 131 #define LEGACY_PCI_TRACE_008 LEGACY_PCI_TRACE + 0x08 132 #define LEGACY_PCI_TRACE_009 LEGACY_PCI_TRACE + 0x09 133 #define LEGACY_PCI_TRACE_00A LEGACY_PCI_TRACE + 0x0A 134 #define LEGACY_PCI_TRACE_00B LEGACY_PCI_TRACE + 0x0B 135 #define LEGACY_PCI_TRACE_00C LEGACY_PCI_TRACE + 0x0C 136 #define LEGACY_PCI_TRACE_00D LEGACY_PCI_TRACE + 0x0D 137 #define LEGACY_PCI_TRACE_00E LEGACY_PCI_TRACE + 0x0E 138 #define LEGACY_PCI_TRACE_00F LEGACY_PCI_TRACE + 0x0F 139 140 #define BDA_VIDEO_MODE 0x49 141 142 #define IDE_PI_REGISTER_PNE BIT0 143 #define IDE_PI_REGISTER_SNE BIT2 144 145 typedef struct { 146 UINTN PciSegment; 147 UINTN PciBus; 148 UINTN PciDevice; 149 UINTN PciFunction; 150 UINT32 ShadowAddress; 151 UINT32 ShadowedSize; 152 UINT8 DiskStart; 153 UINT8 DiskEnd; 154 } ROM_INSTANCE_ENTRY; 155 156 // 157 // Values for RealModeGdt 158 // 159 #if defined (MDE_CPU_IA32) 160 161 #define NUM_REAL_GDT_ENTRIES 3 162 #define CONVENTIONAL_MEMORY_TOP 0xA0000 // 640 KB 163 #define INITIAL_VALUE_BELOW_1K 0x0 164 165 #elif defined (MDE_CPU_X64) 166 167 #define NUM_REAL_GDT_ENTRIES 8 168 #define CONVENTIONAL_MEMORY_TOP 0xA0000 // 640 KB 169 #define INITIAL_VALUE_BELOW_1K 0x0 170 171 #elif defined (MDE_CPU_IPF) 172 173 #define NUM_REAL_GDT_ENTRIES 3 174 #define CONVENTIONAL_MEMORY_TOP 0x80000 // 512 KB 175 #define INITIAL_VALUE_BELOW_1K 0xff 176 177 #endif 178 179 #pragma pack(1) 180 181 // 182 // Define what a processor GDT looks like 183 // 184 typedef struct { 185 UINT32 LimitLo : 16; 186 UINT32 BaseLo : 16; 187 UINT32 BaseMid : 8; 188 UINT32 Type : 4; 189 UINT32 System : 1; 190 UINT32 Dpl : 2; 191 UINT32 Present : 1; 192 UINT32 LimitHi : 4; 193 UINT32 Software : 1; 194 UINT32 Reserved : 1; 195 UINT32 DefaultSize : 1; 196 UINT32 Granularity : 1; 197 UINT32 BaseHi : 8; 198 } GDT32; 199 200 typedef struct { 201 UINT16 LimitLow; 202 UINT16 BaseLow; 203 UINT8 BaseMid; 204 UINT8 Attribute; 205 UINT8 LimitHi; 206 UINT8 BaseHi; 207 } GDT64; 208 209 // 210 // Define what a processor descriptor looks like 211 // This data structure must be kept in sync with ASM STRUCT in Thunk.inc 212 // 213 typedef struct { 214 UINT16 Limit; 215 UINT64 Base; 216 } DESCRIPTOR64; 217 218 typedef struct { 219 UINT16 Limit; 220 UINT32 Base; 221 } DESCRIPTOR32; 222 223 // 224 // Low stub lay out 225 // 226 #define LOW_STACK_SIZE (8 * 1024) // 8k? 227 #define EFI_MAX_E820_ENTRY 100 228 #define FIRST_INSTANCE 1 229 #define NOT_FIRST_INSTANCE 0 230 231 #if defined (MDE_CPU_IA32) 232 typedef struct { 233 // 234 // Space for the code 235 // The address of Code is also the beginning of the relocated Thunk code 236 // 237 CHAR8 Code[4096]; // ? 238 // 239 // The address of the Reverse Thunk code 240 // Note that this member CONTAINS the address of the relocated reverse thunk 241 // code unlike the member variable 'Code', which IS the address of the Thunk 242 // code. 243 // 244 UINT32 LowReverseThunkStart; 245 246 // 247 // Data for the code (cs releative) 248 // 249 DESCRIPTOR32 GdtDesc; // Protected mode GDT 250 DESCRIPTOR32 IdtDesc; // Protected mode IDT 251 UINT32 FlatSs; 252 UINT32 FlatEsp; 253 254 UINT32 LowCodeSelector; // Low code selector in GDT 255 UINT32 LowDataSelector; // Low data selector in GDT 256 UINT32 LowStack; 257 DESCRIPTOR32 RealModeIdtDesc; 258 259 // 260 // real-mode GDT (temporary GDT with two real mode segment descriptors) 261 // 262 GDT32 RealModeGdt[NUM_REAL_GDT_ENTRIES]; 263 DESCRIPTOR32 RealModeGdtDesc; 264 265 // 266 // Members specifically for the reverse thunk 267 // The RevReal* members are used to store the current state of real mode 268 // before performing the reverse thunk. The RevFlat* members must be set 269 // before calling the reverse thunk assembly code. 270 // 271 UINT16 RevRealDs; 272 UINT16 RevRealSs; 273 UINT32 RevRealEsp; 274 DESCRIPTOR32 RevRealIdtDesc; 275 UINT16 RevFlatDataSelector; // Flat data selector in GDT 276 UINT32 RevFlatStack; 277 278 // 279 // A low memory stack 280 // 281 CHAR8 Stack[LOW_STACK_SIZE]; 282 283 // 284 // Stack for flat mode after reverse thunk 285 // @bug - This may no longer be necessary if the reverse thunk interface 286 // is changed to have the flat stack in a different location. 287 // 288 CHAR8 RevThunkStack[LOW_STACK_SIZE]; 289 290 // 291 // Legacy16 Init memory map info 292 // 293 EFI_TO_COMPATIBILITY16_INIT_TABLE EfiToLegacy16InitTable; 294 295 EFI_TO_COMPATIBILITY16_BOOT_TABLE EfiToLegacy16BootTable; 296 297 CHAR8 InterruptRedirectionCode[32]; 298 EFI_LEGACY_INSTALL_PCI_HANDLER PciHandler; 299 EFI_DISPATCH_OPROM_TABLE DispatchOpromTable; 300 BBS_TABLE BbsTable[MAX_BBS_ENTRIES]; 301 } LOW_MEMORY_THUNK; 302 303 #elif defined (MDE_CPU_X64) 304 305 typedef struct { 306 // 307 // Space for the code 308 // The address of Code is also the beginning of the relocated Thunk code 309 // 310 CHAR8 Code[4096]; // ? 311 312 // 313 // Data for the code (cs releative) 314 // 315 DESCRIPTOR64 X64GdtDesc; // Protected mode GDT 316 DESCRIPTOR64 X64IdtDesc; // Protected mode IDT 317 UINTN X64Ss; 318 UINTN X64Esp; 319 320 UINTN RealStack; 321 DESCRIPTOR32 RealModeIdtDesc; 322 DESCRIPTOR32 RealModeGdtDesc; 323 324 // 325 // real-mode GDT (temporary GDT with two real mode segment descriptors) 326 // 327 GDT64 RealModeGdt[NUM_REAL_GDT_ENTRIES]; 328 UINT64 PageMapLevel4; 329 330 // 331 // A low memory stack 332 // 333 CHAR8 Stack[LOW_STACK_SIZE]; 334 335 // 336 // Legacy16 Init memory map info 337 // 338 EFI_TO_COMPATIBILITY16_INIT_TABLE EfiToLegacy16InitTable; 339 340 EFI_TO_COMPATIBILITY16_BOOT_TABLE EfiToLegacy16BootTable; 341 342 CHAR8 InterruptRedirectionCode[32]; 343 EFI_LEGACY_INSTALL_PCI_HANDLER PciHandler; 344 EFI_DISPATCH_OPROM_TABLE DispatchOpromTable; 345 BBS_TABLE BbsTable[MAX_BBS_ENTRIES]; 346 } LOW_MEMORY_THUNK; 347 348 #elif defined (MDE_CPU_IPF) 349 350 typedef struct { 351 // 352 // Space for the code 353 // The address of Code is also the beginning of the relocated Thunk code 354 // 355 CHAR8 Code[4096]; // ? 356 // 357 // The address of the Reverse Thunk code 358 // Note that this member CONTAINS the address of the relocated reverse thunk 359 // code unlike the member variable 'Code', which IS the address of the Thunk 360 // code. 361 // 362 UINT32 LowReverseThunkStart; 363 364 // 365 // Data for the code (cs releative) 366 // 367 DESCRIPTOR32 GdtDesc; // Protected mode GDT 368 DESCRIPTOR32 IdtDesc; // Protected mode IDT 369 UINT32 FlatSs; 370 UINT32 FlatEsp; 371 372 UINT32 LowCodeSelector; // Low code selector in GDT 373 UINT32 LowDataSelector; // Low data selector in GDT 374 UINT32 LowStack; 375 DESCRIPTOR32 RealModeIdtDesc; 376 377 // 378 // real-mode GDT (temporary GDT with two real mode segment descriptors) 379 // 380 GDT32 RealModeGdt[NUM_REAL_GDT_ENTRIES]; 381 DESCRIPTOR32 RealModeGdtDesc; 382 383 // 384 // Members specifically for the reverse thunk 385 // The RevReal* members are used to store the current state of real mode 386 // before performing the reverse thunk. The RevFlat* members must be set 387 // before calling the reverse thunk assembly code. 388 // 389 UINT16 RevRealDs; 390 UINT16 RevRealSs; 391 UINT32 RevRealEsp; 392 DESCRIPTOR32 RevRealIdtDesc; 393 UINT16 RevFlatDataSelector; // Flat data selector in GDT 394 UINT32 RevFlatStack; 395 396 // 397 // A low memory stack 398 // 399 CHAR8 Stack[LOW_STACK_SIZE]; 400 401 // 402 // Stack for flat mode after reverse thunk 403 // @bug - This may no longer be necessary if the reverse thunk interface 404 // is changed to have the flat stack in a different location. 405 // 406 CHAR8 RevThunkStack[LOW_STACK_SIZE]; 407 408 // 409 // Legacy16 Init memory map info 410 // 411 EFI_TO_COMPATIBILITY16_INIT_TABLE EfiToLegacy16InitTable; 412 413 EFI_TO_COMPATIBILITY16_BOOT_TABLE EfiToLegacy16BootTable; 414 415 CHAR8 InterruptRedirectionCode[32]; 416 EFI_LEGACY_INSTALL_PCI_HANDLER PciHandler; 417 EFI_DISPATCH_OPROM_TABLE DispatchOpromTable; 418 BBS_TABLE BbsTable[MAX_BBS_ENTRIES]; 419 } LOW_MEMORY_THUNK; 420 421 #endif 422 423 // 424 // PnP Expansion Header 425 // 426 typedef struct { 427 UINT32 PnpSignature; 428 UINT8 Revision; 429 UINT8 Length; 430 UINT16 NextHeader; 431 UINT8 Reserved1; 432 UINT8 Checksum; 433 UINT32 DeviceId; 434 UINT16 MfgPointer; 435 UINT16 ProductNamePointer; 436 UINT8 Class; 437 UINT8 SubClass; 438 UINT8 Interface; 439 UINT8 DeviceIndicators; 440 UINT16 Bcv; 441 UINT16 DisconnectVector; 442 UINT16 Bev; 443 UINT16 Reserved2; 444 UINT16 StaticResourceVector; 445 } LEGACY_PNP_EXPANSION_HEADER; 446 447 typedef struct { 448 UINT8 PciSegment; 449 UINT8 PciBus; 450 UINT8 PciDevice; 451 UINT8 PciFunction; 452 UINT16 Vid; 453 UINT16 Did; 454 UINT16 SysSid; 455 UINT16 SVid; 456 UINT8 Class; 457 UINT8 SubClass; 458 UINT8 Interface; 459 UINT8 Reserved; 460 UINTN RomStart; 461 UINTN ManufacturerString; 462 UINTN ProductNameString; 463 } LEGACY_ROM_AND_BBS_TABLE; 464 465 // 466 // Structure how EFI has mapped a devices HDD drive numbers. 467 // Boot to EFI aware OS or shell requires this mapping when 468 // 16-bit CSM assigns drive numbers. 469 // This mapping is ignored booting to a legacy OS. 470 // 471 typedef struct { 472 UINT8 PciSegment; 473 UINT8 PciBus; 474 UINT8 PciDevice; 475 UINT8 PciFunction; 476 UINT8 StartDriveNumber; 477 UINT8 EndDriveNumber; 478 } LEGACY_EFI_HDD_TABLE; 479 480 // 481 // This data is passed to Leacy16Boot 482 // 483 typedef enum { 484 EfiAcpiAddressRangeMemory = 1, 485 EfiAcpiAddressRangeReserved = 2, 486 EfiAcpiAddressRangeACPI = 3, 487 EfiAcpiAddressRangeNVS = 4, 488 EfiAddressRangePersistentMemory = 7 489 } EFI_ACPI_MEMORY_TYPE; 490 491 typedef struct { 492 UINT64 BaseAddr; 493 UINT64 Length; 494 EFI_ACPI_MEMORY_TYPE Type; 495 } EFI_E820_ENTRY64; 496 497 typedef struct { 498 UINT32 BassAddrLow; 499 UINT32 BaseAddrHigh; 500 UINT32 LengthLow; 501 UINT32 LengthHigh; 502 EFI_ACPI_MEMORY_TYPE Type; 503 } EFI_E820_ENTRY; 504 505 #pragma pack() 506 507 extern BBS_TABLE *mBbsTable; 508 509 extern EFI_GENERIC_MEMORY_TEST_PROTOCOL *gGenMemoryTest; 510 511 #define PORT_70 0x70 512 #define PORT_71 0x71 513 514 #define CMOS_0A 0x0a ///< Status register A 515 #define CMOS_0D 0x0d ///< Status register D 516 #define CMOS_0E 0x0e ///< Diagnostic Status 517 #define CMOS_0F 0x0f ///< Shutdown status 518 #define CMOS_10 0x10 ///< Floppy type 519 #define CMOS_12 0x12 ///< IDE type 520 #define CMOS_14 0x14 ///< Same as BDA 40:10 521 #define CMOS_15 0x15 ///< Low byte of base memory in 1k increments 522 #define CMOS_16 0x16 ///< High byte of base memory in 1k increments 523 #define CMOS_17 0x17 ///< Low byte of 1MB+ memory in 1k increments - max 15 MB 524 #define CMOS_18 0x18 ///< High byte of 1MB+ memory in 1k increments - max 15 MB 525 #define CMOS_19 0x19 ///< C: extended drive type 526 #define CMOS_1A 0x1a ///< D: extended drive type 527 #define CMOS_2E 0x2e ///< Most significient byte of standard checksum 528 #define CMOS_2F 0x2f ///< Least significient byte of standard checksum 529 #define CMOS_30 0x30 ///< CMOS 0x17 530 #define CMOS_31 0x31 ///< CMOS 0x18 531 #define CMOS_32 0x32 ///< Century byte 532 533 // 534 // 8254 Timer registers 535 // 536 #define TIMER0_COUNT_PORT 0x40 537 #define TIMER1_COUNT_PORT 0x41 538 #define TIMER2_COUNT_PORT 0x42 539 #define TIMER_CONTROL_PORT 0x43 540 541 // 542 // Timer 0, Read/Write LSB then MSB, Square wave output, binary count use. 543 // 544 #define TIMER0_CONTROL_WORD 0x36 545 546 #define LEGACY_BIOS_INSTANCE_SIGNATURE SIGNATURE_32 ('L', 'B', 'I', 'T') 547 typedef struct { 548 UINTN Signature; 549 550 EFI_HANDLE Handle; 551 EFI_LEGACY_BIOS_PROTOCOL LegacyBios; 552 553 EFI_HANDLE ImageHandle; 554 555 // 556 // CPU Architectural Protocol 557 // 558 EFI_CPU_ARCH_PROTOCOL *Cpu; 559 560 // 561 // Timer Architectural Protocol 562 // 563 EFI_TIMER_ARCH_PROTOCOL *Timer; 564 BOOLEAN TimerUses8254; 565 566 // 567 // Protocol to Lock and Unlock 0xc0000 - 0xfffff 568 // 569 EFI_LEGACY_REGION2_PROTOCOL *LegacyRegion; 570 571 EFI_LEGACY_BIOS_PLATFORM_PROTOCOL *LegacyBiosPlatform; 572 573 // 574 // Interrupt control for thunk and PCI IRQ 575 // 576 EFI_LEGACY_8259_PROTOCOL *Legacy8259; 577 578 // 579 // PCI Interrupt PIRQ control 580 // 581 EFI_LEGACY_INTERRUPT_PROTOCOL *LegacyInterrupt; 582 583 // 584 // Generic Memory Test 585 // 586 EFI_GENERIC_MEMORY_TEST_PROTOCOL *GenericMemoryTest; 587 588 // 589 // TRUE if PCI Interupt Line registers have been programmed. 590 // 591 BOOLEAN PciInterruptLine; 592 593 // 594 // Code space below 1MB needed by thunker to transition to real mode. 595 // Contains stack and real mode code fragments 596 // 597 LOW_MEMORY_THUNK *IntThunk; 598 599 // 600 // Starting shadow address of the Legacy BIOS 601 // 602 UINT32 BiosStart; 603 UINT32 LegacyBiosImageSize; 604 605 // 606 // Start of variables used by CsmItp.mac ITP macro file and/os LegacyBios 607 // 608 UINT8 Dump[4]; 609 610 // 611 // $EFI Legacy16 code entry info in memory < 1 MB; 612 // 613 EFI_COMPATIBILITY16_TABLE *Legacy16Table; 614 VOID *Legacy16InitPtr; 615 VOID *Legacy16BootPtr; 616 VOID *InternalIrqRoutingTable; 617 UINT32 NumberIrqRoutingEntries; 618 VOID *BbsTablePtr; 619 VOID *HddTablePtr; 620 UINT32 NumberHddControllers; 621 622 // 623 // Cached copy of Legacy16 entry point 624 // 625 UINT16 Legacy16CallSegment; 626 UINT16 Legacy16CallOffset; 627 628 // 629 // Returned from $EFI and passed in to OPROMS 630 // 631 UINT16 PnPInstallationCheckSegment; 632 UINT16 PnPInstallationCheckOffset; 633 634 // 635 // E820 table 636 // 637 EFI_E820_ENTRY E820Table[EFI_MAX_E820_ENTRY]; 638 UINT32 NumberE820Entries; 639 640 // 641 // True if legacy VGA INT 10h handler installed 642 // 643 BOOLEAN VgaInstalled; 644 645 // 646 // Number of IDE drives 647 // 648 UINT8 IdeDriveCount; 649 650 // 651 // Current Free Option ROM space. An option ROM must NOT go past 652 // BiosStart. 653 // 654 UINT32 OptionRom; 655 656 // 657 // Save Legacy16 unexpected interrupt vector. Reprogram INT 68-6F from 658 // EFI values to legacy value just before boot. 659 // 660 UINT32 BiosUnexpectedInt; 661 UINT32 ThunkSavedInt[8]; 662 UINT16 ThunkSeg; 663 LEGACY_EFI_HDD_TABLE *LegacyEfiHddTable; 664 UINT16 LegacyEfiHddTableIndex; 665 UINT8 DiskEnd; 666 UINT8 Disk4075; 667 UINT16 TraceIndex; 668 UINT16 Trace[0x200]; 669 670 // 671 // Indicate that whether GenericLegacyBoot is entered or not 672 // 673 BOOLEAN LegacyBootEntered; 674 675 // 676 // CSM16 PCI Interface Version 677 // 678 UINT16 Csm16PciInterfaceVersion; 679 680 } LEGACY_BIOS_INSTANCE; 681 682 683 #pragma pack(1) 684 685 /* 686 40:00-01 Com1 687 40:02-03 Com2 688 40:04-05 Com3 689 40:06-07 Com4 690 40:08-09 Lpt1 691 40:0A-0B Lpt2 692 40:0C-0D Lpt3 693 40:0E-0E Ebda segment 694 40:10-11 MachineConfig 695 40:12 Bda12 - skip 696 40:13-14 MemSize below 1MB 697 40:15-16 Bda15_16 - skip 698 40:17 Keyboard Shift status 699 40:18-19 Bda18_19 - skip 700 40:1A-1B Key buffer head 701 40:1C-1D Key buffer tail 702 40:1E-3D Bda1E_3D- key buffer -skip 703 40:3E-3F FloppyData 3E = Calibration status 3F = Motor status 704 40:40 FloppyTimeout 705 40:41-74 Bda41_74 - skip 706 40:75 Number of HDD drives 707 40:76-77 Bda76_77 - skip 708 40:78-79 78 = Lpt1 timeout, 79 = Lpt2 timeout 709 40:7A-7B 7A = Lpt3 timeout, 7B = Lpt4 timeout 710 40:7C-7D 7C = Com1 timeout, 7D = Com2 timeout 711 40:7E-7F 7E = Com3 timeout, 7F = Com4 timeout 712 40:80-81 Pointer to start of key buffer 713 40:82-83 Pointer to end of key buffer 714 40:84-87 Bda84_87 - skip 715 40:88 HDD Data Xmit rate 716 40:89-8f skip 717 40:90 Floppy data rate 718 40:91-95 skip 719 40:96 Keyboard Status 720 40:97 LED Status 721 40:98-101 skip 722 */ 723 typedef struct { 724 UINT16 Com1; 725 UINT16 Com2; 726 UINT16 Com3; 727 UINT16 Com4; 728 UINT16 Lpt1; 729 UINT16 Lpt2; 730 UINT16 Lpt3; 731 UINT16 Ebda; 732 UINT16 MachineConfig; 733 UINT8 Bda12; 734 UINT16 MemSize; 735 UINT8 Bda15_16[0x02]; 736 UINT8 ShiftStatus; 737 UINT8 Bda18_19[0x02]; 738 UINT16 KeyHead; 739 UINT16 KeyTail; 740 UINT16 Bda1E_3D[0x10]; 741 UINT16 FloppyData; 742 UINT8 FloppyTimeout; 743 UINT8 Bda41_74[0x34]; 744 UINT8 NumberOfDrives; 745 UINT8 Bda76_77[0x02]; 746 UINT16 Lpt1_2Timeout; 747 UINT16 Lpt3_4Timeout; 748 UINT16 Com1_2Timeout; 749 UINT16 Com3_4Timeout; 750 UINT16 KeyStart; 751 UINT16 KeyEnd; 752 UINT8 Bda84_87[0x4]; 753 UINT8 DataXmit; 754 UINT8 Bda89_8F[0x07]; 755 UINT8 FloppyXRate; 756 UINT8 Bda91_95[0x05]; 757 UINT8 KeyboardStatus; 758 UINT8 LedStatus; 759 } BDA_STRUC; 760 #pragma pack() 761 762 #define LEGACY_BIOS_INSTANCE_FROM_THIS(this) CR (this, LEGACY_BIOS_INSTANCE, LegacyBios, LEGACY_BIOS_INSTANCE_SIGNATURE) 763 764 /** 765 Thunk to 16-bit real mode and execute a software interrupt with a vector 766 of BiosInt. Regs will contain the 16-bit register context on entry and 767 exit. 768 769 @param This Protocol instance pointer. 770 @param BiosInt Processor interrupt vector to invoke 771 @param Regs Register contexted passed into (and returned) from thunk to 772 16-bit mode 773 774 @retval FALSE Thunk completed, and there were no BIOS errors in the target code. 775 See Regs for status. 776 @retval TRUE There was a BIOS erro in the target code. 777 778 **/ 779 BOOLEAN 780 EFIAPI 781 LegacyBiosInt86 ( 782 IN EFI_LEGACY_BIOS_PROTOCOL *This, 783 IN UINT8 BiosInt, 784 IN EFI_IA32_REGISTER_SET *Regs 785 ); 786 787 788 /** 789 Thunk to 16-bit real mode and call Segment:Offset. Regs will contain the 790 16-bit register context on entry and exit. Arguments can be passed on 791 the Stack argument 792 793 @param This Protocol instance pointer. 794 @param Segment Segemnt of 16-bit mode call 795 @param Offset Offset of 16-bit mdoe call 796 @param Regs Register contexted passed into (and returned) from 797 thunk to 16-bit mode 798 @param Stack Caller allocated stack used to pass arguments 799 @param StackSize Size of Stack in bytes 800 801 @retval FALSE Thunk completed, and there were no BIOS errors in 802 the target code. See Regs for status. 803 @retval TRUE There was a BIOS erro in the target code. 804 805 **/ 806 BOOLEAN 807 EFIAPI 808 LegacyBiosFarCall86 ( 809 IN EFI_LEGACY_BIOS_PROTOCOL *This, 810 IN UINT16 Segment, 811 IN UINT16 Offset, 812 IN EFI_IA32_REGISTER_SET *Regs, 813 IN VOID *Stack, 814 IN UINTN StackSize 815 ); 816 817 818 /** 819 Test to see if a legacy PCI ROM exists for this device. Optionally return 820 the Legacy ROM instance for this PCI device. 821 822 @param This Protocol instance pointer. 823 @param PciHandle The PCI PC-AT OPROM from this devices ROM BAR will 824 be loaded 825 @param RomImage Return the legacy PCI ROM for this device 826 @param RomSize Size of ROM Image 827 @param Flags Indicates if ROM found and if PC-AT. 828 829 @retval EFI_SUCCESS Legacy Option ROM available for this device 830 @retval EFI_UNSUPPORTED Legacy Option ROM not supported. 831 832 **/ 833 EFI_STATUS 834 EFIAPI 835 LegacyBiosCheckPciRom ( 836 IN EFI_LEGACY_BIOS_PROTOCOL *This, 837 IN EFI_HANDLE PciHandle, 838 OUT VOID **RomImage, OPTIONAL 839 OUT UINTN *RomSize, OPTIONAL 840 OUT UINTN *Flags 841 ); 842 843 844 /** 845 Assign drive number to legacy HDD drives prior to booting an EFI 846 aware OS so the OS can access drives without an EFI driver. 847 Note: BBS compliant drives ARE NOT available until this call by 848 either shell or EFI. 849 850 @param This Protocol instance pointer. 851 @param BbsCount Number of BBS_TABLE structures 852 @param BbsTable List BBS entries 853 854 @retval EFI_SUCCESS Drive numbers assigned 855 856 **/ 857 EFI_STATUS 858 EFIAPI 859 LegacyBiosPrepareToBootEfi ( 860 IN EFI_LEGACY_BIOS_PROTOCOL *This, 861 OUT UINT16 *BbsCount, 862 OUT BBS_TABLE **BbsTable 863 ); 864 865 866 /** 867 To boot from an unconventional device like parties and/or execute 868 HDD diagnostics. 869 870 @param This Protocol instance pointer. 871 @param Attributes How to interpret the other input parameters 872 @param BbsEntry The 0-based index into the BbsTable for the parent 873 device. 874 @param BeerData Pointer to the 128 bytes of ram BEER data. 875 @param ServiceAreaData Pointer to the 64 bytes of raw Service Area data. 876 The caller must provide a pointer to the specific 877 Service Area and not the start all Service Areas. 878 EFI_INVALID_PARAMETER if error. Does NOT return if no error. 879 880 **/ 881 EFI_STATUS 882 EFIAPI 883 LegacyBiosBootUnconventionalDevice ( 884 IN EFI_LEGACY_BIOS_PROTOCOL *This, 885 IN UDC_ATTRIBUTES Attributes, 886 IN UINTN BbsEntry, 887 IN VOID *BeerData, 888 IN VOID *ServiceAreaData 889 ); 890 891 892 /** 893 Load a legacy PC-AT OPROM on the PciHandle device. Return information 894 about how many disks were added by the OPROM and the shadow address and 895 size. DiskStart & DiskEnd are INT 13h drive letters. Thus 0x80 is C: 896 897 @param This Protocol instance pointer. 898 @param PciHandle The PCI PC-AT OPROM from this devices ROM BAR will 899 be loaded. This value is NULL if RomImage is 900 non-NULL. This is the normal case. 901 @param RomImage A PCI PC-AT ROM image. This argument is non-NULL 902 if there is no hardware associated with the ROM 903 and thus no PciHandle, otherwise is must be NULL. 904 Example is PXE base code. 905 @param Flags Indicates if ROM found and if PC-AT. 906 @param DiskStart Disk number of first device hooked by the ROM. If 907 DiskStart is the same as DiskEnd no disked were 908 hooked. 909 @param DiskEnd Disk number of the last device hooked by the ROM. 910 @param RomShadowAddress Shadow address of PC-AT ROM 911 @param RomShadowedSize Size of RomShadowAddress in bytes 912 913 @retval EFI_SUCCESS Legacy ROM loaded for this device 914 @retval EFI_INVALID_PARAMETER PciHandle not found 915 @retval EFI_UNSUPPORTED There is no PCI ROM in the ROM BAR or no onboard 916 ROM 917 918 **/ 919 EFI_STATUS 920 EFIAPI 921 LegacyBiosInstallPciRom ( 922 IN EFI_LEGACY_BIOS_PROTOCOL * This, 923 IN EFI_HANDLE PciHandle, 924 IN VOID **RomImage, 925 OUT UINTN *Flags, 926 OUT UINT8 *DiskStart, OPTIONAL 927 OUT UINT8 *DiskEnd, OPTIONAL 928 OUT VOID **RomShadowAddress, OPTIONAL 929 OUT UINT32 *RomShadowedSize OPTIONAL 930 ); 931 932 933 /** 934 Fill in the standard BDA for Keyboard LEDs 935 936 @param This Protocol instance pointer. 937 @param Leds Current LED status 938 939 @retval EFI_SUCCESS It should always work. 940 941 **/ 942 EFI_STATUS 943 EFIAPI 944 LegacyBiosUpdateKeyboardLedStatus ( 945 IN EFI_LEGACY_BIOS_PROTOCOL *This, 946 IN UINT8 Leds 947 ); 948 949 950 /** 951 Get all BBS info 952 953 @param This Protocol instance pointer. 954 @param HddCount Number of HDD_INFO structures 955 @param HddInfo Onboard IDE controller information 956 @param BbsCount Number of BBS_TABLE structures 957 @param BbsTable List BBS entries 958 959 @retval EFI_SUCCESS Tables returned 960 @retval EFI_NOT_FOUND resource not found 961 @retval EFI_DEVICE_ERROR can not get BBS table 962 963 **/ 964 EFI_STATUS 965 EFIAPI 966 LegacyBiosGetBbsInfo ( 967 IN EFI_LEGACY_BIOS_PROTOCOL *This, 968 OUT UINT16 *HddCount, 969 OUT HDD_INFO **HddInfo, 970 OUT UINT16 *BbsCount, 971 OUT BBS_TABLE **BbsTable 972 ); 973 974 975 /** 976 Shadow all legacy16 OPROMs that haven't been shadowed. 977 Warning: Use this with caution. This routine disconnects all EFI 978 drivers. If used externally then caller must re-connect EFI 979 drivers. 980 981 @param This Protocol instance pointer. 982 983 @retval EFI_SUCCESS OPROMs shadowed 984 985 **/ 986 EFI_STATUS 987 EFIAPI 988 LegacyBiosShadowAllLegacyOproms ( 989 IN EFI_LEGACY_BIOS_PROTOCOL *This 990 ); 991 992 993 /** 994 Attempt to legacy boot the BootOption. If the EFI contexted has been 995 compromised this function will not return. 996 997 @param This Protocol instance pointer. 998 @param BbsDevicePath EFI Device Path from BootXXXX variable. 999 @param LoadOptionsSize Size of LoadOption in size. 1000 @param LoadOptions LoadOption from BootXXXX variable 1001 1002 @retval EFI_SUCCESS Removable media not present 1003 1004 **/ 1005 EFI_STATUS 1006 EFIAPI 1007 LegacyBiosLegacyBoot ( 1008 IN EFI_LEGACY_BIOS_PROTOCOL *This, 1009 IN BBS_BBS_DEVICE_PATH *BbsDevicePath, 1010 IN UINT32 LoadOptionsSize, 1011 IN VOID *LoadOptions 1012 ); 1013 1014 1015 /** 1016 Allocate memory < 1 MB and copy the thunker code into low memory. Se up 1017 all the descriptors. 1018 1019 @param Private Private context for Legacy BIOS 1020 1021 @retval EFI_SUCCESS Should only pass. 1022 1023 **/ 1024 EFI_STATUS 1025 LegacyBiosInitializeThunk ( 1026 IN LEGACY_BIOS_INSTANCE *Private 1027 ); 1028 1029 1030 /** 1031 Fill in the standard BDA and EBDA stuff before Legacy16 load 1032 1033 @param Private Legacy BIOS Instance data 1034 1035 @retval EFI_SUCCESS It should always work. 1036 1037 **/ 1038 EFI_STATUS 1039 LegacyBiosInitBda ( 1040 IN LEGACY_BIOS_INSTANCE *Private 1041 ); 1042 1043 1044 /** 1045 Collect IDE Inquiry data from the IDE disks 1046 1047 @param Private Legacy BIOS Instance data 1048 @param HddInfo Hdd Information 1049 @param Flag Reconnect IdeController or not 1050 1051 @retval EFI_SUCCESS It should always work. 1052 1053 **/ 1054 EFI_STATUS 1055 LegacyBiosBuildIdeData ( 1056 IN LEGACY_BIOS_INSTANCE *Private, 1057 IN HDD_INFO **HddInfo, 1058 IN UINT16 Flag 1059 ); 1060 1061 1062 /** 1063 Enable ide controller. This gets disabled when LegacyBoot.c is about 1064 to run the Option ROMs. 1065 1066 @param Private Legacy BIOS Instance data 1067 1068 1069 **/ 1070 VOID 1071 EnableIdeController ( 1072 IN LEGACY_BIOS_INSTANCE *Private 1073 ); 1074 1075 1076 /** 1077 If the IDE channel is in compatibility (legacy) mode, remove all 1078 PCI I/O BAR addresses from the controller. 1079 1080 @param IdeController The handle of target IDE controller 1081 1082 1083 **/ 1084 VOID 1085 InitLegacyIdeController ( 1086 IN EFI_HANDLE IdeController 1087 ); 1088 1089 1090 /** 1091 Program the interrupt routing register in all the PCI devices. On a PC AT system 1092 this register contains the 8259 IRQ vector that matches it's PCI interrupt. 1093 1094 @param Private Legacy BIOS Instance data 1095 1096 @retval EFI_SUCCESS Succeed. 1097 @retval EFI_ALREADY_STARTED All PCI devices have been processed. 1098 1099 **/ 1100 EFI_STATUS 1101 PciProgramAllInterruptLineRegisters ( 1102 IN LEGACY_BIOS_INSTANCE *Private 1103 ); 1104 1105 1106 /** 1107 Collect EFI Info about legacy devices. 1108 1109 @param Private Legacy BIOS Instance data 1110 1111 @retval EFI_SUCCESS It should always work. 1112 1113 **/ 1114 EFI_STATUS 1115 LegacyBiosBuildSioData ( 1116 IN LEGACY_BIOS_INSTANCE *Private 1117 ); 1118 1119 1120 /** 1121 Shadow all the PCI legacy ROMs. Use data from the Legacy BIOS Protocol 1122 to chose the order. Skip any devices that have already have legacy 1123 BIOS run. 1124 1125 @param Private Protocol instance pointer. 1126 1127 @retval EFI_SUCCESS Succeed. 1128 @retval EFI_UNSUPPORTED Cannot get VGA device handle. 1129 1130 **/ 1131 EFI_STATUS 1132 PciShadowRoms ( 1133 IN LEGACY_BIOS_INSTANCE *Private 1134 ); 1135 1136 1137 /** 1138 Fill in the standard BDA and EBDA stuff prior to legacy Boot 1139 1140 @param Private Legacy BIOS Instance data 1141 1142 @retval EFI_SUCCESS It should always work. 1143 1144 **/ 1145 EFI_STATUS 1146 LegacyBiosCompleteBdaBeforeBoot ( 1147 IN LEGACY_BIOS_INSTANCE *Private 1148 ); 1149 1150 1151 /** 1152 Fill in the standard CMOS stuff before Legacy16 load 1153 1154 @param Private Legacy BIOS Instance data 1155 1156 @retval EFI_SUCCESS It should always work. 1157 1158 **/ 1159 EFI_STATUS 1160 LegacyBiosInitCmos ( 1161 IN LEGACY_BIOS_INSTANCE *Private 1162 ); 1163 1164 1165 /** 1166 Fill in the standard CMOS stuff prior to legacy Boot 1167 1168 @param Private Legacy BIOS Instance data 1169 1170 @retval EFI_SUCCESS It should always work. 1171 1172 **/ 1173 EFI_STATUS 1174 LegacyBiosCompleteStandardCmosBeforeBoot ( 1175 IN LEGACY_BIOS_INSTANCE *Private 1176 ); 1177 1178 1179 /** 1180 Contains the code that is copied into low memory (below 640K). 1181 This code reflects interrupts 0x68-0x6f to interrupts 0x08-0x0f. 1182 This template must be copied into low memory, and the IDT entries 1183 0x68-0x6F must be point to the low memory copy of this code. Each 1184 entry is 4 bytes long, so IDT entries 0x68-0x6F can be easily 1185 computed. 1186 1187 **/ 1188 VOID 1189 InterruptRedirectionTemplate ( 1190 VOID 1191 ); 1192 1193 1194 /** 1195 Build the E820 table. 1196 1197 @param Private Legacy BIOS Instance data 1198 @param Size Size of E820 Table 1199 1200 @retval EFI_SUCCESS It should always work. 1201 1202 **/ 1203 EFI_STATUS 1204 LegacyBiosBuildE820 ( 1205 IN LEGACY_BIOS_INSTANCE *Private, 1206 OUT UINTN *Size 1207 ); 1208 1209 /** 1210 This function is to put all AP in halt state. 1211 1212 @param Private Legacy BIOS Instance data 1213 1214 **/ 1215 VOID 1216 ShutdownAPs ( 1217 IN LEGACY_BIOS_INSTANCE *Private 1218 ); 1219 1220 /** 1221 Worker function for LegacyBiosGetFlatDescs, retrieving content of 1222 specific registers. 1223 1224 @param IntThunk Pointer to IntThunk of Legacy BIOS context. 1225 1226 **/ 1227 VOID 1228 GetRegisters ( 1229 LOW_MEMORY_THUNK *IntThunk 1230 ); 1231 1232 /** 1233 Routine for calling real thunk code. 1234 1235 @param RealCode The address of thunk code. 1236 @param BiosInt The Bios interrupt vector number. 1237 @param CallAddress The address of 16-bit mode call. 1238 1239 @return Status returned by real thunk code 1240 1241 **/ 1242 UINTN 1243 CallRealThunkCode ( 1244 UINT8 *RealCode, 1245 UINT8 BiosInt, 1246 UINT32 CallAddress 1247 ); 1248 1249 /** 1250 Routine for generating soft interrupt. 1251 1252 @param Vector The interrupt vector number. 1253 1254 **/ 1255 VOID 1256 GenerateSoftInit ( 1257 UINT8 Vector 1258 ); 1259 1260 /** 1261 Do an AllocatePages () of type AllocateMaxAddress for EfiBootServicesCode 1262 memory. 1263 1264 @param AllocateType Allocated Legacy Memory Type 1265 @param StartPageAddress Start address of range 1266 @param Pages Number of pages to allocate 1267 @param Result Result of allocation 1268 1269 @retval EFI_SUCCESS Legacy16 code loaded 1270 @retval Other No protocol installed, unload driver. 1271 1272 **/ 1273 EFI_STATUS 1274 AllocateLegacyMemory ( 1275 IN EFI_ALLOCATE_TYPE AllocateType, 1276 IN EFI_PHYSICAL_ADDRESS StartPageAddress, 1277 IN UINTN Pages, 1278 OUT EFI_PHYSICAL_ADDRESS *Result 1279 ); 1280 1281 /** 1282 Get a region from the LegacyBios for Tiano usage. Can only be invoked once. 1283 1284 @param This Protocol instance pointer. 1285 @param LegacyMemorySize Size of required region 1286 @param Region Region to use. 00 = Either 0xE0000 or 0xF0000 1287 block Bit0 = 1 0xF0000 block Bit1 = 1 0xE0000 1288 block 1289 @param Alignment Address alignment. Bit mapped. First non-zero 1290 bit from right is alignment. 1291 @param LegacyMemoryAddress Region Assigned 1292 1293 @retval EFI_SUCCESS Region assigned 1294 @retval EFI_ACCESS_DENIED Procedure previously invoked 1295 @retval Other Region not assigned 1296 1297 **/ 1298 EFI_STATUS 1299 EFIAPI 1300 LegacyBiosGetLegacyRegion ( 1301 IN EFI_LEGACY_BIOS_PROTOCOL *This, 1302 IN UINTN LegacyMemorySize, 1303 IN UINTN Region, 1304 IN UINTN Alignment, 1305 OUT VOID **LegacyMemoryAddress 1306 ); 1307 1308 /** 1309 Get a region from the LegacyBios for Tiano usage. Can only be invoked once. 1310 1311 @param This Protocol instance pointer. 1312 @param LegacyMemorySize Size of data to copy 1313 @param LegacyMemoryAddress Legacy Region destination address Note: must 1314 be in region assigned by 1315 LegacyBiosGetLegacyRegion 1316 @param LegacyMemorySourceAddress Source of data 1317 1318 @retval EFI_SUCCESS Region assigned 1319 @retval EFI_ACCESS_DENIED Destination outside assigned region 1320 1321 **/ 1322 EFI_STATUS 1323 EFIAPI 1324 LegacyBiosCopyLegacyRegion ( 1325 IN EFI_LEGACY_BIOS_PROTOCOL *This, 1326 IN UINTN LegacyMemorySize, 1327 IN VOID *LegacyMemoryAddress, 1328 IN VOID *LegacyMemorySourceAddress 1329 ); 1330 1331 /** 1332 Find Legacy16 BIOS image in the FLASH device and shadow it into memory. Find 1333 the $EFI table in the shadow area. Thunk into the Legacy16 code after it had 1334 been shadowed. 1335 1336 @param Private Legacy BIOS context data 1337 1338 @retval EFI_SUCCESS Legacy16 code loaded 1339 @retval Other No protocol installed, unload driver. 1340 1341 **/ 1342 EFI_STATUS 1343 ShadowAndStartLegacy16 ( 1344 IN LEGACY_BIOS_INSTANCE *Private 1345 ); 1346 1347 /** 1348 Checks the state of the floppy and if media is inserted. 1349 1350 This routine checks the state of the floppy and if media is inserted. 1351 There are 3 cases: 1352 No floppy present - Set BBS entry to ignore 1353 Floppy present & no media - Set BBS entry to lowest priority. We cannot 1354 set it to ignore since 16-bit CSM will 1355 indicate no floppy and thus drive A: is 1356 unusable. CSM-16 will not try floppy since 1357 lowest priority and thus not incur boot 1358 time penality. 1359 Floppy present & media - Set BBS entry to some priority. 1360 1361 @return State of floppy media 1362 1363 **/ 1364 UINT8 1365 HasMediaInFloppy ( 1366 VOID 1367 ); 1368 1369 /** 1370 Identify drive data must be updated to actual parameters before boot. 1371 This requires updating the checksum, if it exists. 1372 1373 @param IdentifyDriveData ATA Identify Data 1374 @param Checksum checksum of the ATA Identify Data 1375 1376 @retval EFI_SUCCESS checksum calculated 1377 @retval EFI_SECURITY_VIOLATION IdentifyData invalid 1378 1379 **/ 1380 EFI_STATUS 1381 CalculateIdentifyDriveChecksum ( 1382 IN UINT8 *IdentifyDriveData, 1383 OUT UINT8 *Checksum 1384 ); 1385 1386 /** 1387 Identify drive data must be updated to actual parameters before boot. 1388 1389 @param IdentifyDriveData ATA Identify Data 1390 1391 **/ 1392 VOID 1393 UpdateIdentifyDriveData ( 1394 IN UINT8 *IdentifyDriveData 1395 ); 1396 1397 /** 1398 Complete build of BBS TABLE. 1399 1400 @param Private Legacy BIOS Instance data 1401 @param BbsTable BBS Table passed to 16-bit code 1402 1403 @retval EFI_SUCCESS Removable media not present 1404 1405 **/ 1406 EFI_STATUS 1407 LegacyBiosBuildBbs ( 1408 IN LEGACY_BIOS_INSTANCE *Private, 1409 IN BBS_TABLE *BbsTable 1410 ); 1411 1412 /** 1413 Read CMOS register through index/data port. 1414 1415 @param[in] Index The index of the CMOS register to read. 1416 1417 @return The data value from the CMOS register specified by Index. 1418 1419 **/ 1420 UINT8 1421 LegacyReadStandardCmos ( 1422 IN UINT8 Index 1423 ); 1424 1425 /** 1426 Write CMOS register through index/data port. 1427 1428 @param[in] Index The index of the CMOS register to write. 1429 @param[in] Value The value of CMOS register to write. 1430 1431 @return The value written to the CMOS register specified by Index. 1432 1433 **/ 1434 UINT8 1435 LegacyWriteStandardCmos ( 1436 IN UINT8 Index, 1437 IN UINT8 Value 1438 ); 1439 1440 /** 1441 Calculate the new standard CMOS checksum and write it. 1442 1443 @param Private Legacy BIOS Instance data 1444 1445 @retval EFI_SUCCESS Calculate 16-bit checksum successfully 1446 1447 **/ 1448 EFI_STATUS 1449 LegacyCalculateWriteStandardCmosChecksum ( 1450 VOID 1451 ); 1452 1453 /** 1454 Test to see if a legacy PCI ROM exists for this device. Optionally return 1455 the Legacy ROM instance for this PCI device. 1456 1457 @param[in] This Protocol instance pointer. 1458 @param[in] PciHandle The PCI PC-AT OPROM from this devices ROM BAR will be loaded 1459 @param[out] RomImage Return the legacy PCI ROM for this device 1460 @param[out] RomSize Size of ROM Image 1461 @param[out] RuntimeImageLength Runtime size of ROM Image 1462 @param[out] Flags Indicates if ROM found and if PC-AT. 1463 @param[out] OpromRevision Revision of the PCI Rom 1464 @param[out] ConfigUtilityCodeHeaderPointer of Configuration Utility Code Header 1465 1466 @return EFI_SUCCESS Legacy Option ROM available for this device 1467 @return EFI_ALREADY_STARTED This device is already managed by its Oprom 1468 @return EFI_UNSUPPORTED Legacy Option ROM not supported. 1469 1470 **/ 1471 EFI_STATUS 1472 LegacyBiosCheckPciRomEx ( 1473 IN EFI_LEGACY_BIOS_PROTOCOL *This, 1474 IN EFI_HANDLE PciHandle, 1475 OUT VOID **RomImage, OPTIONAL 1476 OUT UINTN *RomSize, OPTIONAL 1477 OUT UINTN *RuntimeImageLength, OPTIONAL 1478 OUT UINTN *Flags, OPTIONAL 1479 OUT UINT8 *OpromRevision, OPTIONAL 1480 OUT VOID **ConfigUtilityCodeHeader OPTIONAL 1481 ); 1482 1483 /** 1484 Relocate this image under 4G memory for IPF. 1485 1486 @param ImageHandle Handle of driver image. 1487 @param SystemTable Pointer to system table. 1488 1489 @retval EFI_SUCCESS Image successfully relocated. 1490 @retval EFI_ABORTED Failed to relocate image. 1491 1492 **/ 1493 EFI_STATUS 1494 RelocateImageUnder4GIfNeeded ( 1495 IN EFI_HANDLE ImageHandle, 1496 IN EFI_SYSTEM_TABLE *SystemTable 1497 ); 1498 1499 /** 1500 Thunk to 16-bit real mode and call Segment:Offset. Regs will contain the 1501 16-bit register context on entry and exit. Arguments can be passed on 1502 the Stack argument 1503 1504 @param This Protocol instance pointer. 1505 @param Segment Segemnt of 16-bit mode call 1506 @param Offset Offset of 16-bit mdoe call 1507 @param Regs Register contexted passed into (and returned) from thunk to 1508 16-bit mode 1509 @param Stack Caller allocated stack used to pass arguments 1510 @param StackSize Size of Stack in bytes 1511 1512 @retval FALSE Thunk completed, and there were no BIOS errors in the target code. 1513 See Regs for status. 1514 @retval TRUE There was a BIOS erro in the target code. 1515 1516 **/ 1517 BOOLEAN 1518 EFIAPI 1519 InternalLegacyBiosFarCall ( 1520 IN EFI_LEGACY_BIOS_PROTOCOL *This, 1521 IN UINT16 Segment, 1522 IN UINT16 Offset, 1523 IN EFI_IA32_REGISTER_SET *Regs, 1524 IN VOID *Stack, 1525 IN UINTN StackSize 1526 ); 1527 1528 /** 1529 Load a legacy PC-AT OpROM for VGA controller. 1530 1531 @param Private Driver private data. 1532 1533 @retval EFI_SUCCESS Legacy ROM successfully installed for this device. 1534 @retval EFI_DEVICE_ERROR No VGA device handle found, or native EFI video 1535 driver cannot be successfully disconnected, or VGA 1536 thunk driver cannot be successfully connected. 1537 1538 **/ 1539 EFI_STATUS 1540 LegacyBiosInstallVgaRom ( 1541 IN LEGACY_BIOS_INSTANCE *Private 1542 ); 1543 1544 #endif 1545