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