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