Home | History | Annotate | Line # | Download | only in inc
      1 /*	$NetBSD: efiprot.h,v 1.1.1.3 2021/09/30 18:50:09 jmcneill Exp $	*/
      2 
      3 #ifndef _EFI_PROT_H
      4 #define _EFI_PROT_H
      5 
      6 /*++
      7 
      8 Copyright (c) 1998  Intel Corporation
      9 
     10 Module Name:
     11 
     12     efiprot.h
     13 
     14 Abstract:
     15 
     16     EFI Protocols
     17 
     18 
     19 
     20 Revision History
     21 
     22 --*/
     23 
     24 //
     25 //  FPSWA library protocol
     26 //
     27 #define EFI_FPSWA_PROTOCOL_GUID \
     28     { 0xc41b6531, 0x97b9, 0x11d3, {0x9a, 0x29, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
     29 #define FPSWA_PROTOCOL EFI_FPSWA_PROTOCOL_GUID
     30 
     31 //
     32 // Device Path protocol
     33 //
     34 
     35 #define EFI_DEVICE_PATH_PROTOCOL_GUID \
     36     { 0x9576e91, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
     37 #define DEVICE_PATH_PROTOCOL EFI_DEVICE_PATH_PROTOCOL_GUID
     38 
     39 
     40 //
     41 // Block IO protocol
     42 //
     43 
     44 #define EFI_BLOCK_IO_PROTOCOL_GUID \
     45     { 0x964e5b21, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
     46 #define BLOCK_IO_PROTOCOL EFI_BLOCK_IO_PROTOCOL_GUID
     47 
     48 #define EFI_BLOCK_IO_PROTOCOL_REVISION    0x00010000
     49 #define EFI_BLOCK_IO_PROTOCOL_REVISION2   0x00020001
     50 #define EFI_BLOCK_IO_PROTOCOL_REVISION3   ((2<<16) | 31)
     51 #define EFI_BLOCK_IO_INTERFACE_REVISION   EFI_BLOCK_IO_PROTOCOL_REVISION
     52 #define EFI_BLOCK_IO_INTERFACE_REVISION2  EFI_BLOCK_IO_PROTOCOL_REVISION2
     53 #define EFI_BLOCK_IO_INTERFACE_REVISION3  EFI_BLOCK_IO_PROTOCOL_REVISION3
     54 
     55 INTERFACE_DECL(_EFI_BLOCK_IO_PROTOCOL);
     56 
     57 typedef
     58 EFI_STATUS
     59 (EFIAPI *EFI_BLOCK_RESET) (
     60     IN struct _EFI_BLOCK_IO_PROTOCOL  *This,
     61     IN BOOLEAN                        ExtendedVerification
     62     );
     63 
     64 typedef
     65 EFI_STATUS
     66 (EFIAPI *EFI_BLOCK_READ) (
     67     IN struct _EFI_BLOCK_IO_PROTOCOL  *This,
     68     IN UINT32                         MediaId,
     69     IN EFI_LBA                        LBA,
     70     IN UINTN                          BufferSize,
     71     OUT VOID                          *Buffer
     72     );
     73 
     74 
     75 typedef
     76 EFI_STATUS
     77 (EFIAPI *EFI_BLOCK_WRITE) (
     78     IN struct _EFI_BLOCK_IO_PROTOCOL  *This,
     79     IN UINT32                         MediaId,
     80     IN EFI_LBA                        LBA,
     81     IN UINTN                          BufferSize,
     82     IN VOID                           *Buffer
     83     );
     84 
     85 
     86 typedef
     87 EFI_STATUS
     88 (EFIAPI *EFI_BLOCK_FLUSH) (
     89     IN struct _EFI_BLOCK_IO_PROTOCOL  *This
     90     );
     91 
     92 
     93 
     94 typedef struct {
     95     UINT32              MediaId;
     96     BOOLEAN             RemovableMedia;
     97     BOOLEAN             MediaPresent;
     98 
     99     BOOLEAN             LogicalPartition;
    100     BOOLEAN             ReadOnly;
    101     BOOLEAN             WriteCaching;
    102 
    103     UINT32              BlockSize;
    104     UINT32              IoAlign;
    105 
    106     EFI_LBA             LastBlock;
    107 
    108     /* revision 2 */
    109     EFI_LBA             LowestAlignedLba;
    110     UINT32              LogicalBlocksPerPhysicalBlock;
    111     /* revision 3 */
    112     UINT32              OptimalTransferLengthGranularity;
    113 } EFI_BLOCK_IO_MEDIA;
    114 
    115 typedef struct _EFI_BLOCK_IO_PROTOCOL {
    116     UINT64                  Revision;
    117 
    118     EFI_BLOCK_IO_MEDIA      *Media;
    119 
    120     EFI_BLOCK_RESET         Reset;
    121     EFI_BLOCK_READ          ReadBlocks;
    122     EFI_BLOCK_WRITE         WriteBlocks;
    123     EFI_BLOCK_FLUSH         FlushBlocks;
    124 
    125 } EFI_BLOCK_IO_PROTOCOL;
    126 
    127 typedef struct _EFI_BLOCK_IO_PROTOCOL _EFI_BLOCK_IO;
    128 typedef EFI_BLOCK_IO_PROTOCOL EFI_BLOCK_IO;
    129 
    130 #define EFI_BLOCK_IO2_PROTOCOL_GUID \
    131     { 0xa77b2472, 0xe282, 0x4e9f, {0xa2, 0x45, 0xc2, 0xc0, 0xe2, 0x7b, 0xbc, 0xc1} }
    132 
    133 INTERFACE_DECL(_EFI_BLOCK_IO2_PROTOCOL);
    134 
    135 typedef struct {
    136     EFI_EVENT               Event;
    137     EFI_STATUS              TransactionStatus;
    138 } EFI_BLOCK_IO2_TOKEN;
    139 
    140 typedef
    141 EFI_STATUS
    142 (EFIAPI *EFI_BLOCK_RESET_EX) (
    143     IN struct _EFI_BLOCK_IO2_PROTOCOL  *This,
    144     IN BOOLEAN                         ExtendedVerification
    145     );
    146 
    147 typedef
    148 EFI_STATUS
    149 (EFIAPI *EFI_BLOCK_READ_EX) (
    150     IN struct _EFI_BLOCK_IO2_PROTOCOL  *This,
    151     IN UINT32                          MediaId,
    152     IN EFI_LBA                         LBA,
    153     IN OUT EFI_BLOCK_IO2_TOKEN         *Token,
    154     IN UINTN                           BufferSize,
    155     OUT VOID                           *Buffer
    156     );
    157 
    158 typedef
    159 EFI_STATUS
    160 (EFIAPI *EFI_BLOCK_WRITE_EX) (
    161     IN struct _EFI_BLOCK_IO2_PROTOCOL  *This,
    162     IN UINT32                          MediaId,
    163     IN EFI_LBA                         LBA,
    164     IN OUT EFI_BLOCK_IO2_TOKEN         *Token,
    165     IN UINTN                           BufferSize,
    166     IN VOID                            *Buffer
    167     );
    168 
    169 typedef
    170 EFI_STATUS
    171 (EFIAPI *EFI_BLOCK_FLUSH_EX) (
    172     IN struct _EFI_BLOCK_IO2_PROTOCOL  *This,
    173     IN OUT EFI_BLOCK_IO2_TOKEN         *Token
    174     );
    175 
    176 typedef struct _EFI_BLOCK_IO2_PROTOCOL {
    177     EFI_BLOCK_IO_MEDIA  *Media;
    178     EFI_BLOCK_RESET_EX  Reset;
    179     EFI_BLOCK_READ_EX   ReadBlocksEx;
    180     EFI_BLOCK_WRITE_EX  WriteBlocksEx;
    181     EFI_BLOCK_FLUSH_EX  FlushBlocksEx;
    182 } EFI_BLOCK_IO2_PROTOCOL;
    183 
    184 //
    185 // Disk Block IO protocol
    186 //
    187 
    188 #define EFI_DISK_IO_PROTOCOL_GUID \
    189     { 0xce345171, 0xba0b, 0x11d2,  {0x8e, 0x4f, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
    190 #define DISK_IO_PROTOCOL EFI_DISK_IO_PROTOCOL_GUID
    191 
    192 #define EFI_DISK_IO_PROTOCOL_REVISION  0x00010000
    193 #define EFI_DISK_IO_INTERFACE_REVISION EFI_DISK_IO_PROTOCOL_REVISION
    194 
    195 INTERFACE_DECL(_EFI_DISK_IO_PROTOCOL);
    196 
    197 typedef
    198 EFI_STATUS
    199 (EFIAPI *EFI_DISK_READ) (
    200     IN struct _EFI_DISK_IO_PROTOCOL  *This,
    201     IN UINT32                        MediaId,
    202     IN UINT64                        Offset,
    203     IN UINTN                         BufferSize,
    204     OUT VOID                         *Buffer
    205     );
    206 
    207 
    208 typedef
    209 EFI_STATUS
    210 (EFIAPI *EFI_DISK_WRITE) (
    211     IN struct _EFI_DISK_IO_PROTOCOL  *This,
    212     IN UINT32                        MediaId,
    213     IN UINT64                        Offset,
    214     IN UINTN                         BufferSize,
    215     IN VOID                          *Buffer
    216     );
    217 
    218 
    219 typedef struct _EFI_DISK_IO_PROTOCOL {
    220     UINT64              Revision;
    221     EFI_DISK_READ       ReadDisk;
    222     EFI_DISK_WRITE      WriteDisk;
    223 } EFI_DISK_IO_PROTOCOL;
    224 
    225 typedef struct _EFI_DISK_IO_PROTOCOL _EFI_DISK_IO;
    226 typedef EFI_DISK_IO_PROTOCOL EFI_DISK_IO;
    227 
    228 
    229 #define EFI_DISK_IO2_PROTOCOL_GUID \
    230     { 0x151c8eae, 0x7f2c, 0x472c,  {0x9e, 0x54, 0x98, 0x28, 0x19, 0x4f, 0x6a, 0x88} }
    231 
    232 #define EFI_DISK_IO2_PROTOCOL_REVISION  0x00020000
    233 
    234 INTERFACE_DECL(_EFI_DISK_IO2_PROTOCOL);
    235 
    236 typedef struct {
    237     EFI_EVENT  Event;
    238     EFI_STATUS TransactionStatus;
    239 } EFI_DISK_IO2_TOKEN;
    240 
    241 typedef
    242 EFI_STATUS
    243 (EFIAPI *EFI_DISK_CANCEL_EX) (
    244     IN struct _EFI_DISK_IO2_PROTOCOL  *This
    245     );
    246 
    247 typedef
    248 EFI_STATUS
    249 (EFIAPI *EFI_DISK_READ_EX) (
    250     IN struct _EFI_DISK_IO2_PROTOCOL  *This,
    251     IN UINT32                         MediaId,
    252     IN UINT64                         Offset,
    253     IN OUT EFI_DISK_IO2_TOKEN         *Token,
    254     IN UINTN                          BufferSize,
    255     OUT VOID                          *Buffer
    256     );
    257 
    258 typedef
    259 EFI_STATUS
    260 (EFIAPI *EFI_DISK_WRITE_EX) (
    261     IN struct _EFI_DISK_IO2_PROTOCOL  *This,
    262     IN UINT32                         MediaId,
    263     IN UINT64                         Offset,
    264     IN OUT EFI_DISK_IO2_TOKEN         *Token,
    265     IN UINTN                          BufferSize,
    266     IN VOID                           *Buffer
    267     );
    268 
    269 typedef
    270 EFI_STATUS
    271 (EFIAPI *EFI_DISK_FLUSH_EX) (
    272     IN struct _EFI_DISK_IO2_PROTOCOL  *This,
    273     IN OUT EFI_DISK_IO2_TOKEN         *Token
    274     );
    275 
    276 typedef struct _EFI_DISK_IO2_PROTOCOL {
    277     UINT64                            Revision;
    278     EFI_DISK_CANCEL_EX                Cancel;
    279     EFI_DISK_READ_EX                  ReadDiskEx;
    280     EFI_DISK_WRITE_EX                 WriteDiskEx;
    281     EFI_DISK_FLUSH_EX                 FlushDiskEx;
    282 } EFI_DISK_IO2_PROTOCOL;
    283 
    284 //
    285 // Simple file system protocol
    286 //
    287 
    288 #define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID \
    289     { 0x964e5b22, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
    290 #define SIMPLE_FILE_SYSTEM_PROTOCOL EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID
    291 
    292 INTERFACE_DECL(_EFI_SIMPLE_FILE_SYSTEM_PROTOCOL);
    293 INTERFACE_DECL(_EFI_FILE_HANDLE);
    294 
    295 typedef
    296 EFI_STATUS
    297 (EFIAPI *EFI_VOLUME_OPEN) (
    298     IN struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL    *This,
    299     OUT struct _EFI_FILE_HANDLE                   **Root
    300     );
    301 
    302 #define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION  0x00010000
    303 #define EFI_FILE_IO_INTERFACE_REVISION EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION
    304 
    305 typedef struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL {
    306     UINT64                  Revision;
    307     EFI_VOLUME_OPEN         OpenVolume;
    308 } EFI_SIMPLE_FILE_SYSTEM_PROTOCOL;
    309 
    310 typedef struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL _EFI_FILE_IO_INTERFACE;
    311 typedef EFI_SIMPLE_FILE_SYSTEM_PROTOCOL EFI_FILE_IO_INTERFACE;
    312 
    313 //
    314 //
    315 //
    316 
    317 typedef
    318 EFI_STATUS
    319 (EFIAPI *EFI_FILE_OPEN) (
    320     IN struct _EFI_FILE_HANDLE  *File,
    321     OUT struct _EFI_FILE_HANDLE **NewHandle,
    322     IN CHAR16                   *FileName,
    323     IN UINT64                   OpenMode,
    324     IN UINT64                   Attributes
    325     );
    326 
    327 // Open modes
    328 #define EFI_FILE_MODE_READ      0x0000000000000001
    329 #define EFI_FILE_MODE_WRITE     0x0000000000000002
    330 #define EFI_FILE_MODE_CREATE    0x8000000000000000
    331 
    332 // File attributes
    333 #define EFI_FILE_READ_ONLY      0x0000000000000001
    334 #define EFI_FILE_HIDDEN         0x0000000000000002
    335 #define EFI_FILE_SYSTEM         0x0000000000000004
    336 #define EFI_FILE_RESERVIED      0x0000000000000008
    337 #define EFI_FILE_DIRECTORY      0x0000000000000010
    338 #define EFI_FILE_ARCHIVE        0x0000000000000020
    339 #define EFI_FILE_VALID_ATTR     0x0000000000000037
    340 
    341 typedef
    342 EFI_STATUS
    343 (EFIAPI *EFI_FILE_CLOSE) (
    344     IN struct _EFI_FILE_HANDLE  *File
    345     );
    346 
    347 typedef
    348 EFI_STATUS
    349 (EFIAPI *EFI_FILE_DELETE) (
    350     IN struct _EFI_FILE_HANDLE  *File
    351     );
    352 
    353 typedef
    354 EFI_STATUS
    355 (EFIAPI *EFI_FILE_READ) (
    356     IN struct _EFI_FILE_HANDLE  *File,
    357     IN OUT UINTN                *BufferSize,
    358     OUT VOID                    *Buffer
    359     );
    360 
    361 typedef
    362 EFI_STATUS
    363 (EFIAPI *EFI_FILE_WRITE) (
    364     IN struct _EFI_FILE_HANDLE  *File,
    365     IN OUT UINTN                *BufferSize,
    366     IN VOID                     *Buffer
    367     );
    368 
    369 typedef
    370 EFI_STATUS
    371 (EFIAPI *EFI_FILE_SET_POSITION) (
    372     IN struct _EFI_FILE_HANDLE  *File,
    373     IN UINT64                   Position
    374     );
    375 
    376 typedef
    377 EFI_STATUS
    378 (EFIAPI *EFI_FILE_GET_POSITION) (
    379     IN struct _EFI_FILE_HANDLE  *File,
    380     OUT UINT64                  *Position
    381     );
    382 
    383 typedef
    384 EFI_STATUS
    385 (EFIAPI *EFI_FILE_GET_INFO) (
    386     IN struct _EFI_FILE_HANDLE  *File,
    387     IN EFI_GUID                 *InformationType,
    388     IN OUT UINTN                *BufferSize,
    389     OUT VOID                    *Buffer
    390     );
    391 
    392 typedef
    393 EFI_STATUS
    394 (EFIAPI *EFI_FILE_SET_INFO) (
    395     IN struct _EFI_FILE_HANDLE  *File,
    396     IN EFI_GUID                 *InformationType,
    397     IN UINTN                    BufferSize,
    398     IN VOID                     *Buffer
    399     );
    400 
    401 typedef
    402 EFI_STATUS
    403 (EFIAPI *EFI_FILE_FLUSH) (
    404     IN struct _EFI_FILE_HANDLE  *File
    405     );
    406 
    407 typedef struct {
    408     EFI_EVENT       Event;
    409     EFI_STATUS      Status;
    410     UINTN           BufferSize;
    411     VOID            *Buffer;
    412 } EFI_FILE_IO_TOKEN;
    413 
    414 typedef
    415 EFI_STATUS
    416 (EFIAPI *EFI_FILE_OPEN_EX)(
    417     IN struct _EFI_FILE_HANDLE  *File,
    418     OUT struct _EFI_FILE_HANDLE **NewHandle,
    419     IN CHAR16                   *FileName,
    420     IN UINT64                   OpenMode,
    421     IN UINT64                   Attributes,
    422     IN OUT EFI_FILE_IO_TOKEN    *Token
    423     );
    424 
    425 typedef
    426 EFI_STATUS
    427 (EFIAPI *EFI_FILE_READ_EX) (
    428     IN struct _EFI_FILE_HANDLE  *File,
    429     IN OUT EFI_FILE_IO_TOKEN    *Token
    430     );
    431 
    432 typedef
    433 EFI_STATUS
    434 (EFIAPI *EFI_FILE_WRITE_EX) (
    435     IN struct _EFI_FILE_HANDLE  *File,
    436     IN OUT EFI_FILE_IO_TOKEN    *Token
    437     );
    438 
    439 typedef
    440 EFI_STATUS
    441 (EFIAPI *EFI_FILE_FLUSH_EX) (
    442     IN struct _EFI_FILE_HANDLE  *File,
    443     IN OUT EFI_FILE_IO_TOKEN    *Token
    444     );
    445 
    446 #define EFI_FILE_PROTOCOL_REVISION         0x00010000
    447 #define EFI_FILE_PROTOCOL_REVISION2        0x00020000
    448 #define EFI_FILE_PROTOCOL_LATEST_REVISION  EFI_FILE_PROTOCOL_REVISION2
    449 #define EFI_FILE_HANDLE_REVISION           EFI_FILE_PROTOCOL_REVISION
    450 
    451 typedef struct _EFI_FILE_HANDLE {
    452     UINT64                  Revision;
    453     EFI_FILE_OPEN           Open;
    454     EFI_FILE_CLOSE          Close;
    455     EFI_FILE_DELETE         Delete;
    456     EFI_FILE_READ           Read;
    457     EFI_FILE_WRITE          Write;
    458     EFI_FILE_GET_POSITION   GetPosition;
    459     EFI_FILE_SET_POSITION   SetPosition;
    460     EFI_FILE_GET_INFO       GetInfo;
    461     EFI_FILE_SET_INFO       SetInfo;
    462     EFI_FILE_FLUSH          Flush;
    463     EFI_FILE_OPEN_EX        OpenEx;
    464     EFI_FILE_READ_EX        ReadEx;
    465     EFI_FILE_WRITE_EX       WriteEx;
    466     EFI_FILE_FLUSH_EX       FlushEx;
    467 } EFI_FILE_PROTOCOL, *EFI_FILE_HANDLE;
    468 
    469 typedef EFI_FILE_PROTOCOL EFI_FILE;
    470 
    471 
    472 //
    473 // File information types
    474 //
    475 
    476 #define EFI_FILE_INFO_ID   \
    477     { 0x9576e92, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
    478 
    479 typedef struct {
    480     UINT64                  Size;
    481     UINT64                  FileSize;
    482     UINT64                  PhysicalSize;
    483     EFI_TIME                CreateTime;
    484     EFI_TIME                LastAccessTime;
    485     EFI_TIME                ModificationTime;
    486     UINT64                  Attribute;
    487     CHAR16                  FileName[1];
    488 } EFI_FILE_INFO;
    489 
    490 //
    491 // The FileName field of the EFI_FILE_INFO data structure is variable length.
    492 // Whenever code needs to know the size of the EFI_FILE_INFO data structure, it needs to
    493 // be the size of the data structure without the FileName field.  The following macro
    494 // computes this size correctly no matter how big the FileName array is declared.
    495 // This is required to make the EFI_FILE_INFO data structure ANSI compilant.
    496 //
    497 
    498 #define SIZE_OF_EFI_FILE_INFO EFI_FIELD_OFFSET(EFI_FILE_INFO,FileName)
    499 
    500 #define EFI_FILE_SYSTEM_INFO_ID    \
    501     { 0x9576e93, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
    502 
    503 typedef struct {
    504     UINT64                  Size;
    505     BOOLEAN                 ReadOnly;
    506     UINT64                  VolumeSize;
    507     UINT64                  FreeSpace;
    508     UINT32                  BlockSize;
    509     CHAR16                  VolumeLabel[1];
    510 } EFI_FILE_SYSTEM_INFO;
    511 
    512 //
    513 // The VolumeLabel field of the EFI_FILE_SYSTEM_INFO data structure is variable length.
    514 // Whenever code needs to know the size of the EFI_FILE_SYSTEM_INFO data structure, it needs
    515 // to be the size of the data structure without the VolumeLable field.  The following macro
    516 // computes this size correctly no matter how big the VolumeLable array is declared.
    517 // This is required to make the EFI_FILE_SYSTEM_INFO data structure ANSI compilant.
    518 //
    519 
    520 #define SIZE_OF_EFI_FILE_SYSTEM_INFO EFI_FIELD_OFFSET(EFI_FILE_SYSTEM_INFO,VolumeLabel)
    521 
    522 #define EFI_FILE_SYSTEM_VOLUME_LABEL_ID    \
    523     { 0xDB47D7D3,0xFE81, 0x11d3, {0x9A, 0x35, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D} }
    524 
    525 typedef struct {
    526     CHAR16                  VolumeLabel[1];
    527 } EFI_FILE_SYSTEM_VOLUME_LABEL;
    528 
    529 #define SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL_INFO EFI_FIELD_OFFSET(EFI_FILE_SYSTEM_VOLUME_LABEL,VolumeLabel)
    530 
    531 //
    532 // For compatibility with older versions of gnu-efi
    533 //
    534 #define EFI_FILE_SYSTEM_VOLUME_LABEL_INFO_ID EFI_FILE_SYSTEM_VOLUME_LABEL_ID
    535 #define EFI_FILE_SYSTEM_VOLUME_LABEL_INFO    EFI_FILE_SYSTEM_VOLUME_LABEL
    536 
    537 //
    538 // Load file protocol
    539 //
    540 
    541 
    542 #define EFI_LOAD_FILE_PROTOCOL_GUID \
    543     { 0x56EC3091, 0x954C, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B} }
    544 #define LOAD_FILE_PROTOCOL EFI_LOAD_FILE_PROTOCOL_GUID
    545 
    546 INTERFACE_DECL(_EFI_LOAD_FILE_PROTOCOL);
    547 
    548 typedef
    549 EFI_STATUS
    550 (EFIAPI *EFI_LOAD_FILE) (
    551     IN struct _EFI_LOAD_FILE_PROTOCOL  *This,
    552     IN EFI_DEVICE_PATH                  *FilePath,
    553     IN BOOLEAN                          BootPolicy,
    554     IN OUT UINTN                        *BufferSize,
    555     IN VOID                             *Buffer OPTIONAL
    556     );
    557 
    558 typedef struct _EFI_LOAD_FILE_PROTOCOL {
    559     EFI_LOAD_FILE                       LoadFile;
    560 } EFI_LOAD_FILE_PROTOCOL;
    561 
    562 typedef struct _EFI_LOAD_FILE_PROTOCOL _EFI_LOAD_FILE_INTERFACE;
    563 typedef EFI_LOAD_FILE_PROTOCOL EFI_LOAD_FILE_INTERFACE;
    564 
    565 //
    566 // Device IO protocol
    567 //
    568 
    569 #define EFI_DEVICE_IO_PROTOCOL_GUID \
    570     { 0xaf6ac311, 0x84c3, 0x11d2, {0x8e, 0x3c, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
    571 #define DEVICE_IO_PROTOCOL EFI_DEVICE_IO_PROTOCOL_GUID
    572 
    573 INTERFACE_DECL(_EFI_DEVICE_IO_PROTOCOL);
    574 
    575 typedef enum {
    576     IO_UINT8,
    577     IO_UINT16,
    578     IO_UINT32,
    579     IO_UINT64,
    580 //
    581 // Specification Change: Copy from MMIO to MMIO vs. MMIO to buffer, buffer to MMIO
    582 //
    583     MMIO_COPY_UINT8,
    584     MMIO_COPY_UINT16,
    585     MMIO_COPY_UINT32,
    586     MMIO_COPY_UINT64
    587 } EFI_IO_WIDTH;
    588 
    589 #define EFI_PCI_ADDRESS(_bus,_dev,_func) \
    590     ( (UINT64) ( (((UINTN)_bus) << 24) + (((UINTN)_dev) << 16) + (((UINTN)_func) << 8) ) )
    591 
    592 
    593 typedef
    594 EFI_STATUS
    595 (EFIAPI *EFI_DEVICE_IO) (
    596     IN struct _EFI_DEVICE_IO_PROTOCOL *This,
    597     IN EFI_IO_WIDTH                 Width,
    598     IN UINT64                       Address,
    599     IN UINTN                        Count,
    600     IN OUT VOID                     *Buffer
    601     );
    602 
    603 typedef struct {
    604     EFI_DEVICE_IO                   Read;
    605     EFI_DEVICE_IO                   Write;
    606 } EFI_IO_ACCESS;
    607 
    608 typedef
    609 EFI_STATUS
    610 (EFIAPI *EFI_PCI_DEVICE_PATH) (
    611     IN struct _EFI_DEVICE_IO_PROTOCOL   *This,
    612     IN UINT64                           Address,
    613     IN OUT EFI_DEVICE_PATH              **PciDevicePath
    614     );
    615 
    616 typedef enum {
    617     EfiBusMasterRead,
    618     EfiBusMasterWrite,
    619     EfiBusMasterCommonBuffer
    620 } EFI_IO_OPERATION_TYPE;
    621 
    622 typedef
    623 EFI_STATUS
    624 (EFIAPI *EFI_IO_MAP) (
    625     IN struct _EFI_DEVICE_IO_PROTOCOL   *This,
    626     IN EFI_IO_OPERATION_TYPE            Operation,
    627     IN EFI_PHYSICAL_ADDRESS             *HostAddress,
    628     IN OUT UINTN                        *NumberOfBytes,
    629     OUT EFI_PHYSICAL_ADDRESS            *DeviceAddress,
    630     OUT VOID                            **Mapping
    631     );
    632 
    633 typedef
    634 EFI_STATUS
    635 (EFIAPI *EFI_IO_UNMAP) (
    636     IN struct _EFI_DEVICE_IO_PROTOCOL   *This,
    637     IN VOID                             *Mapping
    638     );
    639 
    640 typedef
    641 EFI_STATUS
    642 (EFIAPI *EFI_IO_ALLOCATE_BUFFER) (
    643     IN struct _EFI_DEVICE_IO_PROTOCOL   *This,
    644     IN EFI_ALLOCATE_TYPE                Type,
    645     IN EFI_MEMORY_TYPE                  MemoryType,
    646     IN UINTN                            Pages,
    647     IN OUT EFI_PHYSICAL_ADDRESS         *HostAddress
    648     );
    649 
    650 typedef
    651 EFI_STATUS
    652 (EFIAPI *EFI_IO_FLUSH) (
    653     IN struct _EFI_DEVICE_IO_PROTOCOL   *This
    654     );
    655 
    656 typedef
    657 EFI_STATUS
    658 (EFIAPI *EFI_IO_FREE_BUFFER) (
    659     IN struct _EFI_DEVICE_IO_PROTOCOL   *This,
    660     IN UINTN                            Pages,
    661     IN EFI_PHYSICAL_ADDRESS             HostAddress
    662     );
    663 
    664 typedef struct _EFI_DEVICE_IO_PROTOCOL {
    665     EFI_IO_ACCESS                       Mem;
    666     EFI_IO_ACCESS                       Io;
    667     EFI_IO_ACCESS                       Pci;
    668     EFI_IO_MAP                          Map;
    669     EFI_PCI_DEVICE_PATH                 PciDevicePath;
    670     EFI_IO_UNMAP                        Unmap;
    671     EFI_IO_ALLOCATE_BUFFER              AllocateBuffer;
    672     EFI_IO_FLUSH                        Flush;
    673     EFI_IO_FREE_BUFFER                  FreeBuffer;
    674 } EFI_DEVICE_IO_PROTOCOL;
    675 
    676 typedef struct _EFI_DEVICE_IO_PROTOCOL _EFI_DEVICE_IO_INTERFACE;
    677 typedef EFI_DEVICE_IO_PROTOCOL EFI_DEVICE_IO_INTERFACE;
    678 
    679 //
    680 // Unicode Collation protocol
    681 //
    682 
    683 #define EFI_UNICODE_COLLATION_PROTOCOL_GUID \
    684     { 0x1d85cd7f, 0xf43d, 0x11d2, {0x9a, 0xc,  0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
    685 #define UNICODE_COLLATION_PROTOCOL EFI_UNICODE_COLLATION_PROTOCOL_GUID
    686 
    687 #define EFI_UNICODE_BYTE_ORDER_MARK       (CHAR16)(0xfeff)
    688 #define UNICODE_BYTE_ORDER_MARK EFI_UNICODE_BYTE_ORDER_MARK
    689 
    690 INTERFACE_DECL(_EFI_UNICODE_COLLATION_PROTOCOL);
    691 
    692 typedef
    693 INTN
    694 (EFIAPI *EFI_UNICODE_STRICOLL) (
    695     IN struct _EFI_UNICODE_COLLATION_PROTOCOL  *This,
    696     IN CHAR16                         *s1,
    697     IN CHAR16                         *s2
    698     );
    699 
    700 typedef
    701 BOOLEAN
    702 (EFIAPI *EFI_UNICODE_METAIMATCH) (
    703     IN struct _EFI_UNICODE_COLLATION_PROTOCOL  *This,
    704     IN CHAR16                         *String,
    705     IN CHAR16                         *Pattern
    706     );
    707 
    708 typedef
    709 VOID
    710 (EFIAPI *EFI_UNICODE_STRLWR) (
    711     IN struct _EFI_UNICODE_COLLATION_PROTOCOL  *This,
    712     IN OUT CHAR16                       *Str
    713     );
    714 
    715 typedef
    716 VOID
    717 (EFIAPI *EFI_UNICODE_STRUPR) (
    718     IN struct _EFI_UNICODE_COLLATION_PROTOCOL  *This,
    719     IN OUT CHAR16                       *Str
    720     );
    721 
    722 typedef
    723 VOID
    724 (EFIAPI *EFI_UNICODE_FATTOSTR) (
    725     IN struct _EFI_UNICODE_COLLATION_PROTOCOL  *This,
    726     IN UINTN                            FatSize,
    727     IN CHAR8                            *Fat,
    728     OUT CHAR16                          *String
    729     );
    730 
    731 typedef
    732 BOOLEAN
    733 (EFIAPI *EFI_UNICODE_STRTOFAT) (
    734     IN struct _EFI_UNICODE_COLLATION_PROTOCOL  *This,
    735     IN CHAR16                           *String,
    736     IN UINTN                            FatSize,
    737     OUT CHAR8                           *Fat
    738     );
    739 
    740 //
    741 // Hash Protocol
    742 //
    743 #define EFI_HASH_PROTOCOL_GUID \
    744   { 0xC5184932, 0xDBA5, 0x46DB, { 0xA5, 0xBA, 0xCC, 0x0B, 0xDA, 0x9C, 0x14, 0x35 } }
    745 #define HASH_PROTOCOL EFI_HASH_PROTOCOL_GUID
    746 
    747 #define EFI_HASH_ALGORITHM_SHA1_GUID \
    748   { 0x2AE9D80F, 0x3FB2, 0x4095, { 0xB7, 0xB1, 0xE9, 0x31, 0x57, 0xB9, 0x46, 0xB6 } } // Deprecated
    749 #define EFI_HASH_ALGORITHM_SHA1 EFI_HASH_ALGORITHM_SHA1_GUID
    750 
    751 #define EFI_HASH_ALGORITHM_SHA224_GUID \
    752   { 0x8DF01A06, 0x9BD5, 0x4BF7, { 0xB0, 0x21, 0xDB, 0x4F, 0xD9, 0xCC, 0xF4, 0x5B } } // Deprecated
    753 #define EFI_HASH_ALGORITHM_SHA224 EFI_HASH_ALGORITHM_SHA224_GUID
    754 
    755 #define EFI_HASH_ALGORITHM_SHA256_GUID \
    756   { 0x51AA59DE, 0xFDF2, 0x4EA3, { 0xBC, 0x63, 0x87, 0x5F, 0xB7, 0x84, 0x2E, 0xE9 } } // Deprecated
    757 #define EFI_HASH_ALGORITHM_SHA256 EFI_HASH_ALGORITHM_SHA256_GUID
    758 
    759 #define EFI_HASH_ALGORITHM_SHA384_GUID \
    760   { 0xEFA96432, 0xDE33, 0x4DD2, { 0xAE, 0xE6, 0x32, 0x8C, 0x33, 0xDF, 0x77, 0x7A } } // Deprecated
    761 #define EFI_HASH_ALGORITHM_SHA384 EFI_HASH_ALGORITHM_SHA384_GUID
    762 
    763 #define EFI_HASH_ALGORITHM_SHA512_GUID \
    764   { 0xCAA4381E, 0x750C, 0x4770, { 0xB8, 0x70, 0x7A, 0x23, 0xB4, 0xE4, 0x21, 0x30 } } // Deprecated
    765 #define EFI_HASH_ALGORITHM_SHA512 EFI_HASH_ALGORITHM_SHA512_GUID
    766 
    767 #define EFI_HASH_ALGORITHM_MD5_GUID \
    768   { 0x0AF7C79C, 0x65B5, 0x4319, { 0xB0, 0xAE, 0x44, 0xEC, 0x48, 0x4E, 0x4A, 0xD7 } } // Deprecated
    769 #define EFI_HASH_ALGORITHM_MD5 EFI_HASH_ALGORITHM_MD5_GUID
    770 
    771 #define EFI_HASH_ALGORITHM_SHA1_NOPAD_GUID \
    772   { 0x24C5DC2F, 0x53E2, 0x40CA, { 0x9E, 0xD6, 0xA5, 0xD9, 0xA4, 0x9F, 0x46, 0x3B } }
    773 #define EFI_HASH_ALGORITHM_SHA1_NOPAD EFI_HASH_ALGORITHM_SHA1_NOPAD_GUID
    774 
    775 #define EFI_HASH_ALGORITHM_SHA256_NOPAD_GUID \
    776   { 0x8628752A, 0x6CB7, 0x4814, { 0x96, 0xFC, 0x24, 0xA8, 0x15, 0xAC, 0x22, 0x26 } }
    777 #define EFI_HASH_ALGORITHM_SHA256_NOPAD EFI_HASH_ALGORITHM_SHA256_NOPAD_GUID
    778 
    779 
    780 INTERFACE_DECL(_EFI_HASH_PROTOCOL);
    781 
    782 typedef UINT8 EFI_MD5_HASH[16];
    783 typedef UINT8 EFI_SHA1_HASH[20];
    784 typedef UINT8 EFI_SHA224_HASH[28];
    785 typedef UINT8 EFI_SHA256_HASH[32];
    786 typedef UINT8 EFI_SHA384_HASH[48];
    787 typedef UINT8 EFI_SHA512_HASH[64];
    788 typedef union _EFI_HASH_OUTPUT {
    789   EFI_MD5_HASH                    *Md5Hash;
    790   EFI_SHA1_HASH                   *Sha1Hash;
    791   EFI_SHA224_HASH                 *Sha224Hash;
    792   EFI_SHA256_HASH                 *Sha256Hash;
    793   EFI_SHA384_HASH                 *Sha384Hash;
    794   EFI_SHA512_HASH                 *Sha512Hash;
    795 } EFI_HASH_OUTPUT;
    796 
    797 typedef
    798 EFI_STATUS
    799 (EFIAPI *EFI_HASH_GET_HASH_SIZE) (
    800   IN CONST struct _EFI_HASH_PROTOCOL  *This,
    801   IN CONST EFI_GUID               *HashAlgorithm,
    802   OUT UINTN                       *HashSize);
    803 
    804 typedef
    805 EFI_STATUS
    806 (EFIAPI *EFI_HASH_HASH) (
    807   IN CONST struct _EFI_HASH_PROTOCOL  *This,
    808   IN CONST EFI_GUID               *HashAlgorithm,
    809   IN BOOLEAN                      Extend,
    810   IN CONST UINT8                  *Message,
    811   IN UINT64                       MessageSize,
    812   IN OUT EFI_HASH_OUTPUT          *Hash);
    813 
    814 typedef struct _EFI_HASH_PROTOCOL {
    815   EFI_HASH_GET_HASH_SIZE                  GetHashSize;
    816   EFI_HASH_HASH                           Hash;
    817 } EFI_HASH_PROTOCOL;
    818 
    819 typedef struct _EFI_HASH_PROTOCOL _EFI_HASH;
    820 typedef EFI_HASH_PROTOCOL EFI_HASH;
    821 
    822 
    823 typedef struct _EFI_UNICODE_COLLATION_PROTOCOL {
    824 
    825     // general
    826     EFI_UNICODE_STRICOLL                StriColl;
    827     EFI_UNICODE_METAIMATCH              MetaiMatch;
    828     EFI_UNICODE_STRLWR                  StrLwr;
    829     EFI_UNICODE_STRUPR                  StrUpr;
    830 
    831     // for supporting fat volumes
    832     EFI_UNICODE_FATTOSTR                FatToStr;
    833     EFI_UNICODE_STRTOFAT                StrToFat;
    834 
    835     CHAR8                               *SupportedLanguages;
    836 } EFI_UNICODE_COLLATION_PROTOCOL;
    837 
    838 typedef EFI_UNICODE_COLLATION_PROTOCOL EFI_UNICODE_COLLATION_INTERFACE;
    839 
    840 /* Graphics output protocol */
    841 #define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID \
    842    { 0x9042a9de, 0x23dc, 0x4a38, {0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a } }
    843 typedef struct _EFI_GRAPHICS_OUTPUT_PROTOCOL EFI_GRAPHICS_OUTPUT_PROTOCOL;
    844 
    845 typedef struct {
    846   UINT32            RedMask;
    847   UINT32            GreenMask;
    848   UINT32            BlueMask;
    849   UINT32            ReservedMask;
    850 } EFI_PIXEL_BITMASK;
    851 
    852 typedef enum {
    853   PixelRedGreenBlueReserved8BitPerColor,
    854   PixelBlueGreenRedReserved8BitPerColor,
    855   PixelBitMask,
    856   PixelBltOnly,
    857   PixelFormatMax
    858 } EFI_GRAPHICS_PIXEL_FORMAT;
    859 
    860 typedef struct {
    861   UINT32                     Version;
    862   UINT32                     HorizontalResolution;
    863   UINT32                     VerticalResolution;
    864   EFI_GRAPHICS_PIXEL_FORMAT  PixelFormat;
    865   EFI_PIXEL_BITMASK          PixelInformation;
    866   UINT32                     PixelsPerScanLine;
    867 } EFI_GRAPHICS_OUTPUT_MODE_INFORMATION;
    868 
    869 /**
    870   Return the current video mode information.
    871 
    872   @param  This       Protocol instance pointer.
    873   @param  ModeNumber The mode number to return information on.
    874   @param  SizeOfInfo A pointer to the size, in bytes, of the Info buffer.
    875   @param  Info       A pointer to callee allocated buffer that returns information about ModeNumber.
    876 
    877   @retval EFI_SUCCESS           Mode information returned.
    878   @retval EFI_BUFFER_TOO_SMALL  The Info buffer was too small.
    879   @retval EFI_DEVICE_ERROR      A hardware error occurred trying to retrieve the video mode.
    880   @retval EFI_NOT_STARTED       Video display is not initialized. Call SetMode ()
    881   @retval EFI_INVALID_PARAMETER One of the input args was NULL.
    882 
    883 **/
    884 typedef
    885 EFI_STATUS
    886 (EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_QUERY_MODE) (
    887   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,
    888   IN  UINT32                                ModeNumber,
    889   OUT UINTN                                 *SizeOfInfo,
    890   OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info
    891   )
    892 ;
    893 
    894 /**
    895   Return the current video mode information.
    896 
    897   @param  This              Protocol instance pointer.
    898   @param  ModeNumber        The mode number to be set.
    899 
    900   @retval EFI_SUCCESS       Graphics mode was changed.
    901   @retval EFI_DEVICE_ERROR  The device had an error and could not complete the request.
    902   @retval EFI_UNSUPPORTED   ModeNumber is not supported by this device.
    903 
    904 **/
    905 typedef
    906 EFI_STATUS
    907 (EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_SET_MODE) (
    908   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
    909   IN  UINT32                       ModeNumber
    910   );
    911 
    912 typedef struct {
    913   UINT8 Blue;
    914   UINT8 Green;
    915   UINT8 Red;
    916   UINT8 Reserved;
    917 } EFI_GRAPHICS_OUTPUT_BLT_PIXEL;
    918 
    919 typedef union {
    920   EFI_GRAPHICS_OUTPUT_BLT_PIXEL Pixel;
    921   UINT32                        Raw;
    922 } EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION;
    923 
    924 typedef enum {
    925   EfiBltVideoFill,
    926   EfiBltVideoToBltBuffer,
    927   EfiBltBufferToVideo,
    928   EfiBltVideoToVideo,
    929   EfiGraphicsOutputBltOperationMax
    930 } EFI_GRAPHICS_OUTPUT_BLT_OPERATION;
    931 
    932 /**
    933   The following table defines actions for BltOperations:
    934 
    935   <B>EfiBltVideoFill</B> - Write data from the  BltBuffer pixel (SourceX, SourceY)
    936   directly to every pixel of the video display rectangle
    937   (DestinationX, DestinationY) (DestinationX + Width, DestinationY + Height).
    938   Only one pixel will be used from the BltBuffer. Delta is NOT used.
    939 
    940   <B>EfiBltVideoToBltBuffer</B> - Read data from the video display rectangle
    941   (SourceX, SourceY) (SourceX + Width, SourceY + Height) and place it in
    942   the BltBuffer rectangle (DestinationX, DestinationY )
    943   (DestinationX + Width, DestinationY + Height). If DestinationX or
    944   DestinationY is not zero then Delta must be set to the length in bytes
    945   of a row in the BltBuffer.
    946 
    947   <B>EfiBltBufferToVideo</B> - Write data from the  BltBuffer rectangle
    948   (SourceX, SourceY) (SourceX + Width, SourceY + Height) directly to the
    949   video display rectangle (DestinationX, DestinationY)
    950   (DestinationX + Width, DestinationY + Height). If SourceX or SourceY is
    951   not zero then Delta must be set to the length in bytes of a row in the
    952   BltBuffer.
    953 
    954   <B>EfiBltVideoToVideo</B> - Copy from the video display rectangle (SourceX, SourceY)
    955   (SourceX + Width, SourceY + Height) .to the video display rectangle
    956   (DestinationX, DestinationY) (DestinationX + Width, DestinationY + Height).
    957   The BltBuffer and Delta  are not used in this mode.
    958 
    959   @param  This         Protocol instance pointer.
    960   @param  BltBuffer    Buffer containing data to blit into video buffer. This
    961                        buffer has a size of Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
    962   @param  BltOperation Operation to perform on BlitBuffer and video memory
    963   @param  SourceX      X coordinate of source for the BltBuffer.
    964   @param  SourceY      Y coordinate of source for the BltBuffer.
    965   @param  DestinationX X coordinate of destination for the BltBuffer.
    966   @param  DestinationY Y coordinate of destination for the BltBuffer.
    967   @param  Width        Width of rectangle in BltBuffer in pixels.
    968   @param  Height       Hight of rectangle in BltBuffer in pixels.
    969   @param  Delta        OPTIONAL
    970 
    971   @retval EFI_SUCCESS           The Blt operation completed.
    972   @retval EFI_INVALID_PARAMETER BltOperation is not valid.
    973   @retval EFI_DEVICE_ERROR      A hardware error occured writting to the video buffer.
    974 
    975 **/
    976 typedef
    977 EFI_STATUS
    978 (EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_BLT) (
    979   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL            *This,
    980   IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL           *BltBuffer,   OPTIONAL
    981   IN  EFI_GRAPHICS_OUTPUT_BLT_OPERATION       BltOperation,
    982   IN  UINTN                                   SourceX,
    983   IN  UINTN                                   SourceY,
    984   IN  UINTN                                   DestinationX,
    985   IN  UINTN                                   DestinationY,
    986   IN  UINTN                                   Width,
    987   IN  UINTN                                   Height,
    988   IN  UINTN                                   Delta         OPTIONAL
    989   );
    990 
    991 typedef struct {
    992   UINT32                                 MaxMode;
    993   UINT32                                 Mode;
    994   EFI_GRAPHICS_OUTPUT_MODE_INFORMATION   *Info;
    995   UINTN                                  SizeOfInfo;
    996   EFI_PHYSICAL_ADDRESS                   FrameBufferBase;
    997   UINTN                                  FrameBufferSize;
    998 } EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE;
    999 
   1000 struct _EFI_GRAPHICS_OUTPUT_PROTOCOL {
   1001   EFI_GRAPHICS_OUTPUT_PROTOCOL_QUERY_MODE  QueryMode;
   1002   EFI_GRAPHICS_OUTPUT_PROTOCOL_SET_MODE    SetMode;
   1003   EFI_GRAPHICS_OUTPUT_PROTOCOL_BLT         Blt;
   1004   EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE        *Mode;
   1005 };
   1006 
   1007 
   1008 
   1009 /*
   1010  * EFI EDID Discovered Protocol
   1011  * UEFI Specification Version 2.5 Section 11.9
   1012  */
   1013 #define EFI_EDID_DISCOVERED_PROTOCOL_GUID \
   1014     { 0x1C0C34F6, 0xD380, 0x41FA, { 0xA0, 0x49, 0x8a, 0xD0, 0x6C, 0x1A, 0x66, 0xAA} }
   1015 
   1016 typedef struct _EFI_EDID_DISCOVERED_PROTOCOL {
   1017     UINT32   SizeOfEdid;
   1018     UINT8   *Edid;
   1019 } EFI_EDID_DISCOVERED_PROTOCOL;
   1020 
   1021 
   1022 
   1023 /*
   1024  * EFI EDID Active Protocol
   1025  * UEFI Specification Version 2.5 Section 11.9
   1026  */
   1027 #define EFI_EDID_ACTIVE_PROTOCOL_GUID \
   1028     { 0xBD8C1056, 0x9F36, 0x44EC, { 0x92, 0xA8, 0xA6, 0x33, 0x7F, 0x81, 0x79, 0x86} }
   1029 
   1030 typedef struct _EFI_EDID_ACTIVE_PROTOCOL {
   1031     UINT32   SizeOfEdid;
   1032     UINT8   *Edid;
   1033 } EFI_EDID_ACTIVE_PROTOCOL;
   1034 
   1035 
   1036 
   1037 /*
   1038  * EFI EDID Override Protocol
   1039  * UEFI Specification Version 2.5 Section 11.9
   1040  */
   1041 #define EFI_EDID_OVERRIDE_PROTOCOL_GUID \
   1042     { 0x48ECB431, 0xFB72, 0x45C0, { 0xA9, 0x22, 0xF4, 0x58, 0xFE, 0x04, 0x0B, 0xD5} }
   1043 
   1044 INTERFACE_DECL(_EFI_EDID_OVERRIDE_PROTOCOL);
   1045 
   1046 typedef
   1047 EFI_STATUS
   1048 (EFIAPI *EFI_EDID_OVERRIDE_PROTOCOL_GET_EDID) (
   1049   IN      struct _EFI_EDID_OVERRIDE_PROTOCOL   *This,
   1050   IN      EFI_HANDLE                           *ChildHandle,
   1051   OUT     UINT32                               *Attributes,
   1052   IN OUT  UINTN                                *EdidSize,
   1053   IN OUT  UINT8                               **Edid);
   1054 
   1055 typedef struct _EFI_EDID_OVERRIDE_PROTOCOL {
   1056     EFI_EDID_OVERRIDE_PROTOCOL_GET_EDID  GetEdid;
   1057 } EFI_EDID_OVERRIDE_PROTOCOL;
   1058 
   1059 
   1060 
   1061 INTERFACE_DECL(_EFI_SERVICE_BINDING);
   1062 
   1063 typedef
   1064 EFI_STATUS
   1065 (EFIAPI *EFI_SERVICE_BINDING_CREATE_CHILD) (
   1066     IN struct _EFI_SERVICE_BINDING *This,
   1067     IN EFI_HANDLE                  *ChildHandle
   1068     );
   1069 
   1070 typedef
   1071 EFI_STATUS
   1072 (EFIAPI *EFI_SERVICE_BINDING_DESTROY_CHILD) (
   1073     IN struct _EFI_SERVICE_BINDING *This,
   1074     IN EFI_HANDLE                  ChildHandle
   1075     );
   1076 
   1077 typedef struct _EFI_SERVICE_BINDING {
   1078     EFI_SERVICE_BINDING_CREATE_CHILD  CreateChild;
   1079     EFI_SERVICE_BINDING_DESTROY_CHILD DestroyChild;
   1080 } EFI_SERVICE_BINDING;
   1081 
   1082 
   1083 
   1084 /*
   1085  * EFI Driver Binding Protocol
   1086  * UEFI Specification Version 2.5 Section 10.1
   1087  */
   1088 #define EFI_DRIVER_BINDING_PROTOCOL_GUID \
   1089     { 0x18A031AB, 0xB443, 0x4D1A, { 0xA5, 0xC0, 0x0C, 0x09, 0x26, 0x1E, 0x9F, 0x71} }
   1090 #define DRIVER_BINDING_PROTOCOL EFI_DRIVER_BINDING_PROTOCOL_GUID
   1091 
   1092 INTERFACE_DECL(_EFI_DRIVER_BINDING_PROTOCOL);
   1093 
   1094 typedef
   1095 EFI_STATUS
   1096 (EFIAPI *EFI_DRIVER_BINDING_PROTOCOL_SUPPORTED) (
   1097   IN      struct _EFI_DRIVER_BINDING_PROTOCOL *This,
   1098   IN      EFI_HANDLE                          ControllerHandle,
   1099   IN      EFI_DEVICE_PATH                     *RemainingDevicePath OPTIONAL);
   1100 
   1101 typedef
   1102 EFI_STATUS
   1103 (EFIAPI *EFI_DRIVER_BINDING_PROTOCOL_START) (
   1104   IN      struct _EFI_DRIVER_BINDING_PROTOCOL *This,
   1105   IN      EFI_HANDLE                          ControllerHandle,
   1106   IN      EFI_DEVICE_PATH                     *RemainingDevicePath OPTIONAL);
   1107 
   1108 typedef
   1109 EFI_STATUS
   1110 (EFIAPI *EFI_DRIVER_BINDING_PROTOCOL_STOP) (
   1111   IN      struct _EFI_DRIVER_BINDING_PROTOCOL *This,
   1112   IN      EFI_HANDLE                          ControllerHandle,
   1113   IN      UINTN                               NumberOfChildren,
   1114   IN      EFI_HANDLE                          *ChildHandleBuffer OPTIONAL);
   1115 
   1116 typedef struct _EFI_DRIVER_BINDING_PROTOCOL {
   1117   EFI_DRIVER_BINDING_PROTOCOL_SUPPORTED       Supported;
   1118   EFI_DRIVER_BINDING_PROTOCOL_START           Start;
   1119   EFI_DRIVER_BINDING_PROTOCOL_STOP            Stop;
   1120   UINT32                                      Version;
   1121   EFI_HANDLE                                  ImageHandle;
   1122   EFI_HANDLE                                  DriverBindingHandle;
   1123 } EFI_DRIVER_BINDING_PROTOCOL;
   1124 
   1125 typedef struct _EFI_DRIVER_BINDING_PROTOCOL _EFI_DRIVER_BINDING;
   1126 typedef EFI_DRIVER_BINDING_PROTOCOL EFI_DRIVER_BINDING;
   1127 
   1128 
   1129 /*
   1130  * Backwards compatibility with older GNU-EFI versions. Deprecated.
   1131  */
   1132 #define EFI_DRIVER_SUPPORTED         EFI_DRIVER_BINDING_PROTOCOL_SUPPORTED
   1133 #define EFI_DRIVER_START             EFI_DRIVER_BINDING_PROTOCOL_START
   1134 #define EFI_DRIVER_STOP              EFI_DRIVER_BINDING_PROTOCOL_STOP
   1135 
   1136 
   1137 
   1138 /*
   1139  * EFI Component Name Protocol
   1140  * Deprecated - use EFI Component Name 2 Protocol instead
   1141  */
   1142 #define EFI_COMPONENT_NAME_PROTOCOL_GUID \
   1143     {0x107A772C, 0xD5E1, 0x11D4, { 0x9A, 0x46, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D} }
   1144 #define COMPONENT_NAME_PROTOCOL EFI_COMPONENT_NAME_PROTOCOL_GUID
   1145 
   1146 INTERFACE_DECL(_EFI_COMPONENT_NAME_PROTOCOL);
   1147 
   1148 typedef
   1149 EFI_STATUS
   1150 (EFIAPI *EFI_COMPONENT_NAME_GET_DRIVER_NAME) (
   1151   IN      struct _EFI_COMPONENT_NAME_PROTOCOL   *This,
   1152   IN      CHAR8                                 *Language,
   1153   OUT     CHAR16                                **DriverName);
   1154 
   1155 typedef
   1156 EFI_STATUS
   1157 (EFIAPI *EFI_COMPONENT_NAME_GET_CONTROLLER_NAME) (
   1158   IN      struct _EFI_COMPONENT_NAME_PROTOCOL   *This,
   1159   IN      EFI_HANDLE                            ControllerHandle,
   1160   IN      EFI_HANDLE                            ChildHandle OPTIONAL,
   1161   IN      CHAR8                                 *Language,
   1162   OUT     CHAR16                                **ControllerName);
   1163 
   1164 typedef struct _EFI_COMPONENT_NAME_PROTOCOL {
   1165   EFI_COMPONENT_NAME_GET_DRIVER_NAME      GetDriverName;
   1166   EFI_COMPONENT_NAME_GET_CONTROLLER_NAME  GetControllerName;
   1167   CHAR8                                   *SupportedLanguages;
   1168 } EFI_COMPONENT_NAME_PROTOCOL;
   1169 
   1170 typedef struct _EFI_COMPONENT_NAME_PROTOCOL _EFI_COMPONENT_NAME;
   1171 typedef EFI_COMPONENT_NAME_PROTOCOL EFI_COMPONENT_NAME;
   1172 
   1173 
   1174 /*
   1175  * EFI Component Name 2 Protocol
   1176  * UEFI Specification Version 2.5 Section 10.5
   1177  */
   1178 #define EFI_COMPONENT_NAME2_PROTOCOL_GUID \
   1179     {0x6A7A5CFF, 0xE8D9, 0x4F70, { 0xBA, 0xDA, 0x75, 0xAB, 0x30, 0x25, 0xCE, 0x14} }
   1180 #define COMPONENT_NAME2_PROTOCOL EFI_COMPONENT_NAME2_PROTOCOL_GUID
   1181 
   1182 INTERFACE_DECL(_EFI_COMPONENT_NAME2_PROTOCOL);
   1183 
   1184 typedef
   1185 EFI_STATUS
   1186 (EFIAPI *EFI_COMPONENT_NAME2_GET_DRIVER_NAME) (
   1187   IN      struct _EFI_COMPONENT_NAME2_PROTOCOL   *This,
   1188   IN      CHAR8                                  *Language,
   1189   OUT     CHAR16                                 **DriverName);
   1190 
   1191 typedef
   1192 EFI_STATUS
   1193 (EFIAPI *EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) (
   1194   IN      struct _EFI_COMPONENT_NAME2_PROTOCOL   *This,
   1195   IN      EFI_HANDLE                             ControllerHandle,
   1196   IN      EFI_HANDLE                             ChildHandle OPTIONAL,
   1197   IN      CHAR8                                  *Language,
   1198   OUT     CHAR16                                 **ControllerName);
   1199 
   1200 typedef struct _EFI_COMPONENT_NAME2_PROTOCOL {
   1201   EFI_COMPONENT_NAME2_GET_DRIVER_NAME       GetDriverName;
   1202   EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME   GetControllerName;
   1203   CHAR8                                     *SupportedLanguages;
   1204 } EFI_COMPONENT_NAME2_PROTOCOL;
   1205 
   1206 typedef struct _EFI_COMPONENT_NAME2_PROTOCOL _EFI_COMPONENT_NAME2;
   1207 typedef EFI_COMPONENT_NAME2_PROTOCOL EFI_COMPONENT_NAME2;
   1208 
   1209 
   1210 
   1211 /*
   1212  * EFI Loaded Image Protocol
   1213  * UEFI Specification Version 2.5 Section 8.1
   1214  */
   1215 #define EFI_LOADED_IMAGE_PROTOCOL_GUID \
   1216     { 0x5B1B31A1, 0x9562, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B} }
   1217 #define LOADED_IMAGE_PROTOCOL EFI_LOADED_IMAGE_PROTOCOL_GUID
   1218 
   1219 #define EFI_LOADED_IMAGE_PROTOCOL_REVISION  0x1000
   1220 #define EFI_IMAGE_INFORMATION_REVISION  EFI_LOADED_IMAGE_PROTOCOL_REVISION
   1221 
   1222 typedef
   1223 EFI_STATUS
   1224 (EFIAPI *EFI_IMAGE_UNLOAD) (
   1225     IN EFI_HANDLE                   ImageHandle
   1226     );
   1227 
   1228 typedef struct {
   1229     UINT32                          Revision;
   1230     EFI_HANDLE                      ParentHandle;
   1231     struct _EFI_SYSTEM_TABLE        *SystemTable;
   1232 
   1233     // Source location of image
   1234     EFI_HANDLE                      DeviceHandle;
   1235     EFI_DEVICE_PATH                 *FilePath;
   1236     VOID                            *Reserved;
   1237 
   1238     // Images load options
   1239     UINT32                          LoadOptionsSize;
   1240     VOID                            *LoadOptions;
   1241 
   1242     // Location of where image was loaded
   1243     VOID                            *ImageBase;
   1244     UINT64                          ImageSize;
   1245     EFI_MEMORY_TYPE                 ImageCodeType;
   1246     EFI_MEMORY_TYPE                 ImageDataType;
   1247 
   1248     // If the driver image supports a dynamic unload request
   1249     EFI_IMAGE_UNLOAD                Unload;
   1250 } EFI_LOADED_IMAGE_PROTOCOL;
   1251 
   1252 typedef EFI_LOADED_IMAGE_PROTOCOL EFI_LOADED_IMAGE;
   1253 
   1254 #define EFI_LOADED_IMAGE_DEVICE_PATH_PROTOCOL_GUID \
   1255     {0xbc62157e, 0x3e33, 0x4fec, {0x99, 0x20, 0x2d, 0x3b, 0x36, 0xd7, 0x50, 0xdf} }
   1256 
   1257 /*
   1258  * Random Number Generator Protocol
   1259  * UEFI Specification Version 2.5 Section 35.5
   1260  */
   1261 #define EFI_RNG_PROTOCOL_GUID                          \
   1262           { 0x3152bca5, 0xeade, 0x433d, {0x86, 0x2e, 0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44} }
   1263 
   1264 typedef EFI_GUID EFI_RNG_ALGORITHM;
   1265 
   1266 #define EFI_RNG_ALGORITHM_SP800_90_HASH_256_GUID       \
   1267      {0xa7af67cb, 0x603b, 0x4d42, {0xba, 0x21, 0x70, 0xbf, 0xb6, 0x29, 0x3f, 0x96} }
   1268 
   1269 #define EFI_RNG_ALGORITHM_SP800_90_HMAC_256_GUID       \
   1270      {0xc5149b43, 0xae85, 0x4f53, {0x99, 0x82, 0xb9, 0x43, 0x35, 0xd3, 0xa9, 0xe7} }
   1271 
   1272 #define EFI_RNG_ALGORITHM_SP800_90_CTR_256_GUID        \
   1273      {0x44f0de6e, 0x4d8c, 0x4045, {0xa8, 0xc7, 0x4d, 0xd1, 0x68, 0x85, 0x6b, 0x9e} }
   1274 
   1275 #define EFI_RNG_ALGORITHM_X9_31_3DES_GUID              \
   1276      {0x63c4785a, 0xca34, 0x4012, {0xa3, 0xc8, 0x0b, 0x6a, 0x32, 0x4f, 0x55, 0x46} }
   1277 
   1278 #define EFI_RNG_ALGORITHM_X9_31_AES_GUID               \
   1279      {0xacd03321, 0x777e, 0x4d3d, {0xb1, 0xc8, 0x20, 0xcf, 0xd8, 0x88, 0x20, 0xc9} }
   1280 
   1281 #define EFI_RNG_ALGORITHM_RAW                          \
   1282      {0xe43176d7, 0xb6e8, 0x4827, {0xb7, 0x84, 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61} }
   1283 
   1284 INTERFACE_DECL(_EFI_RNG_PROTOCOL);
   1285 
   1286 typedef
   1287 EFI_STATUS
   1288 (EFIAPI *EFI_RNG_GET_INFO) (
   1289   IN      struct _EFI_RNG_PROTOCOL   *This,
   1290   IN OUT  UINTN                      *RNGAlgorithmListSize,
   1291   OUT     EFI_RNG_ALGORITHM          *RNGAlgorithmList
   1292 );
   1293 
   1294 typedef
   1295 EFI_STATUS
   1296 (EFIAPI *EFI_RNG_GET_RNG) (
   1297   IN      struct _EFI_RNG_PROTOCOL   *This,
   1298   IN      EFI_RNG_ALGORITHM          *RNGAlgorithm,           OPTIONAL
   1299   IN      UINTN                      RNGValueLength,
   1300   OUT     UINT8                      *RNGValue
   1301 );
   1302 
   1303 typedef struct _EFI_RNG_PROTOCOL {
   1304           EFI_RNG_GET_INFO           GetInfo;
   1305           EFI_RNG_GET_RNG            GetRNG;
   1306 } EFI_RNG_PROTOCOL;
   1307 
   1308 
   1309 //
   1310 // EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL
   1311 //
   1312 
   1313 #define EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL_GUID          \
   1314           { 0x6b30c738, 0xa391, 0x11d4, {0x9a, 0x3b, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
   1315 
   1316 INTERFACE_DECL(_EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL);
   1317 
   1318 typedef
   1319 EFI_STATUS
   1320 (EFIAPI *EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER) (
   1321 IN      struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL  *This,
   1322 IN      EFI_HANDLE                                      ControllerHandle,
   1323 IN OUT  EFI_HANDLE                                     *DriverImageHandle);
   1324 
   1325 typedef
   1326 EFI_STATUS
   1327 (EFIAPI *EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER_PATH) (
   1328 IN      struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL  *This,
   1329 IN      EFI_HANDLE                                      ControllerHandle,
   1330 IN OUT  EFI_DEVICE_PATH                               **DriverImagePath);
   1331 
   1332 typedef
   1333 EFI_STATUS
   1334 (EFIAPI *EFI_PLATFORM_DRIVER_OVERRIDE_DRIVER_LOADED) (
   1335 IN      struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL  *This,
   1336 IN      EFI_HANDLE                                      ControllerHandle,
   1337 IN      EFI_DEVICE_PATH                                *DriverImagePath,
   1338 IN      EFI_HANDLE                                      DriverImageHandle);
   1339 
   1340 typedef struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL {
   1341   EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER       GetDriver;
   1342   EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER_PATH  GetDriverPath;
   1343   EFI_PLATFORM_DRIVER_OVERRIDE_DRIVER_LOADED    DriverLoaded;
   1344 } EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL;
   1345 
   1346 //
   1347 // EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL
   1348 //
   1349 
   1350 #define EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL_GUID          \
   1351           { 0x3bc1b285, 0x8a15, 0x4a82, {0xaa, 0xbf, 0x4d, 0x7d, 0x13, 0xfb, 0x32, 0x65} }
   1352 
   1353 INTERFACE_DECL(_EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL);
   1354 
   1355 typedef
   1356 EFI_STATUS
   1357 (EFIAPI *EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_GET_DRIVER) (
   1358 IN      struct _EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL  *This,
   1359 IN OUT  EFI_HANDLE                                         *DriverImageHandle);
   1360 
   1361 typedef struct _EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL {
   1362   EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_GET_DRIVER       GetDriver;
   1363 } EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL;
   1364 
   1365 //
   1366 // EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL
   1367 //
   1368 
   1369 #define EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL_GUID          \
   1370           { 0xb1ee129e, 0xda36, 0x4181, {0x91, 0xf8, 0x04, 0xa4, 0x92, 0x37, 0x66, 0xa7} }
   1371 
   1372 INTERFACE_DECL(_EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL);
   1373 
   1374 typedef
   1375 UINT32
   1376 (EFIAPI *EFI_DRIVER_FAMILY_OVERRIDE_GET_VERSION) (
   1377 IN      struct _EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL  *This);
   1378 
   1379 typedef struct _EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL {
   1380   EFI_DRIVER_FAMILY_OVERRIDE_GET_VERSION       GetVersion;
   1381 } EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL;
   1382 
   1383 //
   1384 // EFI_EBC_PROTOCOL
   1385 //
   1386 
   1387 #define EFI_EBC_INTERPRETER_PROTOCOL_GUID              \
   1388      {0x13ac6dd1, 0x73d0, 0x11d4, {0xb0, 0x6b, 0x00, 0xaa, 0x00, 0xbd, 0x6d, 0xe7} }
   1389 
   1390 #define EFI_EBC_PROTOCOL_GUID EFI_EBC_INTERPRETER_PROTOCOL_GUID
   1391 
   1392 INTERFACE_DECL(_EFI_EBC_PROTOCOL);
   1393 
   1394 typedef
   1395 EFI_STATUS
   1396 (EFIAPI *EFI_EBC_CREATE_THUNK)(
   1397   IN struct _EFI_EBC_PROTOCOL   *This,
   1398   IN EFI_HANDLE                 ImageHandle,
   1399   IN VOID                       *EbcEntryPoint,
   1400   OUT VOID                      **Thunk);
   1401 
   1402 typedef
   1403 EFI_STATUS
   1404 (EFIAPI *EFI_EBC_UNLOAD_IMAGE)(
   1405   IN struct _EFI_EBC_PROTOCOL   *This,
   1406   IN EFI_HANDLE                 ImageHandle);
   1407 
   1408 typedef
   1409 EFI_STATUS
   1410 (EFIAPI *EBC_ICACHE_FLUSH)(
   1411   IN EFI_PHYSICAL_ADDRESS       Start,
   1412   IN UINT64                     Length);
   1413 
   1414 typedef
   1415 EFI_STATUS
   1416 (EFIAPI *EFI_EBC_REGISTER_ICACHE_FLUSH)(
   1417   IN struct _EFI_EBC_PROTOCOL   *This,
   1418   IN EBC_ICACHE_FLUSH           Flush);
   1419 
   1420 typedef
   1421 EFI_STATUS
   1422 (EFIAPI *EFI_EBC_GET_VERSION)(
   1423   IN struct _EFI_EBC_PROTOCOL   *This,
   1424   IN OUT UINT64                 *Version);
   1425 
   1426 typedef struct _EFI_EBC_PROTOCOL {
   1427   EFI_EBC_CREATE_THUNK          CreateThunk;
   1428   EFI_EBC_UNLOAD_IMAGE          UnloadImage;
   1429   EFI_EBC_REGISTER_ICACHE_FLUSH RegisterICacheFlush;
   1430   EFI_EBC_GET_VERSION           GetVersion;
   1431 } EFI_EBC_PROTOCOL;
   1432 
   1433 #endif
   1434