Debian Codegraph @

gnu-efi/inc/efiprot.h

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