iPXE
UefiSpec.h
Go to the documentation of this file.
1 /** @file
2  Include file that supports UEFI.
3 
4  This include file must contain things defined in the UEFI 2.6 specification.
5  If a code construct is defined in the UEFI 2.6 specification it must be included
6  by this include file.
7 
8 Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
9 This program and the accompanying materials are licensed and made available under
10 the terms and conditions of the BSD License that accompanies this distribution.
11 The full text of the license may be found at
12 http://opensource.org/licenses/bsd-license.php.
13 
14 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
15 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
16 
17 **/
18 
19 #ifndef __UEFI_SPEC_H__
20 #define __UEFI_SPEC_H__
21 
22 FILE_LICENCE ( BSD3 );
23 
25 
30 
31 ///
32 /// Enumeration of EFI memory allocation types.
33 ///
34 typedef enum {
35  ///
36  /// Allocate any available range of pages that satisfies the request.
37  ///
39  ///
40  /// Allocate any available range of pages whose uppermost address is less than
41  /// or equal to a specified maximum address.
42  ///
44  ///
45  /// Allocate pages at a specified address.
46  ///
48  ///
49  /// Maximum enumeration value that may be used for bounds checking.
50  ///
53 
54 //
55 // Bit definitions for EFI_TIME.Daylight
56 //
57 #define EFI_TIME_ADJUST_DAYLIGHT 0x01
58 #define EFI_TIME_IN_DAYLIGHT 0x02
59 
60 ///
61 /// Value definition for EFI_TIME.TimeZone.
62 ///
63 #define EFI_UNSPECIFIED_TIMEZONE 0x07FF
64 
65 //
66 // Memory cacheability attributes
67 //
68 #define EFI_MEMORY_UC 0x0000000000000001ULL
69 #define EFI_MEMORY_WC 0x0000000000000002ULL
70 #define EFI_MEMORY_WT 0x0000000000000004ULL
71 #define EFI_MEMORY_WB 0x0000000000000008ULL
72 #define EFI_MEMORY_UCE 0x0000000000000010ULL
73 //
74 // Physical memory protection attributes
75 //
76 // Note: UEFI spec 2.5 and following: use EFI_MEMORY_RO as write-protected physical memory
77 // protection attribute. Also, EFI_MEMORY_WP means cacheability attribute.
78 //
79 #define EFI_MEMORY_WP 0x0000000000001000ULL
80 #define EFI_MEMORY_RP 0x0000000000002000ULL
81 #define EFI_MEMORY_XP 0x0000000000004000ULL
82 #define EFI_MEMORY_RO 0x0000000000020000ULL
83 //
84 // Physical memory persistence attribute.
85 // The memory region supports byte-addressable non-volatility.
86 //
87 #define EFI_MEMORY_NV 0x0000000000008000ULL
88 //
89 // The memory region provides higher reliability relative to other memory in the system.
90 // If all memory has the same reliability, then this bit is not used.
91 //
92 #define EFI_MEMORY_MORE_RELIABLE 0x0000000000010000ULL
93 //
94 // Runtime memory attribute
95 //
96 #define EFI_MEMORY_RUNTIME 0x8000000000000000ULL
97 
98 ///
99 /// Memory descriptor version number.
100 ///
101 #define EFI_MEMORY_DESCRIPTOR_VERSION 1
102 
103 ///
104 /// Definition of an EFI memory descriptor.
105 ///
106 typedef struct {
107  ///
108  /// Type of the memory region. See EFI_MEMORY_TYPE.
109  ///
111  ///
112  /// Physical address of the first byte of the memory region. Must aligned
113  /// on a 4 KB boundary.
114  ///
116  ///
117  /// Virtual address of the first byte of the memory region. Must aligned
118  /// on a 4 KB boundary.
119  ///
121  ///
122  /// Number of 4KB pages in the memory region.
123  ///
125  ///
126  /// Attributes of the memory region that describe the bit mask of capabilities
127  /// for that memory region, and not necessarily the current settings for that
128  /// memory region.
129  ///
132 
133 /**
134  Allocates memory pages from the system.
135 
136  @param[in] Type The type of allocation to perform.
137  @param[in] MemoryType The type of memory to allocate.
138  MemoryType values in the range 0x70000000..0x7FFFFFFF
139  are reserved for OEM use. MemoryType values in the range
140  0x80000000..0xFFFFFFFF are reserved for use by UEFI OS loaders
141  that are provided by operating system vendors.
142  @param[in] Pages The number of contiguous 4 KB pages to allocate.
143  @param[in, out] Memory The pointer to a physical address. On input, the way in which the address is
144  used depends on the value of Type.
145 
146  @retval EFI_SUCCESS The requested pages were allocated.
147  @retval EFI_INVALID_PARAMETER 1) Type is not AllocateAnyPages or
148  AllocateMaxAddress or AllocateAddress.
149  2) MemoryType is in the range
150  EfiMaxMemoryType..0x6FFFFFFF.
151  3) Memory is NULL.
152  4) MemoryType is EfiPersistentMemory.
153  @retval EFI_OUT_OF_RESOURCES The pages could not be allocated.
154  @retval EFI_NOT_FOUND The requested pages could not be found.
155 
156 **/
157 typedef
161  IN EFI_MEMORY_TYPE MemoryType,
162  IN UINTN Pages,
163  IN OUT EFI_PHYSICAL_ADDRESS *Memory
164  );
165 
166 /**
167  Frees memory pages.
168 
169  @param[in] Memory The base physical address of the pages to be freed.
170  @param[in] Pages The number of contiguous 4 KB pages to free.
171 
172  @retval EFI_SUCCESS The requested pages were freed.
173  @retval EFI_INVALID_PARAMETER Memory is not a page-aligned address or Pages is invalid.
174  @retval EFI_NOT_FOUND The requested memory pages were not allocated with
175  AllocatePages().
176 
177 **/
178 typedef
181  IN EFI_PHYSICAL_ADDRESS Memory,
182  IN UINTN Pages
183  );
184 
185 /**
186  Returns the current memory map.
187 
188  @param[in, out] MemoryMapSize A pointer to the size, in bytes, of the MemoryMap buffer.
189  On input, this is the size of the buffer allocated by the caller.
190  On output, it is the size of the buffer returned by the firmware if
191  the buffer was large enough, or the size of the buffer needed to contain
192  the map if the buffer was too small.
193  @param[in, out] MemoryMap A pointer to the buffer in which firmware places the current memory
194  map.
195  @param[out] MapKey A pointer to the location in which firmware returns the key for the
196  current memory map.
197  @param[out] DescriptorSize A pointer to the location in which firmware returns the size, in bytes, of
198  an individual EFI_MEMORY_DESCRIPTOR.
199  @param[out] DescriptorVersion A pointer to the location in which firmware returns the version number
200  associated with the EFI_MEMORY_DESCRIPTOR.
201 
202  @retval EFI_SUCCESS The memory map was returned in the MemoryMap buffer.
203  @retval EFI_BUFFER_TOO_SMALL The MemoryMap buffer was too small. The current buffer size
204  needed to hold the memory map is returned in MemoryMapSize.
205  @retval EFI_INVALID_PARAMETER 1) MemoryMapSize is NULL.
206  2) The MemoryMap buffer is not too small and MemoryMap is
207  NULL.
208 
209 **/
210 typedef
213  IN OUT UINTN *MemoryMapSize,
214  IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap,
215  OUT UINTN *MapKey,
216  OUT UINTN *DescriptorSize,
217  OUT UINT32 *DescriptorVersion
218  );
219 
220 /**
221  Allocates pool memory.
222 
223  @param[in] PoolType The type of pool to allocate.
224  MemoryType values in the range 0x70000000..0x7FFFFFFF
225  are reserved for OEM use. MemoryType values in the range
226  0x80000000..0xFFFFFFFF are reserved for use by UEFI OS loaders
227  that are provided by operating system vendors.
228  @param[in] Size The number of bytes to allocate from the pool.
229  @param[out] Buffer A pointer to a pointer to the allocated buffer if the call succeeds;
230  undefined otherwise.
231 
232  @retval EFI_SUCCESS The requested number of bytes was allocated.
233  @retval EFI_OUT_OF_RESOURCES The pool requested could not be allocated.
234  @retval EFI_INVALID_PARAMETER Buffer is NULL.
235  PoolType is in the range EfiMaxMemoryType..0x6FFFFFFF.
236  PoolType is EfiPersistentMemory.
237 
238 **/
239 typedef
242  IN EFI_MEMORY_TYPE PoolType,
243  IN UINTN Size,
244  OUT VOID **Buffer
245  );
246 
247 /**
248  Returns pool memory to the system.
249 
250  @param[in] Buffer The pointer to the buffer to free.
251 
252  @retval EFI_SUCCESS The memory was returned to the system.
253  @retval EFI_INVALID_PARAMETER Buffer was invalid.
254 
255 **/
256 typedef
259  IN VOID *Buffer
260  );
261 
262 /**
263  Changes the runtime addressing mode of EFI firmware from physical to virtual.
264 
265  @param[in] MemoryMapSize The size in bytes of VirtualMap.
266  @param[in] DescriptorSize The size in bytes of an entry in the VirtualMap.
267  @param[in] DescriptorVersion The version of the structure entries in VirtualMap.
268  @param[in] VirtualMap An array of memory descriptors which contain new virtual
269  address mapping information for all runtime ranges.
270 
271  @retval EFI_SUCCESS The virtual address map has been applied.
272  @retval EFI_UNSUPPORTED EFI firmware is not at runtime, or the EFI firmware is already in
273  virtual address mapped mode.
274  @retval EFI_INVALID_PARAMETER DescriptorSize or DescriptorVersion is invalid.
275  @retval EFI_NO_MAPPING A virtual address was not supplied for a range in the memory
276  map that requires a mapping.
277  @retval EFI_NOT_FOUND A virtual address was supplied for an address that is not found
278  in the memory map.
279 
280 **/
281 typedef
284  IN UINTN MemoryMapSize,
285  IN UINTN DescriptorSize,
286  IN UINT32 DescriptorVersion,
287  IN EFI_MEMORY_DESCRIPTOR *VirtualMap
288  );
289 
290 /**
291  Connects one or more drivers to a controller.
292 
293  @param[in] ControllerHandle The handle of the controller to which driver(s) are to be connected.
294  @param[in] DriverImageHandle A pointer to an ordered list handles that support the
295  EFI_DRIVER_BINDING_PROTOCOL.
296  @param[in] RemainingDevicePath A pointer to the device path that specifies a child of the
297  controller specified by ControllerHandle.
298  @param[in] Recursive If TRUE, then ConnectController() is called recursively
299  until the entire tree of controllers below the controller specified
300  by ControllerHandle have been created. If FALSE, then
301  the tree of controllers is only expanded one level.
302 
303  @retval EFI_SUCCESS 1) One or more drivers were connected to ControllerHandle.
304  2) No drivers were connected to ControllerHandle, but
305  RemainingDevicePath is not NULL, and it is an End Device
306  Path Node.
307  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
308  @retval EFI_NOT_FOUND 1) There are no EFI_DRIVER_BINDING_PROTOCOL instances
309  present in the system.
310  2) No drivers were connected to ControllerHandle.
311  @retval EFI_SECURITY_VIOLATION
312  The user has no permission to start UEFI device drivers on the device path
313  associated with the ControllerHandle or specified by the RemainingDevicePath.
314 **/
315 typedef
319  IN EFI_HANDLE *DriverImageHandle, OPTIONAL
320  IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath, OPTIONAL
321  IN BOOLEAN Recursive
322  );
323 
324 /**
325  Disconnects one or more drivers from a controller.
326 
327  @param[in] ControllerHandle The handle of the controller from which driver(s) are to be disconnected.
328  @param[in] DriverImageHandle The driver to disconnect from ControllerHandle.
329  If DriverImageHandle is NULL, then all the drivers currently managing
330  ControllerHandle are disconnected from ControllerHandle.
331  @param[in] ChildHandle The handle of the child to destroy.
332  If ChildHandle is NULL, then all the children of ControllerHandle are
333  destroyed before the drivers are disconnected from ControllerHandle.
334 
335  @retval EFI_SUCCESS 1) One or more drivers were disconnected from the controller.
336  2) On entry, no drivers are managing ControllerHandle.
337  3) DriverImageHandle is not NULL, and on entry
338  DriverImageHandle is not managing ControllerHandle.
339  @retval EFI_INVALID_PARAMETER 1) ControllerHandle is NULL.
340  2) DriverImageHandle is not NULL, and it is not a valid EFI_HANDLE.
341  3) ChildHandle is not NULL, and it is not a valid EFI_HANDLE.
342  4) DriverImageHandle does not support the EFI_DRIVER_BINDING_PROTOCOL.
343  @retval EFI_OUT_OF_RESOURCES There are not enough resources available to disconnect any drivers from
344  ControllerHandle.
345  @retval EFI_DEVICE_ERROR The controller could not be disconnected because of a device error.
346 
347 **/
348 typedef
352  IN EFI_HANDLE DriverImageHandle, OPTIONAL
353  IN EFI_HANDLE ChildHandle OPTIONAL
354  );
355 
356 
357 
358 //
359 // ConvertPointer DebugDisposition type.
360 //
361 #define EFI_OPTIONAL_PTR 0x00000001
362 
363 /**
364  Determines the new virtual address that is to be used on subsequent memory accesses.
365 
366  @param[in] DebugDisposition Supplies type information for the pointer being converted.
367  @param[in, out] Address A pointer to a pointer that is to be fixed to be the value needed
368  for the new virtual address mappings being applied.
369 
370  @retval EFI_SUCCESS The pointer pointed to by Address was modified.
371  @retval EFI_INVALID_PARAMETER 1) Address is NULL.
372  2) *Address is NULL and DebugDisposition does
373  not have the EFI_OPTIONAL_PTR bit set.
374  @retval EFI_NOT_FOUND The pointer pointed to by Address was not found to be part
375  of the current memory map. This is normally fatal.
376 
377 **/
378 typedef
381  IN UINTN DebugDisposition,
382  IN OUT VOID **Address
383  );
384 
385 
386 //
387 // These types can be ORed together as needed - for example,
388 // EVT_TIMER might be Ored with EVT_NOTIFY_WAIT or
389 // EVT_NOTIFY_SIGNAL.
390 //
391 #define EVT_TIMER 0x80000000
392 #define EVT_RUNTIME 0x40000000
393 #define EVT_NOTIFY_WAIT 0x00000100
394 #define EVT_NOTIFY_SIGNAL 0x00000200
395 
396 #define EVT_SIGNAL_EXIT_BOOT_SERVICES 0x00000201
397 #define EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE 0x60000202
398 
399 //
400 // The event's NotifyContext pointer points to a runtime memory
401 // address.
402 // The event is deprecated in UEFI2.0 and later specifications.
403 //
404 #define EVT_RUNTIME_CONTEXT 0x20000000
405 
406 
407 /**
408  Invoke a notification event
409 
410  @param[in] Event Event whose notification function is being invoked.
411  @param[in] Context The pointer to the notification function's context,
412  which is implementation-dependent.
413 
414 **/
415 typedef
416 VOID
418  IN EFI_EVENT Event,
419  IN VOID *Context
420  );
421 
422 /**
423  Creates an event.
424 
425  @param[in] Type The type of event to create and its mode and attributes.
426  @param[in] NotifyTpl The task priority level of event notifications, if needed.
427  @param[in] NotifyFunction The pointer to the event's notification function, if any.
428  @param[in] NotifyContext The pointer to the notification function's context; corresponds to parameter
429  Context in the notification function.
430  @param[out] Event The pointer to the newly created event if the call succeeds; undefined
431  otherwise.
432 
433  @retval EFI_SUCCESS The event structure was created.
434  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
435  @retval EFI_OUT_OF_RESOURCES The event could not be allocated.
436 
437 **/
438 typedef
441  IN UINT32 Type,
442  IN EFI_TPL NotifyTpl,
443  IN EFI_EVENT_NOTIFY NotifyFunction,
444  IN VOID *NotifyContext,
445  OUT EFI_EVENT *Event
446  );
447 
448 /**
449  Creates an event in a group.
450 
451  @param[in] Type The type of event to create and its mode and attributes.
452  @param[in] NotifyTpl The task priority level of event notifications,if needed.
453  @param[in] NotifyFunction The pointer to the event's notification function, if any.
454  @param[in] NotifyContext The pointer to the notification function's context; corresponds to parameter
455  Context in the notification function.
456  @param[in] EventGroup The pointer to the unique identifier of the group to which this event belongs.
457  If this is NULL, then the function behaves as if the parameters were passed
458  to CreateEvent.
459  @param[out] Event The pointer to the newly created event if the call succeeds; undefined
460  otherwise.
461 
462  @retval EFI_SUCCESS The event structure was created.
463  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
464  @retval EFI_OUT_OF_RESOURCES The event could not be allocated.
465 
466 **/
467 typedef
470  IN UINT32 Type,
471  IN EFI_TPL NotifyTpl,
472  IN EFI_EVENT_NOTIFY NotifyFunction OPTIONAL,
473  IN CONST VOID *NotifyContext OPTIONAL,
474  IN CONST EFI_GUID *EventGroup OPTIONAL,
475  OUT EFI_EVENT *Event
476  );
477 
478 ///
479 /// Timer delay types
480 ///
481 typedef enum {
482  ///
483  /// An event's timer settings is to be cancelled and not trigger time is to be set/
484  ///
486  ///
487  /// An event is to be signaled periodically at a specified interval from the current time.
488  ///
490  ///
491  /// An event is to be signaled once at a specified interval from the current time.
492  ///
495 
496 /**
497  Sets the type of timer and the trigger time for a timer event.
498 
499  @param[in] Event The timer event that is to be signaled at the specified time.
500  @param[in] Type The type of time that is specified in TriggerTime.
501  @param[in] TriggerTime The number of 100ns units until the timer expires.
502  A TriggerTime of 0 is legal.
503  If Type is TimerRelative and TriggerTime is 0, then the timer
504  event will be signaled on the next timer tick.
505  If Type is TimerPeriodic and TriggerTime is 0, then the timer
506  event will be signaled on every timer tick.
507 
508  @retval EFI_SUCCESS The event has been set to be signaled at the requested time.
509  @retval EFI_INVALID_PARAMETER Event or Type is not valid.
510 
511 **/
512 typedef
515  IN EFI_EVENT Event,
517  IN UINT64 TriggerTime
518  );
519 
520 /**
521  Signals an event.
522 
523  @param[in] Event The event to signal.
524 
525  @retval EFI_SUCCESS The event has been signaled.
526 
527 **/
528 typedef
531  IN EFI_EVENT Event
532  );
533 
534 /**
535  Stops execution until an event is signaled.
536 
537  @param[in] NumberOfEvents The number of events in the Event array.
538  @param[in] Event An array of EFI_EVENT.
539  @param[out] Index The pointer to the index of the event which satisfied the wait condition.
540 
541  @retval EFI_SUCCESS The event indicated by Index was signaled.
542  @retval EFI_INVALID_PARAMETER 1) NumberOfEvents is 0.
543  2) The event indicated by Index is of type
544  EVT_NOTIFY_SIGNAL.
545  @retval EFI_UNSUPPORTED The current TPL is not TPL_APPLICATION.
546 
547 **/
548 typedef
551  IN UINTN NumberOfEvents,
552  IN EFI_EVENT *Event,
553  OUT UINTN *Index
554  );
555 
556 /**
557  Closes an event.
558 
559  @param[in] Event The event to close.
560 
561  @retval EFI_SUCCESS The event has been closed.
562 
563 **/
564 typedef
567  IN EFI_EVENT Event
568  );
569 
570 /**
571  Checks whether an event is in the signaled state.
572 
573  @param[in] Event The event to check.
574 
575  @retval EFI_SUCCESS The event is in the signaled state.
576  @retval EFI_NOT_READY The event is not in the signaled state.
577  @retval EFI_INVALID_PARAMETER Event is of type EVT_NOTIFY_SIGNAL.
578 
579 **/
580 typedef
583  IN EFI_EVENT Event
584  );
585 
586 
587 //
588 // Task priority level
589 //
590 #define TPL_APPLICATION 4
591 #define TPL_CALLBACK 8
592 #define TPL_NOTIFY 16
593 #define TPL_HIGH_LEVEL 31
594 
595 
596 /**
597  Raises a task's priority level and returns its previous level.
598 
599  @param[in] NewTpl The new task priority level.
600 
601  @return Previous task priority level
602 
603 **/
604 typedef
605 EFI_TPL
607  IN EFI_TPL NewTpl
608  );
609 
610 /**
611  Restores a task's priority level to its previous value.
612 
613  @param[in] OldTpl The previous task priority level to restore.
614 
615 **/
616 typedef
617 VOID
619  IN EFI_TPL OldTpl
620  );
621 
622 /**
623  Returns the value of a variable.
624 
625  @param[in] VariableName A Null-terminated string that is the name of the vendor's
626  variable.
627  @param[in] VendorGuid A unique identifier for the vendor.
628  @param[out] Attributes If not NULL, a pointer to the memory location to return the
629  attributes bitmask for the variable.
630  @param[in, out] DataSize On input, the size in bytes of the return Data buffer.
631  On output the size of data returned in Data.
632  @param[out] Data The buffer to return the contents of the variable. May be NULL
633  with a zero DataSize in order to determine the size buffer needed.
634 
635  @retval EFI_SUCCESS The function completed successfully.
636  @retval EFI_NOT_FOUND The variable was not found.
637  @retval EFI_BUFFER_TOO_SMALL The DataSize is too small for the result.
638  @retval EFI_INVALID_PARAMETER VariableName is NULL.
639  @retval EFI_INVALID_PARAMETER VendorGuid is NULL.
640  @retval EFI_INVALID_PARAMETER DataSize is NULL.
641  @retval EFI_INVALID_PARAMETER The DataSize is not too small and Data is NULL.
642  @retval EFI_DEVICE_ERROR The variable could not be retrieved due to a hardware error.
643  @retval EFI_SECURITY_VIOLATION The variable could not be retrieved due to an authentication failure.
644 
645 **/
646 typedef
649  IN CHAR16 *VariableName,
650  IN EFI_GUID *VendorGuid,
651  OUT UINT32 *Attributes, OPTIONAL
652  IN OUT UINTN *DataSize,
653  OUT VOID *Data OPTIONAL
654  );
655 
656 /**
657  Enumerates the current variable names.
658 
659  @param[in, out] VariableNameSize The size of the VariableName buffer.
660  @param[in, out] VariableName On input, supplies the last VariableName that was returned
661  by GetNextVariableName(). On output, returns the Nullterminated
662  string of the current variable.
663  @param[in, out] VendorGuid On input, supplies the last VendorGuid that was returned by
664  GetNextVariableName(). On output, returns the
665  VendorGuid of the current variable.
666 
667  @retval EFI_SUCCESS The function completed successfully.
668  @retval EFI_NOT_FOUND The next variable was not found.
669  @retval EFI_BUFFER_TOO_SMALL The VariableNameSize is too small for the result.
670  @retval EFI_INVALID_PARAMETER VariableNameSize is NULL.
671  @retval EFI_INVALID_PARAMETER VariableName is NULL.
672  @retval EFI_INVALID_PARAMETER VendorGuid is NULL.
673  @retval EFI_DEVICE_ERROR The variable could not be retrieved due to a hardware error.
674 
675 **/
676 typedef
679  IN OUT UINTN *VariableNameSize,
680  IN OUT CHAR16 *VariableName,
681  IN OUT EFI_GUID *VendorGuid
682  );
683 
684 /**
685  Sets the value of a variable.
686 
687  @param[in] VariableName A Null-terminated string that is the name of the vendor's variable.
688  Each VariableName is unique for each VendorGuid. VariableName must
689  contain 1 or more characters. If VariableName is an empty string,
690  then EFI_INVALID_PARAMETER is returned.
691  @param[in] VendorGuid A unique identifier for the vendor.
692  @param[in] Attributes Attributes bitmask to set for the variable.
693  @param[in] DataSize The size in bytes of the Data buffer. Unless the EFI_VARIABLE_APPEND_WRITE,
694  EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS, or
695  EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute is set, a size of zero
696  causes the variable to be deleted. When the EFI_VARIABLE_APPEND_WRITE attribute is
697  set, then a SetVariable() call with a DataSize of zero will not cause any change to
698  the variable value (the timestamp associated with the variable may be updated however
699  even if no new data value is provided,see the description of the
700  EFI_VARIABLE_AUTHENTICATION_2 descriptor below. In this case the DataSize will not
701  be zero since the EFI_VARIABLE_AUTHENTICATION_2 descriptor will be populated).
702  @param[in] Data The contents for the variable.
703 
704  @retval EFI_SUCCESS The firmware has successfully stored the variable and its data as
705  defined by the Attributes.
706  @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits, name, and GUID was supplied, or the
707  DataSize exceeds the maximum allowed.
708  @retval EFI_INVALID_PARAMETER VariableName is an empty string.
709  @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the variable and its data.
710  @retval EFI_DEVICE_ERROR The variable could not be retrieved due to a hardware error.
711  @retval EFI_WRITE_PROTECTED The variable in question is read-only.
712  @retval EFI_WRITE_PROTECTED The variable in question cannot be deleted.
713  @retval EFI_SECURITY_VIOLATION The variable could not be written due to EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS
714  or EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACESS being set, but the AuthInfo
715  does NOT pass the validation check carried out by the firmware.
716 
717  @retval EFI_NOT_FOUND The variable trying to be updated or deleted was not found.
718 
719 **/
720 typedef
723  IN CHAR16 *VariableName,
724  IN EFI_GUID *VendorGuid,
725  IN UINT32 Attributes,
726  IN UINTN DataSize,
727  IN VOID *Data
728  );
729 
730 
731 ///
732 /// This provides the capabilities of the
733 /// real time clock device as exposed through the EFI interfaces.
734 ///
735 typedef struct {
736  ///
737  /// Provides the reporting resolution of the real-time clock device in
738  /// counts per second. For a normal PC-AT CMOS RTC device, this
739  /// value would be 1 Hz, or 1, to indicate that the device only reports
740  /// the time to the resolution of 1 second.
741  ///
743  ///
744  /// Provides the timekeeping accuracy of the real-time clock in an
745  /// error rate of 1E-6 parts per million. For a clock with an accuracy
746  /// of 50 parts per million, the value in this field would be
747  /// 50,000,000.
748  ///
750  ///
751  /// A TRUE indicates that a time set operation clears the device's
752  /// time below the Resolution reporting level. A FALSE
753  /// indicates that the state below the Resolution level of the
754  /// device is not cleared when the time is set. Normal PC-AT CMOS
755  /// RTC devices set this value to FALSE.
756  ///
759 
760 /**
761  Returns the current time and date information, and the time-keeping capabilities
762  of the hardware platform.
763 
764  @param[out] Time A pointer to storage to receive a snapshot of the current time.
765  @param[out] Capabilities An optional pointer to a buffer to receive the real time clock
766  device's capabilities.
767 
768  @retval EFI_SUCCESS The operation completed successfully.
769  @retval EFI_INVALID_PARAMETER Time is NULL.
770  @retval EFI_DEVICE_ERROR The time could not be retrieved due to hardware error.
771 
772 **/
773 typedef
776  OUT EFI_TIME *Time,
777  OUT EFI_TIME_CAPABILITIES *Capabilities OPTIONAL
778  );
779 
780 /**
781  Sets the current local time and date information.
782 
783  @param[in] Time A pointer to the current time.
784 
785  @retval EFI_SUCCESS The operation completed successfully.
786  @retval EFI_INVALID_PARAMETER A time field is out of range.
787  @retval EFI_DEVICE_ERROR The time could not be set due due to hardware error.
788 
789 **/
790 typedef
793  IN EFI_TIME *Time
794  );
795 
796 /**
797  Returns the current wakeup alarm clock setting.
798 
799  @param[out] Enabled Indicates if the alarm is currently enabled or disabled.
800  @param[out] Pending Indicates if the alarm signal is pending and requires acknowledgement.
801  @param[out] Time The current alarm setting.
802 
803  @retval EFI_SUCCESS The alarm settings were returned.
804  @retval EFI_INVALID_PARAMETER Enabled is NULL.
805  @retval EFI_INVALID_PARAMETER Pending is NULL.
806  @retval EFI_INVALID_PARAMETER Time is NULL.
807  @retval EFI_DEVICE_ERROR The wakeup time could not be retrieved due to a hardware error.
808  @retval EFI_UNSUPPORTED A wakeup timer is not supported on this platform.
809 
810 **/
811 typedef
814  OUT BOOLEAN *Enabled,
815  OUT BOOLEAN *Pending,
816  OUT EFI_TIME *Time
817  );
818 
819 /**
820  Sets the system wakeup alarm clock time.
821 
822  @param[in] Enable Enable or disable the wakeup alarm.
823  @param[in] Time If Enable is TRUE, the time to set the wakeup alarm for.
824  If Enable is FALSE, then this parameter is optional, and may be NULL.
825 
826  @retval EFI_SUCCESS If Enable is TRUE, then the wakeup alarm was enabled. If
827  Enable is FALSE, then the wakeup alarm was disabled.
828  @retval EFI_INVALID_PARAMETER A time field is out of range.
829  @retval EFI_DEVICE_ERROR The wakeup time could not be set due to a hardware error.
830  @retval EFI_UNSUPPORTED A wakeup timer is not supported on this platform.
831 
832 **/
833 typedef
836  IN BOOLEAN Enable,
837  IN EFI_TIME *Time OPTIONAL
838  );
839 
840 /**
841  Loads an EFI image into memory.
842 
843  @param[in] BootPolicy If TRUE, indicates that the request originates from the boot
844  manager, and that the boot manager is attempting to load
845  FilePath as a boot selection. Ignored if SourceBuffer is
846  not NULL.
847  @param[in] ParentImageHandle The caller's image handle.
848  @param[in] DevicePath The DeviceHandle specific file path from which the image is
849  loaded.
850  @param[in] SourceBuffer If not NULL, a pointer to the memory location containing a copy
851  of the image to be loaded.
852  @param[in] SourceSize The size in bytes of SourceBuffer. Ignored if SourceBuffer is NULL.
853  @param[out] ImageHandle The pointer to the returned image handle that is created when the
854  image is successfully loaded.
855 
856  @retval EFI_SUCCESS Image was loaded into memory correctly.
857  @retval EFI_NOT_FOUND Both SourceBuffer and DevicePath are NULL.
858  @retval EFI_INVALID_PARAMETER One or more parametes are invalid.
859  @retval EFI_UNSUPPORTED The image type is not supported.
860  @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient resources.
861  @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
862  understood.
863  @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
864  @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
865  image from being loaded. NULL is returned in *ImageHandle.
866  @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
867  valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
868  platform policy specifies that the image should not be started.
869 **/
870 typedef
873  IN BOOLEAN BootPolicy,
874  IN EFI_HANDLE ParentImageHandle,
875  IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
876  IN VOID *SourceBuffer OPTIONAL,
877  IN UINTN SourceSize,
878  OUT EFI_HANDLE *ImageHandle
879  );
880 
881 /**
882  Transfers control to a loaded image's entry point.
883 
884  @param[in] ImageHandle Handle of image to be started.
885  @param[out] ExitDataSize The pointer to the size, in bytes, of ExitData.
886  @param[out] ExitData The pointer to a pointer to a data buffer that includes a Null-terminated
887  string, optionally followed by additional binary data.
888 
889  @retval EFI_INVALID_PARAMETER ImageHandle is either an invalid image handle or the image
890  has already been initialized with StartImage.
891  @retval EFI_SECURITY_VIOLATION The current platform policy specifies that the image should not be started.
892  @return Exit code from image
893 
894 **/
895 typedef
898  IN EFI_HANDLE ImageHandle,
899  OUT UINTN *ExitDataSize,
900  OUT CHAR16 **ExitData OPTIONAL
901  );
902 
903 /**
904  Terminates a loaded EFI image and returns control to boot services.
905 
906  @param[in] ImageHandle Handle that identifies the image. This parameter is passed to the
907  image on entry.
908  @param[in] ExitStatus The image's exit code.
909  @param[in] ExitDataSize The size, in bytes, of ExitData. Ignored if ExitStatus is EFI_SUCCESS.
910  @param[in] ExitData The pointer to a data buffer that includes a Null-terminated string,
911  optionally followed by additional binary data. The string is a
912  description that the caller may use to further indicate the reason
913  for the image's exit. ExitData is only valid if ExitStatus
914  is something other than EFI_SUCCESS. The ExitData buffer
915  must be allocated by calling AllocatePool().
916 
917  @retval EFI_SUCCESS The image specified by ImageHandle was unloaded.
918  @retval EFI_INVALID_PARAMETER The image specified by ImageHandle has been loaded and
919  started with LoadImage() and StartImage(), but the
920  image is not the currently executing image.
921 
922 **/
923 typedef
926  IN EFI_HANDLE ImageHandle,
927  IN EFI_STATUS ExitStatus,
928  IN UINTN ExitDataSize,
929  IN CHAR16 *ExitData OPTIONAL
930  );
931 
932 /**
933  Unloads an image.
934 
935  @param[in] ImageHandle Handle that identifies the image to be unloaded.
936 
937  @retval EFI_SUCCESS The image has been unloaded.
938  @retval EFI_INVALID_PARAMETER ImageHandle is not a valid image handle.
939 
940 **/
941 typedef
944  IN EFI_HANDLE ImageHandle
945  );
946 
947 /**
948  Terminates all boot services.
949 
950  @param[in] ImageHandle Handle that identifies the exiting image.
951  @param[in] MapKey Key to the latest memory map.
952 
953  @retval EFI_SUCCESS Boot services have been terminated.
954  @retval EFI_INVALID_PARAMETER MapKey is incorrect.
955 
956 **/
957 typedef
960  IN EFI_HANDLE ImageHandle,
961  IN UINTN MapKey
962  );
963 
964 /**
965  Induces a fine-grained stall.
966 
967  @param[in] Microseconds The number of microseconds to stall execution.
968 
969  @retval EFI_SUCCESS Execution was stalled at least the requested number of
970  Microseconds.
971 
972 **/
973 typedef
976  IN UINTN Microseconds
977  );
978 
979 /**
980  Sets the system's watchdog timer.
981 
982  @param[in] Timeout The number of seconds to set the watchdog timer to.
983  @param[in] WatchdogCode The numeric code to log on a watchdog timer timeout event.
984  @param[in] DataSize The size, in bytes, of WatchdogData.
985  @param[in] WatchdogData A data buffer that includes a Null-terminated string, optionally
986  followed by additional binary data.
987 
988  @retval EFI_SUCCESS The timeout has been set.
989  @retval EFI_INVALID_PARAMETER The supplied WatchdogCode is invalid.
990  @retval EFI_UNSUPPORTED The system does not have a watchdog timer.
991  @retval EFI_DEVICE_ERROR The watchdog timer could not be programmed due to a hardware
992  error.
993 
994 **/
995 typedef
998  IN UINTN Timeout,
999  IN UINT64 WatchdogCode,
1000  IN UINTN DataSize,
1001  IN CHAR16 *WatchdogData OPTIONAL
1002  );
1003 
1004 /**
1005  Resets the entire platform.
1006 
1007  @param[in] ResetType The type of reset to perform.
1008  @param[in] ResetStatus The status code for the reset.
1009  @param[in] DataSize The size, in bytes, of ResetData.
1010  @param[in] ResetData For a ResetType of EfiResetCold, EfiResetWarm, or
1011  EfiResetShutdown the data buffer starts with a Null-terminated
1012  string, optionally followed by additional binary data.
1013  The string is a description that the caller may use to further
1014  indicate the reason for the system reset. ResetData is only
1015  valid if ResetStatus is something other than EFI_SUCCESS
1016  unless the ResetType is EfiResetPlatformSpecific
1017  where a minimum amount of ResetData is always required.
1018 **/
1019 typedef
1020 VOID
1022  IN EFI_RESET_TYPE ResetType,
1023  IN EFI_STATUS ResetStatus,
1024  IN UINTN DataSize,
1025  IN VOID *ResetData OPTIONAL
1026  );
1027 
1028 /**
1029  Returns a monotonically increasing count for the platform.
1030 
1031  @param[out] Count The pointer to returned value.
1032 
1033  @retval EFI_SUCCESS The next monotonic count was returned.
1034  @retval EFI_INVALID_PARAMETER Count is NULL.
1035  @retval EFI_DEVICE_ERROR The device is not functioning properly.
1036 
1037 **/
1038 typedef
1039 EFI_STATUS
1041  OUT UINT64 *Count
1042  );
1043 
1044 /**
1045  Returns the next high 32 bits of the platform's monotonic counter.
1046 
1047  @param[out] HighCount The pointer to returned value.
1048 
1049  @retval EFI_SUCCESS The next high monotonic count was returned.
1050  @retval EFI_INVALID_PARAMETER HighCount is NULL.
1051  @retval EFI_DEVICE_ERROR The device is not functioning properly.
1052 
1053 **/
1054 typedef
1055 EFI_STATUS
1057  OUT UINT32 *HighCount
1058  );
1059 
1060 /**
1061  Computes and returns a 32-bit CRC for a data buffer.
1062 
1063  @param[in] Data A pointer to the buffer on which the 32-bit CRC is to be computed.
1064  @param[in] DataSize The number of bytes in the buffer Data.
1065  @param[out] Crc32 The 32-bit CRC that was computed for the data buffer specified by Data
1066  and DataSize.
1067 
1068  @retval EFI_SUCCESS The 32-bit CRC was computed for the data buffer and returned in
1069  Crc32.
1070  @retval EFI_INVALID_PARAMETER Data is NULL.
1071  @retval EFI_INVALID_PARAMETER Crc32 is NULL.
1072  @retval EFI_INVALID_PARAMETER DataSize is 0.
1073 
1074 **/
1075 typedef
1076 EFI_STATUS
1078  IN VOID *Data,
1079  IN UINTN DataSize,
1080  OUT UINT32 *Crc32
1081  );
1082 
1083 /**
1084  Copies the contents of one buffer to another buffer.
1085 
1086  @param[in] Destination The pointer to the destination buffer of the memory copy.
1087  @param[in] Source The pointer to the source buffer of the memory copy.
1088  @param[in] Length Number of bytes to copy from Source to Destination.
1089 
1090 **/
1091 typedef
1092 VOID
1094  IN VOID *Destination,
1095  IN VOID *Source,
1096  IN UINTN Length
1097  );
1098 
1099 /**
1100  The SetMem() function fills a buffer with a specified value.
1101 
1102  @param[in] Buffer The pointer to the buffer to fill.
1103  @param[in] Size Number of bytes in Buffer to fill.
1104  @param[in] Value Value to fill Buffer with.
1105 
1106 **/
1107 typedef
1108 VOID
1110  IN VOID *Buffer,
1111  IN UINTN Size,
1112  IN UINT8 Value
1113  );
1114 
1115 ///
1116 /// Enumeration of EFI Interface Types
1117 ///
1118 typedef enum {
1119  ///
1120  /// Indicates that the supplied protocol interface is supplied in native form.
1121  ///
1124 
1125 /**
1126  Installs a protocol interface on a device handle. If the handle does not exist, it is created and added
1127  to the list of handles in the system. InstallMultipleProtocolInterfaces() performs
1128  more error checking than InstallProtocolInterface(), so it is recommended that
1129  InstallMultipleProtocolInterfaces() be used in place of
1130  InstallProtocolInterface()
1131 
1132  @param[in, out] Handle A pointer to the EFI_HANDLE on which the interface is to be installed.
1133  @param[in] Protocol The numeric ID of the protocol interface.
1134  @param[in] InterfaceType Indicates whether Interface is supplied in native form.
1135  @param[in] Interface A pointer to the protocol interface.
1136 
1137  @retval EFI_SUCCESS The protocol interface was installed.
1138  @retval EFI_OUT_OF_RESOURCES Space for a new handle could not be allocated.
1139  @retval EFI_INVALID_PARAMETER Handle is NULL.
1140  @retval EFI_INVALID_PARAMETER Protocol is NULL.
1141  @retval EFI_INVALID_PARAMETER InterfaceType is not EFI_NATIVE_INTERFACE.
1142  @retval EFI_INVALID_PARAMETER Protocol is already installed on the handle specified by Handle.
1143 
1144 **/
1145 typedef
1146 EFI_STATUS
1148  IN OUT EFI_HANDLE *Handle,
1149  IN EFI_GUID *Protocol,
1150  IN EFI_INTERFACE_TYPE InterfaceType,
1151  IN VOID *Interface
1152  );
1153 
1154 /**
1155  Installs one or more protocol interfaces into the boot services environment.
1156 
1157  @param[in, out] Handle The pointer to a handle to install the new protocol interfaces on,
1158  or a pointer to NULL if a new handle is to be allocated.
1159  @param ... A variable argument list containing pairs of protocol GUIDs and protocol
1160  interfaces.
1161 
1162  @retval EFI_SUCCESS All the protocol interface was installed.
1163  @retval EFI_OUT_OF_RESOURCES There was not enough memory in pool to install all the protocols.
1164  @retval EFI_ALREADY_STARTED A Device Path Protocol instance was passed in that is already present in
1165  the handle database.
1166  @retval EFI_INVALID_PARAMETER Handle is NULL.
1167  @retval EFI_INVALID_PARAMETER Protocol is already installed on the handle specified by Handle.
1168 
1169 **/
1170 typedef
1171 EFI_STATUS
1173  IN OUT EFI_HANDLE *Handle,
1174  ...
1175  );
1176 
1177 /**
1178  Reinstalls a protocol interface on a device handle.
1179 
1180  @param[in] Handle Handle on which the interface is to be reinstalled.
1181  @param[in] Protocol The numeric ID of the interface.
1182  @param[in] OldInterface A pointer to the old interface. NULL can be used if a structure is not
1183  associated with Protocol.
1184  @param[in] NewInterface A pointer to the new interface.
1185 
1186  @retval EFI_SUCCESS The protocol interface was reinstalled.
1187  @retval EFI_NOT_FOUND The OldInterface on the handle was not found.
1188  @retval EFI_ACCESS_DENIED The protocol interface could not be reinstalled,
1189  because OldInterface is still being used by a
1190  driver that will not release it.
1191  @retval EFI_INVALID_PARAMETER Handle is NULL.
1192  @retval EFI_INVALID_PARAMETER Protocol is NULL.
1193 
1194 **/
1195 typedef
1196 EFI_STATUS
1198  IN EFI_HANDLE Handle,
1199  IN EFI_GUID *Protocol,
1200  IN VOID *OldInterface,
1201  IN VOID *NewInterface
1202  );
1203 
1204 /**
1205  Removes a protocol interface from a device handle. It is recommended that
1206  UninstallMultipleProtocolInterfaces() be used in place of
1207  UninstallProtocolInterface().
1208 
1209  @param[in] Handle The handle on which the interface was installed.
1210  @param[in] Protocol The numeric ID of the interface.
1211  @param[in] Interface A pointer to the interface.
1212 
1213  @retval EFI_SUCCESS The interface was removed.
1214  @retval EFI_NOT_FOUND The interface was not found.
1215  @retval EFI_ACCESS_DENIED The interface was not removed because the interface
1216  is still being used by a driver.
1217  @retval EFI_INVALID_PARAMETER Handle is NULL.
1218  @retval EFI_INVALID_PARAMETER Protocol is NULL.
1219 
1220 **/
1221 typedef
1222 EFI_STATUS
1224  IN EFI_HANDLE Handle,
1225  IN EFI_GUID *Protocol,
1226  IN VOID *Interface
1227  );
1228 
1229 /**
1230  Removes one or more protocol interfaces into the boot services environment.
1231 
1232  @param[in] Handle The handle to remove the protocol interfaces from.
1233  @param ... A variable argument list containing pairs of protocol GUIDs and
1234  protocol interfaces.
1235 
1236  @retval EFI_SUCCESS All the protocol interfaces were removed.
1237  @retval EFI_INVALID_PARAMETER One of the protocol interfaces was not previously installed on Handle.
1238 
1239 **/
1240 typedef
1241 EFI_STATUS
1243  IN EFI_HANDLE Handle,
1244  ...
1245  );
1246 
1247 /**
1248  Queries a handle to determine if it supports a specified protocol.
1249 
1250  @param[in] Handle The handle being queried.
1251  @param[in] Protocol The published unique identifier of the protocol.
1252  @param[out] Interface Supplies the address where a pointer to the corresponding Protocol
1253  Interface is returned.
1254 
1255  @retval EFI_SUCCESS The interface information for the specified protocol was returned.
1256  @retval EFI_UNSUPPORTED The device does not support the specified protocol.
1257  @retval EFI_INVALID_PARAMETER Handle is NULL.
1258  @retval EFI_INVALID_PARAMETER Protocol is NULL.
1259  @retval EFI_INVALID_PARAMETER Interface is NULL.
1260 
1261 **/
1262 typedef
1263 EFI_STATUS
1265  IN EFI_HANDLE Handle,
1266  IN EFI_GUID *Protocol,
1267  OUT VOID **Interface
1268  );
1269 
1270 #define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL 0x00000001
1271 #define EFI_OPEN_PROTOCOL_GET_PROTOCOL 0x00000002
1272 #define EFI_OPEN_PROTOCOL_TEST_PROTOCOL 0x00000004
1273 #define EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 0x00000008
1274 #define EFI_OPEN_PROTOCOL_BY_DRIVER 0x00000010
1275 #define EFI_OPEN_PROTOCOL_EXCLUSIVE 0x00000020
1276 
1277 /**
1278  Queries a handle to determine if it supports a specified protocol. If the protocol is supported by the
1279  handle, it opens the protocol on behalf of the calling agent.
1280 
1281  @param[in] Handle The handle for the protocol interface that is being opened.
1282  @param[in] Protocol The published unique identifier of the protocol.
1283  @param[out] Interface Supplies the address where a pointer to the corresponding Protocol
1284  Interface is returned.
1285  @param[in] AgentHandle The handle of the agent that is opening the protocol interface
1286  specified by Protocol and Interface.
1287  @param[in] ControllerHandle If the agent that is opening a protocol is a driver that follows the
1288  UEFI Driver Model, then this parameter is the controller handle
1289  that requires the protocol interface. If the agent does not follow
1290  the UEFI Driver Model, then this parameter is optional and may
1291  be NULL.
1292  @param[in] Attributes The open mode of the protocol interface specified by Handle
1293  and Protocol.
1294 
1295  @retval EFI_SUCCESS An item was added to the open list for the protocol interface, and the
1296  protocol interface was returned in Interface.
1297  @retval EFI_UNSUPPORTED Handle does not support Protocol.
1298  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
1299  @retval EFI_ACCESS_DENIED Required attributes can't be supported in current environment.
1300  @retval EFI_ALREADY_STARTED Item on the open list already has requierd attributes whose agent
1301  handle is the same as AgentHandle.
1302 
1303 **/
1304 typedef
1305 EFI_STATUS
1307  IN EFI_HANDLE Handle,
1308  IN EFI_GUID *Protocol,
1309  OUT VOID **Interface, OPTIONAL
1310  IN EFI_HANDLE AgentHandle,
1312  IN UINT32 Attributes
1313  );
1314 
1315 
1316 /**
1317  Closes a protocol on a handle that was opened using OpenProtocol().
1318 
1319  @param[in] Handle The handle for the protocol interface that was previously opened
1320  with OpenProtocol(), and is now being closed.
1321  @param[in] Protocol The published unique identifier of the protocol.
1322  @param[in] AgentHandle The handle of the agent that is closing the protocol interface.
1323  @param[in] ControllerHandle If the agent that opened a protocol is a driver that follows the
1324  UEFI Driver Model, then this parameter is the controller handle
1325  that required the protocol interface.
1326 
1327  @retval EFI_SUCCESS The protocol instance was closed.
1328  @retval EFI_INVALID_PARAMETER 1) Handle is NULL.
1329  2) AgentHandle is NULL.
1330  3) ControllerHandle is not NULL and ControllerHandle is not a valid EFI_HANDLE.
1331  4) Protocol is NULL.
1332  @retval EFI_NOT_FOUND 1) Handle does not support the protocol specified by Protocol.
1333  2) The protocol interface specified by Handle and Protocol is not
1334  currently open by AgentHandle and ControllerHandle.
1335 
1336 **/
1337 typedef
1338 EFI_STATUS
1340  IN EFI_HANDLE Handle,
1341  IN EFI_GUID *Protocol,
1342  IN EFI_HANDLE AgentHandle,
1344  );
1345 
1346 ///
1347 /// EFI Oprn Protocol Information Entry
1348 ///
1349 typedef struct {
1355 
1356 /**
1357  Retrieves the list of agents that currently have a protocol interface opened.
1358 
1359  @param[in] Handle The handle for the protocol interface that is being queried.
1360  @param[in] Protocol The published unique identifier of the protocol.
1361  @param[out] EntryBuffer A pointer to a buffer of open protocol information in the form of
1362  EFI_OPEN_PROTOCOL_INFORMATION_ENTRY structures.
1363  @param[out] EntryCount A pointer to the number of entries in EntryBuffer.
1364 
1365  @retval EFI_SUCCESS The open protocol information was returned in EntryBuffer, and the
1366  number of entries was returned EntryCount.
1367  @retval EFI_OUT_OF_RESOURCES There are not enough resources available to allocate EntryBuffer.
1368  @retval EFI_NOT_FOUND Handle does not support the protocol specified by Protocol.
1369 
1370 **/
1371 typedef
1372 EFI_STATUS
1374  IN EFI_HANDLE Handle,
1375  IN EFI_GUID *Protocol,
1377  OUT UINTN *EntryCount
1378  );
1379 
1380 /**
1381  Retrieves the list of protocol interface GUIDs that are installed on a handle in a buffer allocated
1382  from pool.
1383 
1384  @param[in] Handle The handle from which to retrieve the list of protocol interface
1385  GUIDs.
1386  @param[out] ProtocolBuffer A pointer to the list of protocol interface GUID pointers that are
1387  installed on Handle.
1388  @param[out] ProtocolBufferCount A pointer to the number of GUID pointers present in
1389  ProtocolBuffer.
1390 
1391  @retval EFI_SUCCESS The list of protocol interface GUIDs installed on Handle was returned in
1392  ProtocolBuffer. The number of protocol interface GUIDs was
1393  returned in ProtocolBufferCount.
1394  @retval EFI_OUT_OF_RESOURCES There is not enough pool memory to store the results.
1395  @retval EFI_INVALID_PARAMETER Handle is NULL.
1396  @retval EFI_INVALID_PARAMETER Handle is not a valid EFI_HANDLE.
1397  @retval EFI_INVALID_PARAMETER ProtocolBuffer is NULL.
1398  @retval EFI_INVALID_PARAMETER ProtocolBufferCount is NULL.
1399 
1400 **/
1401 typedef
1402 EFI_STATUS
1404  IN EFI_HANDLE Handle,
1405  OUT EFI_GUID ***ProtocolBuffer,
1406  OUT UINTN *ProtocolBufferCount
1407  );
1408 
1409 /**
1410  Creates an event that is to be signaled whenever an interface is installed for a specified protocol.
1411 
1412  @param[in] Protocol The numeric ID of the protocol for which the event is to be registered.
1413  @param[in] Event Event that is to be signaled whenever a protocol interface is registered
1414  for Protocol.
1415  @param[out] Registration A pointer to a memory location to receive the registration value.
1416 
1417  @retval EFI_SUCCESS The notification event has been registered.
1418  @retval EFI_OUT_OF_RESOURCES Space for the notification event could not be allocated.
1419  @retval EFI_INVALID_PARAMETER Protocol is NULL.
1420  @retval EFI_INVALID_PARAMETER Event is NULL.
1421  @retval EFI_INVALID_PARAMETER Registration is NULL.
1422 
1423 **/
1424 typedef
1425 EFI_STATUS
1427  IN EFI_GUID *Protocol,
1428  IN EFI_EVENT Event,
1429  OUT VOID **Registration
1430  );
1431 
1432 ///
1433 /// Enumeration of EFI Locate Search Types
1434 ///
1435 typedef enum {
1436  ///
1437  /// Retrieve all the handles in the handle database.
1438  ///
1440  ///
1441  /// Retrieve the next handle fron a RegisterProtocolNotify() event.
1442  ///
1444  ///
1445  /// Retrieve the set of handles from the handle database that support a
1446  /// specified protocol.
1447  ///
1450 
1451 /**
1452  Returns an array of handles that support a specified protocol.
1453 
1454  @param[in] SearchType Specifies which handle(s) are to be returned.
1455  @param[in] Protocol Specifies the protocol to search by.
1456  @param[in] SearchKey Specifies the search key.
1457  @param[in, out] BufferSize On input, the size in bytes of Buffer. On output, the size in bytes of
1458  the array returned in Buffer (if the buffer was large enough) or the
1459  size, in bytes, of the buffer needed to obtain the array (if the buffer was
1460  not large enough).
1461  @param[out] Buffer The buffer in which the array is returned.
1462 
1463  @retval EFI_SUCCESS The array of handles was returned.
1464  @retval EFI_NOT_FOUND No handles match the search.
1465  @retval EFI_BUFFER_TOO_SMALL The BufferSize is too small for the result.
1466  @retval EFI_INVALID_PARAMETER SearchType is not a member of EFI_LOCATE_SEARCH_TYPE.
1467  @retval EFI_INVALID_PARAMETER SearchType is ByRegisterNotify and SearchKey is NULL.
1468  @retval EFI_INVALID_PARAMETER SearchType is ByProtocol and Protocol is NULL.
1469  @retval EFI_INVALID_PARAMETER One or more matches are found and BufferSize is NULL.
1470  @retval EFI_INVALID_PARAMETER BufferSize is large enough for the result and Buffer is NULL.
1471 
1472 **/
1473 typedef
1474 EFI_STATUS
1476  IN EFI_LOCATE_SEARCH_TYPE SearchType,
1478  IN VOID *SearchKey, OPTIONAL
1481  );
1482 
1483 /**
1484  Locates the handle to a device on the device path that supports the specified protocol.
1485 
1486  @param[in] Protocol Specifies the protocol to search for.
1487  @param[in, out] DevicePath On input, a pointer to a pointer to the device path. On output, the device
1488  path pointer is modified to point to the remaining part of the device
1489  path.
1490  @param[out] Device A pointer to the returned device handle.
1491 
1492  @retval EFI_SUCCESS The resulting handle was returned.
1493  @retval EFI_NOT_FOUND No handles match the search.
1494  @retval EFI_INVALID_PARAMETER Protocol is NULL.
1495  @retval EFI_INVALID_PARAMETER DevicePath is NULL.
1496  @retval EFI_INVALID_PARAMETER A handle matched the search and Device is NULL.
1497 
1498 **/
1499 typedef
1500 EFI_STATUS
1502  IN EFI_GUID *Protocol,
1503  IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath,
1504  OUT EFI_HANDLE *Device
1505  );
1506 
1507 /**
1508  Adds, updates, or removes a configuration table entry from the EFI System Table.
1509 
1510  @param[in] Guid A pointer to the GUID for the entry to add, update, or remove.
1511  @param[in] Table A pointer to the configuration table for the entry to add, update, or
1512  remove. May be NULL.
1513 
1514  @retval EFI_SUCCESS The (Guid, Table) pair was added, updated, or removed.
1515  @retval EFI_NOT_FOUND An attempt was made to delete a nonexistent entry.
1516  @retval EFI_INVALID_PARAMETER Guid is NULL.
1517  @retval EFI_OUT_OF_RESOURCES There is not enough memory available to complete the operation.
1518 
1519 **/
1520 typedef
1521 EFI_STATUS
1523  IN EFI_GUID *Guid,
1524  IN VOID *Table
1525  );
1526 
1527 /**
1528  Returns an array of handles that support the requested protocol in a buffer allocated from pool.
1529 
1530  @param[in] SearchType Specifies which handle(s) are to be returned.
1531  @param[in] Protocol Provides the protocol to search by.
1532  This parameter is only valid for a SearchType of ByProtocol.
1533  @param[in] SearchKey Supplies the search key depending on the SearchType.
1534  @param[in, out] NoHandles The number of handles returned in Buffer.
1535  @param[out] Buffer A pointer to the buffer to return the requested array of handles that
1536  support Protocol.
1537 
1538  @retval EFI_SUCCESS The array of handles was returned in Buffer, and the number of
1539  handles in Buffer was returned in NoHandles.
1540  @retval EFI_NOT_FOUND No handles match the search.
1541  @retval EFI_OUT_OF_RESOURCES There is not enough pool memory to store the matching results.
1542  @retval EFI_INVALID_PARAMETER NoHandles is NULL.
1543  @retval EFI_INVALID_PARAMETER Buffer is NULL.
1544 
1545 **/
1546 typedef
1547 EFI_STATUS
1549  IN EFI_LOCATE_SEARCH_TYPE SearchType,
1551  IN VOID *SearchKey, OPTIONAL
1552  IN OUT UINTN *NoHandles,
1554  );
1555 
1556 /**
1557  Returns the first protocol instance that matches the given protocol.
1558 
1559  @param[in] Protocol Provides the protocol to search for.
1560  @param[in] Registration Optional registration key returned from
1561  RegisterProtocolNotify().
1562  @param[out] Interface On return, a pointer to the first interface that matches Protocol and
1563  Registration.
1564 
1565  @retval EFI_SUCCESS A protocol instance matching Protocol was found and returned in
1566  Interface.
1567  @retval EFI_NOT_FOUND No protocol instances were found that match Protocol and
1568  Registration.
1569  @retval EFI_INVALID_PARAMETER Interface is NULL.
1570 
1571 **/
1572 typedef
1573 EFI_STATUS
1575  IN EFI_GUID *Protocol,
1576  IN VOID *Registration, OPTIONAL
1577  OUT VOID **Interface
1578  );
1579 
1580 ///
1581 /// EFI Capsule Block Descriptor
1582 ///
1583 typedef struct {
1584  ///
1585  /// Length in bytes of the data pointed to by DataBlock/ContinuationPointer.
1586  ///
1588  union {
1589  ///
1590  /// Physical address of the data block. This member of the union is
1591  /// used if Length is not equal to zero.
1592  ///
1594  ///
1595  /// Physical address of another block of
1596  /// EFI_CAPSULE_BLOCK_DESCRIPTOR structures. This
1597  /// member of the union is used if Length is equal to zero. If
1598  /// ContinuationPointer is zero this entry represents the end of the list.
1599  ///
1601  } Union;
1603 
1604 ///
1605 /// EFI Capsule Header.
1606 ///
1607 typedef struct {
1608  ///
1609  /// A GUID that defines the contents of a capsule.
1610  ///
1612  ///
1613  /// The size of the capsule header. This may be larger than the size of
1614  /// the EFI_CAPSULE_HEADER since CapsuleGuid may imply
1615  /// extended header entries
1616  ///
1618  ///
1619  /// Bit-mapped list describing the capsule attributes. The Flag values
1620  /// of 0x0000 - 0xFFFF are defined by CapsuleGuid. Flag values
1621  /// of 0x10000 - 0xFFFFFFFF are defined by this specification
1622  ///
1624  ///
1625  /// Size in bytes of the capsule.
1626  ///
1629 
1630 ///
1631 /// The EFI System Table entry must point to an array of capsules
1632 /// that contain the same CapsuleGuid value. The array must be
1633 /// prefixed by a UINT32 that represents the size of the array of capsules.
1634 ///
1635 typedef struct {
1636  ///
1637  /// the size of the array of capsules.
1638  ///
1640  ///
1641  /// Point to an array of capsules that contain the same CapsuleGuid value.
1642  ///
1643  VOID* CapsulePtr[1];
1645 
1646 #define CAPSULE_FLAGS_PERSIST_ACROSS_RESET 0x00010000
1647 #define CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE 0x00020000
1648 #define CAPSULE_FLAGS_INITIATE_RESET 0x00040000
1649 
1650 /**
1651  Passes capsules to the firmware with both virtual and physical mapping. Depending on the intended
1652  consumption, the firmware may process the capsule immediately. If the payload should persist
1653  across a system reset, the reset value returned from EFI_QueryCapsuleCapabilities must
1654  be passed into ResetSystem() and will cause the capsule to be processed by the firmware as
1655  part of the reset process.
1656 
1657  @param[in] CapsuleHeaderArray Virtual pointer to an array of virtual pointers to the capsules
1658  being passed into update capsule.
1659  @param[in] CapsuleCount Number of pointers to EFI_CAPSULE_HEADER in
1660  CaspuleHeaderArray.
1661  @param[in] ScatterGatherList Physical pointer to a set of
1662  EFI_CAPSULE_BLOCK_DESCRIPTOR that describes the
1663  location in physical memory of a set of capsules.
1664 
1665  @retval EFI_SUCCESS Valid capsule was passed. If
1666  CAPSULE_FLAGS_PERSIT_ACROSS_RESET is not set, the
1667  capsule has been successfully processed by the firmware.
1668  @retval EFI_INVALID_PARAMETER CapsuleSize is NULL, or an incompatible set of flags were
1669  set in the capsule header.
1670  @retval EFI_INVALID_PARAMETER CapsuleCount is 0.
1671  @retval EFI_DEVICE_ERROR The capsule update was started, but failed due to a device error.
1672  @retval EFI_UNSUPPORTED The capsule type is not supported on this platform.
1673  @retval EFI_OUT_OF_RESOURCES When ExitBootServices() has been previously called this error indicates the capsule
1674  is compatible with this platform but is not capable of being submitted or processed
1675  in runtime. The caller may resubmit the capsule prior to ExitBootServices().
1676  @retval EFI_OUT_OF_RESOURCES When ExitBootServices() has not been previously called then this error indicates
1677  the capsule is compatible with this platform but there are insufficient resources to process.
1678 
1679 **/
1680 typedef
1681 EFI_STATUS
1683  IN EFI_CAPSULE_HEADER **CapsuleHeaderArray,
1684  IN UINTN CapsuleCount,
1685  IN EFI_PHYSICAL_ADDRESS ScatterGatherList OPTIONAL
1686  );
1687 
1688 /**
1689  Returns if the capsule can be supported via UpdateCapsule().
1690 
1691  @param[in] CapsuleHeaderArray Virtual pointer to an array of virtual pointers to the capsules
1692  being passed into update capsule.
1693  @param[in] CapsuleCount Number of pointers to EFI_CAPSULE_HEADER in
1694  CaspuleHeaderArray.
1695  @param[out] MaxiumCapsuleSize On output the maximum size that UpdateCapsule() can
1696  support as an argument to UpdateCapsule() via
1697  CapsuleHeaderArray and ScatterGatherList.
1698  @param[out] ResetType Returns the type of reset required for the capsule update.
1699 
1700  @retval EFI_SUCCESS Valid answer returned.
1701  @retval EFI_UNSUPPORTED The capsule type is not supported on this platform, and
1702  MaximumCapsuleSize and ResetType are undefined.
1703  @retval EFI_INVALID_PARAMETER MaximumCapsuleSize is NULL.
1704  @retval EFI_OUT_OF_RESOURCES When ExitBootServices() has been previously called this error indicates the capsule
1705  is compatible with this platform but is not capable of being submitted or processed
1706  in runtime. The caller may resubmit the capsule prior to ExitBootServices().
1707  @retval EFI_OUT_OF_RESOURCES When ExitBootServices() has not been previously called then this error indicates
1708  the capsule is compatible with this platform but there are insufficient resources to process.
1709 
1710 **/
1711 typedef
1712 EFI_STATUS
1714  IN EFI_CAPSULE_HEADER **CapsuleHeaderArray,
1715  IN UINTN CapsuleCount,
1716  OUT UINT64 *MaximumCapsuleSize,
1717  OUT EFI_RESET_TYPE *ResetType
1718  );
1719 
1720 /**
1721  Returns information about the EFI variables.
1722 
1723  @param[in] Attributes Attributes bitmask to specify the type of variables on
1724  which to return information.
1725  @param[out] MaximumVariableStorageSize On output the maximum size of the storage space
1726  available for the EFI variables associated with the
1727  attributes specified.
1728  @param[out] RemainingVariableStorageSize Returns the remaining size of the storage space
1729  available for the EFI variables associated with the
1730  attributes specified.
1731  @param[out] MaximumVariableSize Returns the maximum size of the individual EFI
1732  variables associated with the attributes specified.
1733 
1734  @retval EFI_SUCCESS Valid answer returned.
1735  @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits was supplied
1736  @retval EFI_UNSUPPORTED The attribute is not supported on this platform, and the
1737  MaximumVariableStorageSize,
1738  RemainingVariableStorageSize, MaximumVariableSize
1739  are undefined.
1740 
1741 **/
1742 typedef
1743 EFI_STATUS
1745  IN UINT32 Attributes,
1746  OUT UINT64 *MaximumVariableStorageSize,
1747  OUT UINT64 *RemainingVariableStorageSize,
1748  OUT UINT64 *MaximumVariableSize
1749  );
1750 
1751 //
1752 // Firmware should stop at a firmware user interface on next boot
1753 //
1754 #define EFI_OS_INDICATIONS_BOOT_TO_FW_UI 0x0000000000000001
1755 #define EFI_OS_INDICATIONS_TIMESTAMP_REVOCATION 0x0000000000000002
1756 #define EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED 0x0000000000000004
1757 #define EFI_OS_INDICATIONS_FMP_CAPSULE_SUPPORTED 0x0000000000000008
1758 #define EFI_OS_INDICATIONS_CAPSULE_RESULT_VAR_SUPPORTED 0x0000000000000010
1759 #define EFI_OS_INDICATIONS_START_PLATFORM_RECOVERY 0x0000000000000040
1760 
1761 //
1762 // EFI Runtime Services Table
1763 //
1764 #define EFI_SYSTEM_TABLE_SIGNATURE SIGNATURE_64 ('I','B','I',' ','S','Y','S','T')
1765 #define EFI_2_60_SYSTEM_TABLE_REVISION ((2 << 16) | (60))
1766 #define EFI_2_50_SYSTEM_TABLE_REVISION ((2 << 16) | (50))
1767 #define EFI_2_40_SYSTEM_TABLE_REVISION ((2 << 16) | (40))
1768 #define EFI_2_31_SYSTEM_TABLE_REVISION ((2 << 16) | (31))
1769 #define EFI_2_30_SYSTEM_TABLE_REVISION ((2 << 16) | (30))
1770 #define EFI_2_20_SYSTEM_TABLE_REVISION ((2 << 16) | (20))
1771 #define EFI_2_10_SYSTEM_TABLE_REVISION ((2 << 16) | (10))
1772 #define EFI_2_00_SYSTEM_TABLE_REVISION ((2 << 16) | (00))
1773 #define EFI_1_10_SYSTEM_TABLE_REVISION ((1 << 16) | (10))
1774 #define EFI_1_02_SYSTEM_TABLE_REVISION ((1 << 16) | (02))
1775 #define EFI_SYSTEM_TABLE_REVISION EFI_2_60_SYSTEM_TABLE_REVISION
1776 #define EFI_SPECIFICATION_VERSION EFI_SYSTEM_TABLE_REVISION
1777 
1778 #define EFI_RUNTIME_SERVICES_SIGNATURE SIGNATURE_64 ('R','U','N','T','S','E','R','V')
1779 #define EFI_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_VERSION
1780 
1781 ///
1782 /// EFI Runtime Services Table.
1783 ///
1784 typedef struct {
1785  ///
1786  /// The table header for the EFI Runtime Services Table.
1787  ///
1789 
1790  //
1791  // Time Services
1792  //
1797 
1798  //
1799  // Virtual Memory Services
1800  //
1803 
1804  //
1805  // Variable Services
1806  //
1810 
1811  //
1812  // Miscellaneous Services
1813  //
1816 
1817  //
1818  // UEFI 2.0 Capsule Services
1819  //
1822 
1823  //
1824  // Miscellaneous UEFI 2.0 Service
1825  //
1828 
1829 
1830 #define EFI_BOOT_SERVICES_SIGNATURE SIGNATURE_64 ('B','O','O','T','S','E','R','V')
1831 #define EFI_BOOT_SERVICES_REVISION EFI_SPECIFICATION_VERSION
1832 
1833 ///
1834 /// EFI Boot Services Table.
1835 ///
1836 typedef struct {
1837  ///
1838  /// The table header for the EFI Boot Services Table.
1839  ///
1841 
1842  //
1843  // Task Priority Services
1844  //
1847 
1848  //
1849  // Memory Services
1850  //
1856 
1857  //
1858  // Event & Timer Services
1859  //
1866 
1867  //
1868  // Protocol Handler Services
1869  //
1879 
1880  //
1881  // Image Services
1882  //
1888 
1889  //
1890  // Miscellaneous Services
1891  //
1895 
1896  //
1897  // DriverSupport Services
1898  //
1901 
1902  //
1903  // Open and Close Protocol Services
1904  //
1908 
1909  //
1910  // Library Services
1911  //
1917 
1918  //
1919  // 32-bit CRC Services
1920  //
1922 
1923  //
1924  // Miscellaneous Services
1925  //
1930 
1931 ///
1932 /// Contains a set of GUID/pointer pairs comprised of the ConfigurationTable field in the
1933 /// EFI System Table.
1934 ///
1935 typedef struct {
1936  ///
1937  /// The 128-bit GUID value that uniquely identifies the system configuration table.
1938  ///
1940  ///
1941  /// A pointer to the table associated with VendorGuid.
1942  ///
1945 
1946 ///
1947 /// EFI System Table
1948 ///
1949 typedef struct {
1950  ///
1951  /// The table header for the EFI System Table.
1952  ///
1954  ///
1955  /// A pointer to a null terminated string that identifies the vendor
1956  /// that produces the system firmware for the platform.
1957  ///
1959  ///
1960  /// A firmware vendor specific value that identifies the revision
1961  /// of the system firmware for the platform.
1962  ///
1964  ///
1965  /// The handle for the active console input device. This handle must support
1966  /// EFI_SIMPLE_TEXT_INPUT_PROTOCOL and EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL.
1967  ///
1969  ///
1970  /// A pointer to the EFI_SIMPLE_TEXT_INPUT_PROTOCOL interface that is
1971  /// associated with ConsoleInHandle.
1972  ///
1974  ///
1975  /// The handle for the active console output device.
1976  ///
1978  ///
1979  /// A pointer to the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL interface
1980  /// that is associated with ConsoleOutHandle.
1981  ///
1983  ///
1984  /// The handle for the active standard error console device.
1985  /// This handle must support the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.
1986  ///
1988  ///
1989  /// A pointer to the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL interface
1990  /// that is associated with StandardErrorHandle.
1991  ///
1993  ///
1994  /// A pointer to the EFI Runtime Services Table.
1995  ///
1997  ///
1998  /// A pointer to the EFI Boot Services Table.
1999  ///
2001  ///
2002  /// The number of system configuration tables in the buffer ConfigurationTable.
2003  ///
2005  ///
2006  /// A pointer to the system configuration tables.
2007  /// The number of entries in the table is NumberOfTableEntries.
2008  ///
2011 
2012 /**
2013  This is the declaration of an EFI image entry point. This entry point is
2014  the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
2015  both device drivers and bus drivers.
2016 
2017  @param[in] ImageHandle The firmware allocated handle for the UEFI image.
2018  @param[in] SystemTable A pointer to the EFI System Table.
2019 
2020  @retval EFI_SUCCESS The operation completed successfully.
2021  @retval Others An unexpected error occurred.
2022 **/
2023 typedef
2024 EFI_STATUS
2026  IN EFI_HANDLE ImageHandle,
2027  IN EFI_SYSTEM_TABLE *SystemTable
2028  );
2029 
2030 //
2031 // EFI Load Option. This data structure describes format of UEFI boot option variables.
2032 //
2033 // NOTE: EFI Load Option is a byte packed buffer of variable length fields.
2034 // The first two fields have fixed length. They are declared as members of the
2035 // EFI_LOAD_OPTION structure. All the other fields are variable length fields.
2036 // They are listed in the comment block below for reference purposes.
2037 //
2038 #pragma pack(1)
2039 typedef struct _EFI_LOAD_OPTION {
2040  ///
2041  /// The attributes for this load option entry. All unused bits must be zero
2042  /// and are reserved by the UEFI specification for future growth.
2043  ///
2045  ///
2046  /// Length in bytes of the FilePathList. OptionalData starts at offset
2047  /// sizeof(UINT32) + sizeof(UINT16) + StrSize(Description) + FilePathListLength
2048  /// of the EFI_LOAD_OPTION descriptor.
2049  ///
2051  ///
2052  /// The user readable description for the load option.
2053  /// This field ends with a Null character.
2054  ///
2055  // CHAR16 Description[];
2056  ///
2057  /// A packed array of UEFI device paths. The first element of the array is a
2058  /// device path that describes the device and location of the Image for this
2059  /// load option. The FilePathList[0] is specific to the device type. Other
2060  /// device paths may optionally exist in the FilePathList, but their usage is
2061  /// OSV specific. Each element in the array is variable length, and ends at
2062  /// the device path end structure. Because the size of Description is
2063  /// arbitrary, this data structure is not guaranteed to be aligned on a
2064  /// natural boundary. This data structure may have to be copied to an aligned
2065  /// natural boundary before it is used.
2066  ///
2067  // EFI_DEVICE_PATH_PROTOCOL FilePathList[];
2068  ///
2069  /// The remaining bytes in the load option descriptor are a binary data buffer
2070  /// that is passed to the loaded image. If the field is zero bytes long, a
2071  /// NULL pointer is passed to the loaded image. The number of bytes in
2072  /// OptionalData can be computed by subtracting the starting offset of
2073  /// OptionalData from total size in bytes of the EFI_LOAD_OPTION.
2074  ///
2075  // UINT8 OptionalData[];
2076 } EFI_LOAD_OPTION;
2077 #pragma pack()
2078 
2079 //
2080 // EFI Load Options Attributes
2081 //
2082 #define LOAD_OPTION_ACTIVE 0x00000001
2083 #define LOAD_OPTION_FORCE_RECONNECT 0x00000002
2084 #define LOAD_OPTION_HIDDEN 0x00000008
2085 #define LOAD_OPTION_CATEGORY 0x00001F00
2086 
2087 #define LOAD_OPTION_CATEGORY_BOOT 0x00000000
2088 #define LOAD_OPTION_CATEGORY_APP 0x00000100
2089 
2090 #define EFI_BOOT_OPTION_SUPPORT_KEY 0x00000001
2091 #define EFI_BOOT_OPTION_SUPPORT_APP 0x00000002
2092 #define EFI_BOOT_OPTION_SUPPORT_SYSPREP 0x00000010
2093 #define EFI_BOOT_OPTION_SUPPORT_COUNT 0x00000300
2094 
2095 ///
2096 /// EFI Boot Key Data
2097 ///
2098 typedef union {
2099  struct {
2100  ///
2101  /// Indicates the revision of the EFI_KEY_OPTION structure. This revision level should be 0.
2102  ///
2104  ///
2105  /// Either the left or right Shift keys must be pressed (1) or must not be pressed (0).
2106  ///
2108  ///
2109  /// Either the left or right Control keys must be pressed (1) or must not be pressed (0).
2110  ///
2112  ///
2113  /// Either the left or right Alt keys must be pressed (1) or must not be pressed (0).
2114  ///
2116  ///
2117  /// Either the left or right Logo keys must be pressed (1) or must not be pressed (0).
2118  ///
2120  ///
2121  /// The Menu key must be pressed (1) or must not be pressed (0).
2122  ///
2124  ///
2125  /// The SysReq key must be pressed (1) or must not be pressed (0).
2126  ///
2129  ///
2130  /// Specifies the actual number of entries in EFI_KEY_OPTION.Keys, from 0-3. If
2131  /// zero, then only the shift state is considered. If more than one, then the boot option will
2132  /// only be launched if all of the specified keys are pressed with the same shift state.
2133  ///
2135  } Options;
2138 
2139 ///
2140 /// EFI Key Option.
2141 ///
2142 #pragma pack(1)
2143 typedef struct {
2144  ///
2145  /// Specifies options about how the key will be processed.
2146  ///
2148  ///
2149  /// The CRC-32 which should match the CRC-32 of the entire EFI_LOAD_OPTION to
2150  /// which BootOption refers. If the CRC-32s do not match this value, then this key
2151  /// option is ignored.
2152  ///
2154  ///
2155  /// The Boot#### option which will be invoked if this key is pressed and the boot option
2156  /// is active (LOAD_OPTION_ACTIVE is set).
2157  ///
2159  ///
2160  /// The key codes to compare against those returned by the
2161  /// EFI_SIMPLE_TEXT_INPUT and EFI_SIMPLE_TEXT_INPUT_EX protocols.
2162  /// The number of key codes (0-3) is specified by the EFI_KEY_CODE_COUNT field in KeyOptions.
2163  ///
2164  //EFI_INPUT_KEY Keys[];
2165 } EFI_KEY_OPTION;
2166 #pragma pack()
2167 
2168 //
2169 // EFI File location to boot from on removable media devices
2170 //
2171 #define EFI_REMOVABLE_MEDIA_FILE_NAME_IA32 L"\\EFI\\BOOT\\BOOTIA32.EFI"
2172 #define EFI_REMOVABLE_MEDIA_FILE_NAME_IA64 L"\\EFI\\BOOT\\BOOTIA64.EFI"
2173 #define EFI_REMOVABLE_MEDIA_FILE_NAME_X64 L"\\EFI\\BOOT\\BOOTX64.EFI"
2174 #define EFI_REMOVABLE_MEDIA_FILE_NAME_ARM L"\\EFI\\BOOT\\BOOTARM.EFI"
2175 #define EFI_REMOVABLE_MEDIA_FILE_NAME_AARCH64 L"\\EFI\\BOOT\\BOOTAA64.EFI"
2176 
2177 #if defined (MDE_CPU_IA32)
2178  #define EFI_REMOVABLE_MEDIA_FILE_NAME EFI_REMOVABLE_MEDIA_FILE_NAME_IA32
2179 #elif defined (MDE_CPU_IPF)
2180  #define EFI_REMOVABLE_MEDIA_FILE_NAME EFI_REMOVABLE_MEDIA_FILE_NAME_IA64
2181 #elif defined (MDE_CPU_X64)
2182  #define EFI_REMOVABLE_MEDIA_FILE_NAME EFI_REMOVABLE_MEDIA_FILE_NAME_X64
2183 #elif defined (MDE_CPU_EBC)
2184 #elif defined (MDE_CPU_ARM)
2185  #define EFI_REMOVABLE_MEDIA_FILE_NAME EFI_REMOVABLE_MEDIA_FILE_NAME_ARM
2186 #elif defined (MDE_CPU_AARCH64)
2187  #define EFI_REMOVABLE_MEDIA_FILE_NAME EFI_REMOVABLE_MEDIA_FILE_NAME_AARCH64
2188 #else
2189  #error Unknown Processor Type
2190 #endif
2191 
2192 #include <ipxe/efi/Uefi/UefiPxe.h>
2193 #include <ipxe/efi/Uefi/UefiGpt.h>
2195 
2196 #endif
#define OPTIONAL
Passing the datum to the function is optional, and a NULL is passed if the value is not supplied.
Definition: Base.h:340
EFI_QUERY_VARIABLE_INFO QueryVariableInfo
Definition: UefiSpec.h:1826
EFI_BOOT_SERVICES * BootServices
A pointer to the EFI Boot Services Table.
Definition: UefiSpec.h:2000
EFI_SET_TIME SetTime
Definition: UefiSpec.h:1794
EFI_SET_WATCHDOG_TIMER SetWatchdogTimer
Definition: UefiSpec.h:1894
UINT32 InputKeyCount
Specifies the actual number of entries in EFI_KEY_OPTION.Keys, from 0-3.
Definition: UefiSpec.h:2134
EFI_STATUS(EFIAPI * EFI_ALLOCATE_PAGES)(IN EFI_ALLOCATE_TYPE Type, IN EFI_MEMORY_TYPE MemoryType, IN UINTN Pages, IN OUT EFI_PHYSICAL_ADDRESS *Memory)
Allocates memory pages from the system.
Definition: UefiSpec.h:159
EFI_TABLE_HEADER Hdr
The table header for the EFI Runtime Services Table.
Definition: UefiSpec.h:1788
EFI_GET_WAKEUP_TIME GetWakeupTime
Definition: UefiSpec.h:1795
EFI Oprn Protocol Information Entry.
Definition: UefiSpec.h:1349
UINT16 FilePathListLength
Length in bytes of the FilePathList.
Definition: UefiSpec.h:2050
EFI_STATUS(EFIAPI * EFI_INSTALL_PROTOCOL_INTERFACE)(IN OUT EFI_HANDLE *Handle, IN EFI_GUID *Protocol, IN EFI_INTERFACE_TYPE InterfaceType, IN VOID *Interface)
Installs a protocol interface on a device handle.
Definition: UefiSpec.h:1147
FILE_LICENCE(BSD3)
UINT32 Flags
Bit-mapped list describing the capsule attributes.
Definition: UefiSpec.h:1623
EFI_RAISE_TPL RaiseTPL
Definition: UefiSpec.h:1845
An event is to be signaled periodically at a specified interval from the current time.
Definition: UefiSpec.h:489
UINT32 ShiftPressed
Either the left or right Shift keys must be pressed (1) or must not be pressed (0).
Definition: UefiSpec.h:2107
EFI_HANDLE ControllerHandle
Definition: UefiSpec.h:1351
The device path protocol as defined in UEFI 2.0.
EFI_STATUS(EFIAPI * EFI_GET_NEXT_HIGH_MONO_COUNT)(OUT UINT32 *HighCount)
Returns the next high 32 bits of the platform's monotonic counter.
Definition: UefiSpec.h:1056
EFI_TPL(EFIAPI * EFI_RAISE_TPL)(IN EFI_TPL NewTpl)
Raises a task's priority level and returns its previous level.
Definition: UefiSpec.h:606
UINT32 ControlPressed
Either the left or right Control keys must be pressed (1) or must not be pressed (0).
Definition: UefiSpec.h:2111
UINT32 PackedValue
Definition: UefiSpec.h:2136
EFI_HANDLE AgentHandle
Definition: UefiSpec.h:1350
UINT8 Type
Definition: Acpi10.h:141
EFI_STATUS(EFIAPI * EFI_GET_WAKEUP_TIME)(OUT BOOLEAN *Enabled, OUT BOOLEAN *Pending, OUT EFI_TIME *Time)
Returns the current wakeup alarm clock setting.
Definition: UefiSpec.h:813
CHAR16 * FirmwareVendor
A pointer to a null terminated string that identifies the vendor that produces the system firmware fo...
Definition: UefiSpec.h:1958
EFI_LOCATE_PROTOCOL LocateProtocol
Definition: UefiSpec.h:1914
EFI_STALL Stall
Definition: UefiSpec.h:1893
EFI_STATUS(EFIAPI * EFI_SET_TIME)(IN EFI_TIME *Time)
Sets the current local time and date information.
Definition: UefiSpec.h:792
An event is to be signaled once at a specified interval from the current time.
Definition: UefiSpec.h:493
EFI_CONVERT_POINTER ConvertPointer
Definition: UefiSpec.h:1802
Definition of an EFI memory descriptor.
Definition: UefiSpec.h:106
EFI_QUERY_CAPSULE_CAPABILITIES QueryCapsuleCapabilities
Definition: UefiSpec.h:1821
EFI_STATUS(EFIAPI * EFI_LOCATE_DEVICE_PATH)(IN EFI_GUID *Protocol, IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath, OUT EFI_HANDLE *Device)
Locates the handle to a device on the device path that supports the specified protocol.
Definition: UefiSpec.h:1501
EFI_STATUS(EFIAPI * EFI_WAIT_FOR_EVENT)(IN UINTN NumberOfEvents, IN EFI_EVENT *Event, OUT UINTN *Index)
Stops execution until an event is signaled.
Definition: UefiSpec.h:550
128 bit buffer containing a unique identifier value.
Definition: Base.h:263
UINT32 FirmwareRevision
A firmware vendor specific value that identifies the revision of the system firmware for the platform...
Definition: UefiSpec.h:1963
struct _EFI_LOAD_OPTION EFI_LOAD_OPTION
EFI_STATUS(EFIAPI * EFI_IMAGE_LOAD)(IN BOOLEAN BootPolicy, IN EFI_HANDLE ParentImageHandle, IN EFI_DEVICE_PATH_PROTOCOL *DevicePath, IN VOID *SourceBuffer OPTIONAL, IN UINTN SourceSize, OUT EFI_HANDLE *ImageHandle)
Loads an EFI image into memory.
Definition: UefiSpec.h:872
Retrieve all the handles in the handle database.
Definition: UefiSpec.h:1439
The EFI_SIMPLE_TEXT_INPUT_PROTOCOL is used on the ConsoleIn device.
Definition: SimpleTextIn.h:124
EFI_STATUS(EFIAPI * EFI_OPEN_PROTOCOL_INFORMATION)(IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, OUT EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer, OUT UINTN *EntryCount)
Retrieves the list of agents that currently have a protocol interface opened.
Definition: UefiSpec.h:1373
UINT32 CapsuleArrayNumber
the size of the array of capsules.
Definition: UefiSpec.h:1639
EFI_REINSTALL_PROTOCOL_INTERFACE ReinstallProtocolInterface
Definition: UefiSpec.h:1871
EFI_EXIT_BOOT_SERVICES ExitBootServices
Definition: UefiSpec.h:1887
EFI_UNINSTALL_PROTOCOL_INTERFACE UninstallProtocolInterface
Definition: UefiSpec.h:1872
EFI_RESET_TYPE
Enumeration of reset types.
VOID * EFI_EVENT
Handle to an event structure.
Definition: UefiBaseType.h:43
EFI_GUID VendorGuid
The 128-bit GUID value that uniquely identifies the system configuration table.
Definition: UefiSpec.h:1939
EFI_IMAGE_LOAD LoadImage
Definition: UefiSpec.h:1883
unsigned char BOOLEAN
Definition: ProcessorBind.h:61
EFI Boot Key Data.
Definition: UefiSpec.h:2098
EFI_STATUS(EFIAPI * EFI_LOCATE_HANDLE)(IN EFI_LOCATE_SEARCH_TYPE SearchType, IN EFI_GUID *Protocol, OPTIONAL IN VOID *SearchKey, OPTIONAL IN OUT UINTN *BufferSize, OUT EFI_HANDLE *Buffer)
Returns an array of handles that support a specified protocol.
Definition: UefiSpec.h:1475
EFI_STATUS(EFIAPI * EFI_FREE_PAGES)(IN EFI_PHYSICAL_ADDRESS Memory, IN UINTN Pages)
Frees memory pages.
Definition: UefiSpec.h:180
UINT32 Attributes
The attributes for this load option entry.
Definition: UefiSpec.h:2044
EFI_STATUS(EFIAPI * EFI_SIGNAL_EVENT)(IN EFI_EVENT Event)
Signals an event.
Definition: UefiSpec.h:530
EFI_GET_NEXT_HIGH_MONO_COUNT GetNextHighMonotonicCount
Definition: UefiSpec.h:1814
EFI_HANDLE ConsoleInHandle
The handle for the active console input device.
Definition: UefiSpec.h:1968
EFI_STATUS(EFIAPI * EFI_STALL)(IN UINTN Microseconds)
Induces a fine-grained stall.
Definition: UefiSpec.h:975
EFI_STATUS(EFIAPI * EFI_CALCULATE_CRC32)(IN VOID *Data, IN UINTN DataSize, OUT UINT32 *Crc32)
Computes and returns a 32-bit CRC for a data buffer.
Definition: UefiSpec.h:1077
Retrieve the next handle fron a RegisterProtocolNotify() event.
Definition: UefiSpec.h:1443
EFI_SET_MEM SetMem
Definition: UefiSpec.h:1927
unsigned int UINT32
Definition: ProcessorBind.h:56
UINT8 Length
Definition: Acpi10.h:139
EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES InstallMultipleProtocolInterfaces
Definition: UefiSpec.h:1915
This header file contains all of the PXE type definitions, structure prototypes, global variables and...
VOID(EFIAPI * EFI_RESTORE_TPL)(IN EFI_TPL OldTpl)
Restores a task's priority level to its previous value.
Definition: UefiSpec.h:618
UINT16_t BufferSize
Buffer size.
Definition: pxe_api.h:64
EFI_STATUS(EFIAPI * EFI_SET_TIMER)(IN EFI_EVENT Event, IN EFI_TIMER_DELAY Type, IN UINT64 TriggerTime)
Sets the type of timer and the trigger time for a timer event.
Definition: UefiSpec.h:514
unsigned short CHAR16
Definition: ProcessorBind.h:59
EFI_CLOSE_EVENT CloseEvent
Definition: UefiSpec.h:1864
EFI_TABLE_HEADER Hdr
The table header for the EFI Boot Services Table.
Definition: UefiSpec.h:1840
EFI_SET_TIMER SetTimer
Definition: UefiSpec.h:1861
EFI_STATUS(EFIAPI * EFI_CLOSE_PROTOCOL)(IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, IN EFI_HANDLE AgentHandle, IN EFI_HANDLE ControllerHandle)
Closes a protocol on a handle that was opened using OpenProtocol().
Definition: UefiSpec.h:1339
EFI_LOCATE_HANDLE LocateHandle
Definition: UefiSpec.h:1876
EFI_IMAGE_UNLOAD UnloadImage
Definition: UefiSpec.h:1886
EFI_BOOT_KEY_DATA KeyData
Specifies options about how the key will be processed.
Definition: UefiSpec.h:2147
This protocol can be used on any device handle to obtain generic path/location information concerning...
Definition: DevicePath.h:51
VOID(EFIAPI * EFI_EVENT_NOTIFY)(IN EFI_EVENT Event, IN VOID *Context)
Invoke a notification event.
Definition: UefiSpec.h:417
EFI_STATUS(EFIAPI * EFI_GET_NEXT_VARIABLE_NAME)(IN OUT UINTN *VariableNameSize, IN OUT CHAR16 *VariableName, IN OUT EFI_GUID *VendorGuid)
Enumerates the current variable names.
Definition: UefiSpec.h:678
EFI_CLOSE_PROTOCOL CloseProtocol
Definition: UefiSpec.h:1906
EFI_STATUS(EFIAPI * EFI_GET_TIME)(OUT EFI_TIME *Time, OUT EFI_TIME_CAPABILITIES *Capabilities OPTIONAL)
Returns the current time and date information, and the time-keeping capabilities of the hardware plat...
Definition: UefiSpec.h:775
EFI_CREATE_EVENT_EX CreateEventEx
Definition: UefiSpec.h:1928
unsigned char UINT8
Definition: ProcessorBind.h:62
UINT64 EFI_PHYSICAL_ADDRESS
64-bit physical memory address.
Definition: UefiBaseType.h:56
EFI_STATUS(EFIAPI * EFI_REINSTALL_PROTOCOL_INTERFACE)(IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, IN VOID *OldInterface, IN VOID *NewInterface)
Reinstalls a protocol interface on a device handle.
Definition: UefiSpec.h:1197
EFI_STATUS(EFIAPI * EFI_OPEN_PROTOCOL)(IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, OUT VOID **Interface, OPTIONAL IN EFI_HANDLE AgentHandle, IN EFI_HANDLE ControllerHandle, IN UINT32 Attributes)
Queries a handle to determine if it supports a specified protocol.
Definition: UefiSpec.h:1306
EFI_STATUS(EFIAPI * EFI_UNINSTALL_PROTOCOL_INTERFACE)(IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, IN VOID *Interface)
Removes a protocol interface from a device handle.
Definition: UefiSpec.h:1223
The SIMPLE_TEXT_OUTPUT protocol is used to control text-based output devices.
UINT64 NumberOfPages
Number of 4KB pages in the memory region.
Definition: UefiSpec.h:124
EFI_STATUS(EFIAPI * EFI_CREATE_EVENT)(IN UINT32 Type, IN EFI_TPL NotifyTpl, IN EFI_EVENT_NOTIFY NotifyFunction, IN VOID *NotifyContext, OUT EFI_EVENT *Event)
Creates an event.
Definition: UefiSpec.h:440
EFI_PHYSICAL_ADDRESS DataBlock
Physical address of the data block.
Definition: UefiSpec.h:1593
UINT16_t Size
Size of structure.
Definition: pxe_api.h:58
EFI_TABLE_HEADER Hdr
The table header for the EFI System Table.
Definition: UefiSpec.h:1953
EFI_STATUS(EFIAPI * EFI_EXIT)(IN EFI_HANDLE ImageHandle, IN EFI_STATUS ExitStatus, IN UINTN ExitDataSize, IN CHAR16 *ExitData OPTIONAL)
Terminates a loaded EFI image and returns control to boot services.
Definition: UefiSpec.h:925
UINT32 HeaderSize
The size of the capsule header.
Definition: UefiSpec.h:1617
UINT32 CapsuleImageSize
Size in bytes of the capsule.
Definition: UefiSpec.h:1627
An event's timer settings is to be cancelled and not trigger time is to be set/.
Definition: UefiSpec.h:485
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL * ConOut
A pointer to the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL interface that is associated with ConsoleOutHandle.
Definition: UefiSpec.h:1982
VOID(EFIAPI * EFI_SET_MEM)(IN VOID *Buffer, IN UINTN Size, IN UINT8 Value)
The SetMem() function fills a buffer with a specified value.
Definition: UefiSpec.h:1109
#define OUT
Definition: mlx_utils.h:29
EFI_STATUS(EFIAPI * EFI_SET_WAKEUP_TIME)(IN BOOLEAN Enable, IN EFI_TIME *Time OPTIONAL)
Sets the system wakeup alarm clock time.
Definition: UefiSpec.h:835
EFI_MEMORY_TYPE
Enumeration of memory types introduced in UEFI.
EFI_STATUS(EFIAPI * EFI_QUERY_VARIABLE_INFO)(IN UINT32 Attributes, OUT UINT64 *MaximumVariableStorageSize, OUT UINT64 *RemainingVariableStorageSize, OUT UINT64 *MaximumVariableSize)
Returns information about the EFI variables.
Definition: UefiSpec.h:1744
EFI_SET_VARIABLE SetVariable
Definition: UefiSpec.h:1809
UINT32 OpenCount
Definition: UefiSpec.h:1353
Allocate pages at a specified address.
Definition: UefiSpec.h:47
EFI_INSTALL_PROTOCOL_INTERFACE InstallProtocolInterface
Definition: UefiSpec.h:1870
UINT32 Attributes
Definition: UefiSpec.h:1352
EFI_STATUS(EFIAPI * EFI_LOCATE_HANDLE_BUFFER)(IN EFI_LOCATE_SEARCH_TYPE SearchType, IN EFI_GUID *Protocol, OPTIONAL IN VOID *SearchKey, OPTIONAL IN OUT UINTN *NoHandles, OUT EFI_HANDLE **Buffer)
Returns an array of handles that support the requested protocol in a buffer allocated from pool.
Definition: UefiSpec.h:1548
EFI_CREATE_EVENT CreateEvent
Definition: UefiSpec.h:1860
EFI_SIMPLE_TEXT_INPUT_PROTOCOL * ConIn
A pointer to the EFI_SIMPLE_TEXT_INPUT_PROTOCOL interface that is associated with ConsoleInHandle.
Definition: UefiSpec.h:1973
EFI_HANDLE_PROTOCOL HandleProtocol
Definition: UefiSpec.h:1873
EFI_REGISTER_PROTOCOL_NOTIFY RegisterProtocolNotify
Definition: UefiSpec.h:1875
EFI_COPY_MEM CopyMem
Definition: UefiSpec.h:1926
EFI_STATUS(EFIAPI * EFI_IMAGE_ENTRY_POINT)(IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable)
This is the declaration of an EFI image entry point.
Definition: UefiSpec.h:2025
EFI_GET_VARIABLE GetVariable
Definition: UefiSpec.h:1807
UINT32 Resolution
Provides the reporting resolution of the real-time clock device in counts per second.
Definition: UefiSpec.h:742
BOOLEAN SetsToZero
A TRUE indicates that a time set operation clears the device's time below the Resolution reporting le...
Definition: UefiSpec.h:757
EFI_GUID CapsuleGuid
A GUID that defines the contents of a capsule.
Definition: UefiSpec.h:1611
Maximum enumeration value that may be used for bounds checking.
Definition: UefiSpec.h:51
unsigned short UINT16
Definition: ProcessorBind.h:58
EFI Guid Partition Table Format Definition.
This file defines the encoding for the VFR (Visual Form Representation) language.
EFI_SIGNAL_EVENT SignalEvent
Definition: UefiSpec.h:1863
EFI_PHYSICAL_ADDRESS PhysicalStart
Physical address of the first byte of the memory region.
Definition: UefiSpec.h:115
EFI_HANDLE StandardErrorHandle
The handle for the active standard error console device.
Definition: UefiSpec.h:1987
EFI Runtime Services Table.
Definition: UefiSpec.h:1784
VOID(EFIAPI * EFI_COPY_MEM)(IN VOID *Destination, IN VOID *Source, IN UINTN Length)
Copies the contents of one buffer to another buffer.
Definition: UefiSpec.h:1093
EFI_RESET_SYSTEM ResetSystem
Definition: UefiSpec.h:1815
Allocate any available range of pages whose uppermost address is less than or equal to a specified ma...
Definition: UefiSpec.h:43
EFI_STATUS(EFIAPI * EFI_IMAGE_UNLOAD)(IN EFI_HANDLE ImageHandle)
Unloads an image.
Definition: UefiSpec.h:943
#define EFIAPI
EFI Boot Services Table.
Definition: UefiSpec.h:1836
EFI_GET_NEXT_MONOTONIC_COUNT GetNextMonotonicCount
Definition: UefiSpec.h:1892
Simple Text Input Ex protocol from the UEFI 2.0 specification.
Indicates that the supplied protocol interface is supplied in native form.
Definition: UefiSpec.h:1122
UINT8_t Protocol
Protocol.
Definition: pxe_api.h:64
EFI_STATUS(EFIAPI * EFI_GET_MEMORY_MAP)(IN OUT UINTN *MemoryMapSize, IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap, OUT UINTN *MapKey, OUT UINTN *DescriptorSize, OUT UINT32 *DescriptorVersion)
Returns the current memory map.
Definition: UefiSpec.h:212
EFI_STATUS(EFIAPI * EFI_SET_WATCHDOG_TIMER)(IN UINTN Timeout, IN UINT64 WatchdogCode, IN UINTN DataSize, IN CHAR16 *WatchdogData OPTIONAL)
Sets the system's watchdog timer.
Definition: UefiSpec.h:997
SEGOFF16_t Buffer
Buffer address.
Definition: pxe_api.h:65
This includes some definitions introduced in UEFI that will be used in both PEI and DXE phases.
EFI_STATUS(EFIAPI * EFI_DISCONNECT_CONTROLLER)(IN EFI_HANDLE ControllerHandle, IN EFI_HANDLE DriverImageHandle, OPTIONAL IN EFI_HANDLE ChildHandle OPTIONAL)
Disconnects one or more drivers from a controller.
Definition: UefiSpec.h:350
Simple Text Out protocol from the UEFI 2.0 specification.
EFI_STATUS(EFIAPI * EFI_HANDLE_PROTOCOL)(IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, OUT VOID **Interface)
Queries a handle to determine if it supports a specified protocol.
Definition: UefiSpec.h:1264
EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES UninstallMultipleProtocolInterfaces
Definition: UefiSpec.h:1916
EFI_CONNECT_CONTROLLER ConnectController
Definition: UefiSpec.h:1899
EFI_GET_TIME GetTime
Definition: UefiSpec.h:1793
UINT32 Revision
Indicates the revision of the EFI_KEY_OPTION structure.
Definition: UefiSpec.h:2103
EFI_STATUS(EFIAPI * EFI_REGISTER_PROTOCOL_NOTIFY)(IN EFI_GUID *Protocol, IN EFI_EVENT Event, OUT VOID **Registration)
Creates an event that is to be signaled whenever an interface is installed for a specified protocol.
Definition: UefiSpec.h:1426
EFI_IMAGE_START StartImage
Definition: UefiSpec.h:1884
EFI_STATUS(EFIAPI * EFI_UPDATE_CAPSULE)(IN EFI_CAPSULE_HEADER **CapsuleHeaderArray, IN UINTN CapsuleCount, IN EFI_PHYSICAL_ADDRESS ScatterGatherList OPTIONAL)
Passes capsules to the firmware with both virtual and physical mapping.
Definition: UefiSpec.h:1682
UINT64 UINTN
Unsigned value of native width.
Definition: ProcessorBind.h:71
EFI System Table.
Definition: UefiSpec.h:1949
EFI_STATUS(EFIAPI * EFI_FREE_POOL)(IN VOID *Buffer)
Returns pool memory to the system.
Definition: UefiSpec.h:258
EFI_VIRTUAL_ADDRESS VirtualStart
Virtual address of the first byte of the memory region.
Definition: UefiSpec.h:120
UINT32 Type
Type of the memory region.
Definition: UefiSpec.h:110
unsigned long Address
Definition: etherboot.h:21
#define VOID
Undeclared type.
Definition: Base.h:319
EFI_HANDLE ConsoleOutHandle
The handle for the active console output device.
Definition: UefiSpec.h:1977
unsigned long long UINT64
Definition: ProcessorBind.h:54
EFI_WAIT_FOR_EVENT WaitForEvent
Definition: UefiSpec.h:1862
EFI_FREE_POOL FreePool
Definition: UefiSpec.h:1855
EFI_HANDLE ControllerHandle
Definition: efi_bofm.c:109
EFI_OPEN_PROTOCOL_INFORMATION OpenProtocolInformation
Definition: UefiSpec.h:1907
EFI Capsule Header.
Definition: UefiSpec.h:1607
EFI_STATUS(EFIAPI * EFI_CONNECT_CONTROLLER)(IN EFI_HANDLE ControllerHandle, IN EFI_HANDLE *DriverImageHandle, OPTIONAL IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath, OPTIONAL IN BOOLEAN Recursive)
Connects one or more drivers to a controller.
Definition: UefiSpec.h:317
EFI Time Abstraction: Year: 1900 - 9999 Month: 1 - 12 Day: 1 - 31 Hour: 0 - 23 Minute: 0 - 59 Second:...
Definition: UefiBaseType.h:74
EFI_STATUS(EFIAPI * EFI_CLOSE_EVENT)(IN EFI_EVENT Event)
Closes an event.
Definition: UefiSpec.h:566
#define IN
Definition: mlx_utils.h:28
EFI Key Option.
Definition: UefiSpec.h:2143
EFI_ALLOCATE_TYPE
Enumeration of EFI memory allocation types.
Definition: UefiSpec.h:34
Simple Text Input protocol from the UEFI 2.0 specification.
EFI_GET_MEMORY_MAP GetMemoryMap
Definition: UefiSpec.h:1853
EFI_ALLOCATE_PAGES AllocatePages
Definition: UefiSpec.h:1851
EFI_STATUS(EFIAPI * EFI_IMAGE_START)(IN EFI_HANDLE ImageHandle, OUT UINTN *ExitDataSize, OUT CHAR16 **ExitData OPTIONAL)
Transfers control to a loaded image's entry point.
Definition: UefiSpec.h:897
EFI_SET_WAKEUP_TIME SetWakeupTime
Definition: UefiSpec.h:1796
EFI_RUNTIME_SERVICES * RuntimeServices
A pointer to the EFI Runtime Services Table.
Definition: UefiSpec.h:1996
UINTN EFI_TPL
Task priority level.
Definition: UefiBaseType.h:47
EFI_PROTOCOLS_PER_HANDLE ProtocolsPerHandle
Definition: UefiSpec.h:1912
EFI_STATUS(EFIAPI * EFI_SET_VIRTUAL_ADDRESS_MAP)(IN UINTN MemoryMapSize, IN UINTN DescriptorSize, IN UINT32 DescriptorVersion, IN EFI_MEMORY_DESCRIPTOR *VirtualMap)
Changes the runtime addressing mode of EFI firmware from physical to virtual.
Definition: UefiSpec.h:283
#define CONST
Datum is read-only.
Definition: Base.h:309
EFI_STATUS(EFIAPI * EFI_GET_VARIABLE)(IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, OUT UINT32 *Attributes, OPTIONAL IN OUT UINTN *DataSize, OUT VOID *Data OPTIONAL)
Returns the value of a variable.
Definition: UefiSpec.h:648
EFI_STATUS(EFIAPI * EFI_CHECK_EVENT)(IN EFI_EVENT Event)
Checks whether an event is in the signaled state.
Definition: UefiSpec.h:582
EFI_STATUS(EFIAPI * EFI_QUERY_CAPSULE_CAPABILITIES)(IN EFI_CAPSULE_HEADER **CapsuleHeaderArray, IN UINTN CapsuleCount, OUT UINT64 *MaximumCapsuleSize, OUT EFI_RESET_TYPE *ResetType)
Returns if the capsule can be supported via UpdateCapsule().
Definition: UefiSpec.h:1713
EFI_STATUS(EFIAPI * EFI_ALLOCATE_POOL)(IN EFI_MEMORY_TYPE PoolType, IN UINTN Size, OUT VOID **Buffer)
Allocates pool memory.
Definition: UefiSpec.h:241
UINT32 BootOptionCrc
The CRC-32 which should match the CRC-32 of the entire EFI_LOAD_OPTION to which BootOption refers.
Definition: UefiSpec.h:2153
EFI_TIMER_DELAY
Timer delay types.
Definition: UefiSpec.h:481
EFI Capsule Block Descriptor.
Definition: UefiSpec.h:1583
EFI_CHECK_EVENT CheckEvent
Definition: UefiSpec.h:1865
RETURN_STATUS EFI_STATUS
Function return status for EFI API.
Definition: UefiBaseType.h:35
EFI_GET_NEXT_VARIABLE_NAME GetNextVariableName
Definition: UefiSpec.h:1808
UINT64 Length
Length in bytes of the data pointed to by DataBlock/ContinuationPointer.
Definition: UefiSpec.h:1587
The EFI System Table entry must point to an array of capsules that contain the same CapsuleGuid value...
Definition: UefiSpec.h:1635
UINTN NumberOfTableEntries
The number of system configuration tables in the buffer ConfigurationTable.
Definition: UefiSpec.h:2004
Allocate any available range of pages that satisfies the request.
Definition: UefiSpec.h:38
Contains a set of GUID/pointer pairs comprised of the ConfigurationTable field in the EFI System Tabl...
Definition: UefiSpec.h:1935
EFI_STATUS(EFIAPI * EFI_INSTALL_CONFIGURATION_TABLE)(IN EFI_GUID *Guid, IN VOID *Table)
Adds, updates, or removes a configuration table entry from the EFI System Table.
Definition: UefiSpec.h:1522
Data structure that precedes all of the standard EFI table types.
Retrieve the set of handles from the handle database that support a specified protocol.
Definition: UefiSpec.h:1448
UINT16 BootOption
The Boot#### option which will be invoked if this key is pressed and the boot option is active (LOAD_...
Definition: UefiSpec.h:2158
EFI_OPEN_PROTOCOL OpenProtocol
Definition: UefiSpec.h:1905
EFI_PHYSICAL_ADDRESS ContinuationPointer
Physical address of another block of EFI_CAPSULE_BLOCK_DESCRIPTOR structures.
Definition: UefiSpec.h:1600
UINT64 Attribute
Attributes of the memory region that describe the bit mask of capabilities for that memory region,...
Definition: UefiSpec.h:130
EFI_LOCATE_SEARCH_TYPE
Enumeration of EFI Locate Search Types.
Definition: UefiSpec.h:1435
EFI_INTERFACE_TYPE
Enumeration of EFI Interface Types.
Definition: UefiSpec.h:1118
EFI_STATUS(EFIAPI * EFI_EXIT_BOOT_SERVICES)(IN EFI_HANDLE ImageHandle, IN UINTN MapKey)
Terminates all boot services.
Definition: UefiSpec.h:959
EFI_UPDATE_CAPSULE UpdateCapsule
Definition: UefiSpec.h:1820
EFI_RESTORE_TPL RestoreTPL
Definition: UefiSpec.h:1846
EFI_STATUS(EFIAPI * EFI_CONVERT_POINTER)(IN UINTN DebugDisposition, IN OUT VOID **Address)
Determines the new virtual address that is to be used on subsequent memory accesses.
Definition: UefiSpec.h:380
UINT32 SysReqPressed
The SysReq key must be pressed (1) or must not be pressed (0).
Definition: UefiSpec.h:2127
UINT32 MenuPressed
The Menu key must be pressed (1) or must not be pressed (0).
Definition: UefiSpec.h:2123
EFI_SET_VIRTUAL_ADDRESS_MAP SetVirtualAddressMap
Definition: UefiSpec.h:1801
EFI_FREE_PAGES FreePages
Definition: UefiSpec.h:1852
EFI_STATUS(EFIAPI * EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES)(IN OUT EFI_HANDLE *Handle,...)
Installs one or more protocol interfaces into the boot services environment.
Definition: UefiSpec.h:1172
UINT32 AltPressed
Either the left or right Alt keys must be pressed (1) or must not be pressed (0).
Definition: UefiSpec.h:2115
VOID(EFIAPI * EFI_RESET_SYSTEM)(IN EFI_RESET_TYPE ResetType, IN EFI_STATUS ResetStatus, IN UINTN DataSize, IN VOID *ResetData OPTIONAL)
Resets the entire platform.
Definition: UefiSpec.h:1021
EFI_CALCULATE_CRC32 CalculateCrc32
Definition: UefiSpec.h:1921
UINT32 LogoPressed
Either the left or right Logo keys must be pressed (1) or must not be pressed (0).
Definition: UefiSpec.h:2119
EFI_STATUS(EFIAPI * EFI_PROTOCOLS_PER_HANDLE)(IN EFI_HANDLE Handle, OUT EFI_GUID ***ProtocolBuffer, OUT UINTN *ProtocolBufferCount)
Retrieves the list of protocol interface GUIDs that are installed on a handle in a buffer allocated f...
Definition: UefiSpec.h:1403
UINT32 Accuracy
Provides the timekeeping accuracy of the real-time clock in an error rate of 1E-6 parts per million.
Definition: UefiSpec.h:749
EFI_STATUS(EFIAPI * EFI_SET_VARIABLE)(IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, IN UINT32 Attributes, IN UINTN DataSize, IN VOID *Data)
Sets the value of a variable.
Definition: UefiSpec.h:722
EFI_STATUS(EFIAPI * EFI_CREATE_EVENT_EX)(IN UINT32 Type, IN EFI_TPL NotifyTpl, IN EFI_EVENT_NOTIFY NotifyFunction OPTIONAL, IN CONST VOID *NotifyContext OPTIONAL, IN CONST EFI_GUID *EventGroup OPTIONAL, OUT EFI_EVENT *Event)
Creates an event in a group.
Definition: UefiSpec.h:469
UINT64 EFI_VIRTUAL_ADDRESS
64-bit virtual memory address.
Definition: UefiBaseType.h:61
Definition: efi.h:55
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL * StdErr
A pointer to the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL interface that is associated with StandardErrorHandl...
Definition: UefiSpec.h:1992
EFI_STATUS(EFIAPI * EFI_LOCATE_PROTOCOL)(IN EFI_GUID *Protocol, IN VOID *Registration, OPTIONAL OUT VOID **Interface)
Returns the first protocol instance that matches the given protocol.
Definition: UefiSpec.h:1574
EFI_LOCATE_HANDLE_BUFFER LocateHandleBuffer
Definition: UefiSpec.h:1913
EFI_INSTALL_CONFIGURATION_TABLE InstallConfigurationTable
Definition: UefiSpec.h:1878
EFI_LOCATE_DEVICE_PATH LocateDevicePath
Definition: UefiSpec.h:1877
EFI_ALLOCATE_POOL AllocatePool
Definition: UefiSpec.h:1854
EFI_STATUS(EFIAPI * EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES)(IN EFI_HANDLE Handle,...)
Removes one or more protocol interfaces into the boot services environment.
Definition: UefiSpec.h:1242
EFI_CONFIGURATION_TABLE * ConfigurationTable
A pointer to the system configuration tables.
Definition: UefiSpec.h:2009
EFI_STATUS(EFIAPI * EFI_GET_NEXT_MONOTONIC_COUNT)(OUT UINT64 *Count)
Returns a monotonically increasing count for the platform.
Definition: UefiSpec.h:1040
VOID * VendorTable
A pointer to the table associated with VendorGuid.
Definition: UefiSpec.h:1943
This provides the capabilities of the real time clock device as exposed through the EFI interfaces.
Definition: UefiSpec.h:735
EFI_DISCONNECT_CONTROLLER DisconnectController
Definition: UefiSpec.h:1900