MdeModulePkg/Include/Library/UefiBootManagerLib.h

   1 /** @file
   2   Provide Boot Manager related library APIs.
   3
   4 Copyright (c) 2011 - 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15
  16 #ifndef _UEFI_BOOT_MANAGER_LIB_H_
  17 #define _UEFI_BOOT_MANAGER_LIB_H_
  18
  19 #include <Protocol/DriverHealth.h>
  20 #include <Library/SortLib.h>
  21
  22 //
  23 // Boot Manager load option library functions.
  24 //
  25
  26 //
  27 // Load Option Type
  28 //
  29 typedef enum {
  30   LoadOptionTypeDriver,
  31   LoadOptionTypeSysPrep,
  32   LoadOptionTypeBoot,
  33   LoadOptionTypeMax
  34 } EFI_BOOT_MANAGER_LOAD_OPTION_TYPE;
  35
  36 typedef enum {
  37   LoadOptionNumberMax = 0x10000,
  38   LoadOptionNumberUnassigned = LoadOptionNumberMax
  39 } EFI_BOOT_MANAGER_LOAD_OPTION_NUMBER;
  40
  41 //
  42 // Common structure definition for DriverOption and BootOption
  43 //
  44 typedef struct {
  45   //
  46   // Data read from UEFI NV variables
  47   //
  48   UINTN                             OptionNumber;       // #### numerical value, could be LoadOptionNumberUnassigned
  49   EFI_BOOT_MANAGER_LOAD_OPTION_TYPE OptionType;         // LoadOptionTypeBoot or LoadOptionTypeDriver
  50   UINT32                            Attributes;         // Load Option Attributes
  51   CHAR16                            *Description;       // Load Option Description
  52   EFI_DEVICE_PATH_PROTOCOL          *FilePath;          // Load Option Device Path
  53   UINT8                             *OptionalData;      // Load Option optional data to pass into image
  54   UINT32                            OptionalDataSize;   // Load Option size of OptionalData
  55   EFI_GUID                          VendorGuid;
  56
  57   //
  58   // Used at runtime
  59   //
  60   EFI_STATUS                        Status;             // Status returned from boot attempt gBS->StartImage ()
  61   CHAR16                            *ExitData;          // Exit data returned from gBS->StartImage ()
  62   UINTN                             ExitDataSize;       // Size of ExitData
  63 } EFI_BOOT_MANAGER_LOAD_OPTION;
  64
  65 /**
  66   Returns an array of load options based on the EFI variable
  67   L"BootOrder"/L"DriverOrder" and the L"Boot####"/L"Driver####" variables impled by it.
  68   #### is the hex value of the UINT16 in each BootOrder/DriverOrder entry.
  69
  70   @param  LoadOptionCount   Returns number of entries in the array.
  71   @param  LoadOptionType    The type of the load option.
  72
  73   @retval NULL  No load options exist.
  74   @retval !NULL Array of load option entries.
  75
  76 **/
  77 EFI_BOOT_MANAGER_LOAD_OPTION *
  78 EFIAPI
  79 EfiBootManagerGetLoadOptions (
  80   OUT UINTN                            *LoadOptionCount,
  81   IN EFI_BOOT_MANAGER_LOAD_OPTION_TYPE LoadOptionType
  82   );
  83
  84 /**
  85   Free an array of load options returned from EfiBootManagerGetLoadOptions().
  86
  87   @param  LoadOptions      Pointer to the array of load options to free.
  88   @param  LoadOptionCount  Number of array entries in LoadOptions.
  89
  90   @return EFI_SUCCESS           LoadOptions was freed.
  91   @return EFI_INVALID_PARAMETER LoadOptions is NULL.
  92 **/
  93 EFI_STATUS
  94 EFIAPI
  95 EfiBootManagerFreeLoadOptions (
  96   IN  EFI_BOOT_MANAGER_LOAD_OPTION  *LoadOptions,
  97   IN  UINTN                         LoadOptionCount
  98   );
  99
 100 /**
 101   Initialize a load option.
 102
 103   @param Option           Pointer to the load option to be initialized.
 104   @param OptionNumber     Option number of the load option.
 105   @param OptionType       Type of the load option.
 106   @param Attributes       Attributes of the load option.
 107   @param Description      Description of the load option.
 108   @param FilePath         Device path of the load option.
 109   @param OptionalData     Optional data of the load option.
 110   @param OptionalDataSize Size of the optional data of the load option.
 111
 112   @retval EFI_SUCCESS           The load option was initialized successfully.
 113   @retval EFI_INVALID_PARAMETER Option, Description or FilePath is NULL.
 114 **/
 115 EFI_STATUS
 116 EFIAPI
 117 EfiBootManagerInitializeLoadOption (
 118   IN OUT EFI_BOOT_MANAGER_LOAD_OPTION   *Option,
 119   IN  UINTN                             OptionNumber,
 120   IN  EFI_BOOT_MANAGER_LOAD_OPTION_TYPE OptionType,
 121   IN  UINT32                            Attributes,
 122   IN  CHAR16                            *Description,
 123   IN  EFI_DEVICE_PATH_PROTOCOL          *FilePath,
 124   IN  UINT8                             *OptionalData,
 125   IN  UINT32                            OptionalDataSize
 126   );
 127
 128 /**
 129   Free a load option created by EfiBootManagerInitializeLoadOption()
 130   or EfiBootManagerVariableToLoadOption().
 131
 132   @param  LoadOption   Pointer to the load option to free.
 133   CONCERN: Check Boot#### instead of BootOrder, optimize, spec clarify
 134   @return EFI_SUCCESS           LoadOption was freed.
 135   @return EFI_INVALID_PARAMETER LoadOption is NULL.
 136
 137 **/
 138 EFI_STATUS
 139 EFIAPI
 140 EfiBootManagerFreeLoadOption (
 141   IN  EFI_BOOT_MANAGER_LOAD_OPTION  *LoadOption
 142   );
 143
 144 /**
 145   Initialize the load option from the VariableName.
 146
 147   @param  VariableName          EFI Variable name which could be Boot#### or
 148                                 Driver####
 149   @param  LoadOption            Pointer to the load option to be initialized
 150
 151   @retval EFI_SUCCESS           The option was created
 152   @retval EFI_INVALID_PARAMETER VariableName or LoadOption is NULL.
 153   @retval EFI_NOT_FOUND         The variable specified by VariableName cannot be found.
 154 **/
 155 EFI_STATUS
 156 EFIAPI
 157 EfiBootManagerVariableToLoadOption (
 158   IN CHAR16                           *VariableName,
 159   IN OUT EFI_BOOT_MANAGER_LOAD_OPTION *LoadOption
 160   );
 161
 162 /**
 163   Create the Boot#### or Driver#### variable from the load option.
 164
 165   @param  LoadOption      Pointer to the load option.
 166
 167   @retval EFI_SUCCESS     The variable was created.
 168   @retval Others          Error status returned by RT->SetVariable.
 169 **/
 170 EFI_STATUS
 171 EFIAPI
 172 EfiBootManagerLoadOptionToVariable (
 173   IN CONST EFI_BOOT_MANAGER_LOAD_OPTION     *LoadOption
 174   );
 175
 176 /**
 177   This function will update the Boot####/Driver####/SysPrep#### and the
 178   BootOrder/DriverOrder/SysPrepOrder to add a new load option.
 179
 180   @param  Option        Pointer to load option to add.
 181   @param  Position      Position of the new load option to put in the BootOrder/DriverOrder/SysPrepOrder.
 182
 183   @retval EFI_SUCCESS   The load option has been successfully added.
 184   @retval Others        Error status returned by RT->SetVariable.
 185 **/
 186 EFI_STATUS
 187 EFIAPI
 188 EfiBootManagerAddLoadOptionVariable (
 189   IN EFI_BOOT_MANAGER_LOAD_OPTION  *Option,
 190   IN UINTN                         Position
 191   );
 192
 193 /**
 194   Delete the load option according to the OptionNumber and OptionType.
 195
 196   Only the BootOrder/DriverOrder is updated to remove the reference of the OptionNumber.
 197
 198   @param  OptionNumber        Option number of the load option.
 199   @param  OptionType          Type of the load option.
 200
 201   @retval EFI_NOT_FOUND       The load option cannot be found.
 202   @retval EFI_SUCCESS         The load option was deleted.
 203 **/
 204 EFI_STATUS
 205 EFIAPI
 206 EfiBootManagerDeleteLoadOptionVariable (
 207   IN UINTN                              OptionNumber,
 208   IN EFI_BOOT_MANAGER_LOAD_OPTION_TYPE  OptionType
 209   );
 210
 211 /**
 212   Sort the load options. The DriverOrder/BootOrder variables will be re-created to
 213   reflect the new order.
 214
 215   @param OptionType        The type of the load option.
 216   @param CompareFunction   The comparator function pointer.
 217 **/
 218 VOID
 219 EFIAPI
 220 EfiBootManagerSortLoadOptionVariable (
 221   IN EFI_BOOT_MANAGER_LOAD_OPTION_TYPE OptionType,
 222   IN SORT_COMPARE                      CompareFunction
 223   );
 224
 225 //
 226 // Boot Manager hot key library functions.
 227 //
 228
 229 #pragma pack(1)
 230 ///
 231 /// EFI Key Option.
 232 ///
 233 typedef struct {
 234   ///
 235   /// Specifies options about how the key will be processed.
 236   ///
 237   EFI_BOOT_KEY_DATA  KeyData;
 238   ///
 239   /// The CRC-32 which should match the CRC-32 of the entire EFI_LOAD_OPTION to
 240   /// which BootOption refers. If the CRC-32s do not match this value, then this key
 241   /// option is ignored.
 242   ///
 243   UINT32             BootOptionCrc;
 244   ///
 245   /// The Boot#### option which will be invoked if this key is pressed and the boot option
 246   /// is active (LOAD_OPTION_ACTIVE is set).
 247   ///
 248   UINT16             BootOption;
 249   ///
 250   /// The key codes to compare against those returned by the
 251   /// EFI_SIMPLE_TEXT_INPUT and EFI_SIMPLE_TEXT_INPUT_EX protocols.
 252   /// The number of key codes (0-3) is specified by the EFI_KEY_CODE_COUNT field in KeyOptions.
 253   ///
 254   EFI_INPUT_KEY      Keys[3];
 255   UINT16             OptionNumber;
 256 } EFI_BOOT_MANAGER_KEY_OPTION;
 257 #pragma pack()
 258
 259 /**
 260   Start the hot key service so that the key press can trigger the boot option.
 261
 262   @param HotkeyTriggered  Return the waitable event and it will be signaled
 263                           when a valid hot key is pressed.
 264
 265   @retval EFI_SUCCESS     The hot key service is started.
 266 **/
 267 EFI_STATUS
 268 EFIAPI
 269 EfiBootManagerStartHotkeyService (
 270   IN EFI_EVENT      *HotkeyTriggered
 271   );
 272
 273 //
 274 // Modifier for EfiBootManagerAddKeyOptionVariable and EfiBootManagerDeleteKeyOptionVariable
 275 //
 276 #define EFI_BOOT_MANAGER_SHIFT_PRESSED    0x00000001
 277 #define EFI_BOOT_MANAGER_CONTROL_PRESSED  0x00000002
 278 #define EFI_BOOT_MANAGER_ALT_PRESSED      0x00000004
 279 #define EFI_BOOT_MANAGER_LOGO_PRESSED     0x00000008
 280 #define EFI_BOOT_MANAGER_MENU_KEY_PRESSED 0x00000010
 281 #define EFI_BOOT_MANAGER_SYS_REQ_PRESSED  0x00000020
 282
 283 /**
 284   Add the key option.
 285   It adds the key option variable and the key option takes affect immediately.
 286
 287   @param AddedOption      Return the added key option.
 288   @param BootOptionNumber The boot option number for the key option.
 289   @param Modifier         Key shift state.
 290   @param ...              Parameter list of pointer of EFI_INPUT_KEY.
 291
 292   @retval EFI_SUCCESS         The key option is added.
 293   @retval EFI_ALREADY_STARTED The hot key is already used by certain key option.
 294 **/
 295 EFI_STATUS
 296 EFIAPI
 297 EfiBootManagerAddKeyOptionVariable (
 298   OUT EFI_BOOT_MANAGER_KEY_OPTION *AddedOption,   OPTIONAL
 299   IN UINT16                       BootOptionNumber,
 300   IN UINT32                       Modifier,
 301   ...
 302   );
 303
 304 /**
 305   Delete the Key Option variable and unregister the hot key
 306
 307   @param DeletedOption  Return the deleted key options.
 308   @param Modifier       Key shift state.
 309   @param ...            Parameter list of pointer of EFI_INPUT_KEY.
 310
 311   @retval EFI_SUCCESS   The key option is deleted.
 312   @retval EFI_NOT_FOUND The key option cannot be found.
 313 **/
 314 EFI_STATUS
 315 EFIAPI
 316 EfiBootManagerDeleteKeyOptionVariable (
 317   IN EFI_BOOT_MANAGER_KEY_OPTION *DeletedOption, OPTIONAL
 318   IN UINT32                      Modifier,
 319   ...
 320   );
 321
 322 /**
 323   Register the key option to exit the waiting of the Boot Manager timeout.
 324   Platform should ensure that the continue key option isn't conflict with
 325   other boot key options.
 326
 327   @param Modifier     Key shift state.
 328   @param  ...         Parameter list of pointer of EFI_INPUT_KEY.
 329
 330   @retval EFI_SUCCESS         Successfully register the continue key option.
 331   @retval EFI_ALREADY_STARTED The continue key option is already registered.
 332 **/
 333 EFI_STATUS
 334 EFIAPI
 335 EfiBootManagerRegisterContinueKeyOption (
 336   IN UINT32           Modifier,
 337   ...
 338   );
 339
 340 /**
 341   Try to boot the boot option triggered by hot key.
 342 **/
 343 VOID
 344 EFIAPI
 345 EfiBootManagerHotkeyBoot (
 346   VOID
 347   );
 348 //
 349 // Boot Manager boot library functions.
 350 //
 351
 352 /**
 353   The function creates boot options for all possible bootable medias in the following order:
 354   1. Removable BlockIo            - The boot option only points to the removable media
 355                                     device, like USB key, DVD, Floppy etc.
 356   2. Fixed BlockIo                - The boot option only points to a Fixed blockIo device,
 357                                     like HardDisk.
 358   3. Non-BlockIo SimpleFileSystem - The boot option points to a device supporting
 359                                     SimpleFileSystem Protocol, but not supporting BlockIo
 360                                     protocol.
 361   4. LoadFile                     - The boot option points to the media supporting
 362                                     LoadFile protocol.
 363   Reference: UEFI Spec chapter 3.3 Boot Option Variables Default Boot Behavior
 364
 365   The function won't delete the boot option not added by itself.
 366 **/
 367 VOID
 368 EFIAPI
 369 EfiBootManagerRefreshAllBootOption (
 370   VOID
 371   );
 372
 373 /**
 374   Attempt to boot the EFI boot option. This routine sets L"BootCurent" and
 375   signals the EFI ready to boot event. If the device path for the option starts
 376   with a BBS device path a legacy boot is attempted. Short form device paths are
 377   also supported via this rountine. A device path starting with
 378   MEDIA_HARDDRIVE_DP, MSG_USB_WWID_DP, MSG_USB_CLASS_DP gets expaned out
 379   to find the first device that matches. If the BootOption Device Path
 380   fails the removable media boot algorithm is attempted (\EFI\BOOTIA32.EFI,
 381   \EFI\BOOTX64.EFI,... only one file type is tried per processor type)
 382
 383   @param  BootOption    Boot Option to try and boot.
 384                         On return, BootOption->Status contains the boot status:
 385                         EFI_SUCCESS     BootOption was booted
 386                         EFI_UNSUPPORTED BootOption isn't supported.
 387                         EFI_NOT_FOUND   The BootOption was not found on the system
 388                         Others          BootOption failed with this error status
 389
 390 **/
 391 VOID
 392 EFIAPI
 393 EfiBootManagerBoot (
 394   IN  EFI_BOOT_MANAGER_LOAD_OPTION  *BootOption
 395   );
 396
 397 /**
 398   Return the Boot Manager Menu.
 399
 400   @param BootOption    Return the Boot Manager Menu.
 401
 402   @retval EFI_SUCCESS   The Boot Manager Menu is successfully returned.
 403   @retval EFI_NOT_FOUND The Boot Manager Menu is not found.
 404 **/
 405 EFI_STATUS
 406 EFIAPI
 407 EfiBootManagerGetBootManagerMenu (
 408   EFI_BOOT_MANAGER_LOAD_OPTION *BootOption
 409   );
 410
 411 /**
 412   The function enumerates all the legacy boot options, creates them and
 413   registers them in the BootOrder variable.
 414 **/
 415 typedef
 416 VOID
 417 (EFIAPI *EFI_BOOT_MANAGER_REFRESH_LEGACY_BOOT_OPTION) (
 418   VOID
 419   );
 420
 421 /**
 422   The function boots a legacy boot option.
 423 **/
 424 typedef
 425 VOID
 426 (EFIAPI *EFI_BOOT_MANAGER_LEGACY_BOOT) (
 427   IN  EFI_BOOT_MANAGER_LOAD_OPTION  *BootOption
 428   );
 429
 430 /**
 431   The function registers the legacy boot support capabilities.
 432
 433   @param RefreshLegacyBootOption The function pointer to create all the legacy boot options.
 434   @param LegacyBoot              The function pointer to boot the legacy boot option.
 435 **/
 436 VOID
 437 EFIAPI
 438 EfiBootManagerRegisterLegacyBootSupport (
 439   EFI_BOOT_MANAGER_REFRESH_LEGACY_BOOT_OPTION   RefreshLegacyBootOption,
 440   EFI_BOOT_MANAGER_LEGACY_BOOT                  LegacyBoot
 441   );
 442
 443 /**
 444   Return the platform provided boot option description for the controller.
 445
 446   @param Handle                Controller handle.
 447   @param DefaultDescription    Default boot description provided by core.
 448
 449   @return  The callee allocated description string
 450            or NULL if the handler wants to use DefaultDescription.
 451 **/
 452 typedef
 453 CHAR16 *
 454 (EFIAPI *EFI_BOOT_MANAGER_BOOT_DESCRIPTION_HANDLER) (
 455   IN EFI_HANDLE                  Handle,
 456   IN CONST CHAR16                *DefaultDescription
 457   );
 458
 459 /**
 460   Register the platform provided boot description handler.
 461
 462   @param Handler  The platform provided boot description handler
 463
 464   @retval EFI_SUCCESS          The handler was registered successfully.
 465   @retval EFI_ALREADY_STARTED  The handler was already registered.
 466   @retval EFI_OUT_OF_RESOURCES There is not enough resource to perform the registration.
 467 **/
 468 EFI_STATUS
 469 EFIAPI
 470 EfiBootManagerRegisterBootDescriptionHandler (
 471   IN EFI_BOOT_MANAGER_BOOT_DESCRIPTION_HANDLER  Handler
 472   );
 473
 474 //
 475 // Boot Manager connect and disconnect library functions
 476 //
 477
 478 /**
 479   This function will connect all the system driver to controller
 480   first, and then special connect the default console, this make
 481   sure all the system controller available and the platform default
 482   console connected.
 483 **/
 484 VOID
 485 EFIAPI
 486 EfiBootManagerConnectAll (
 487   VOID
 488   );
 489
 490 /**
 491   This function will create all handles associate with every device
 492   path node. If the handle associate with one device path node can not
 493   be created successfully, then still give chance to do the dispatch,
 494   which load the missing drivers if possible.
 495
 496   @param  DevicePathToConnect   The device path which will be connected, it can be
 497                                 a multi-instance device path
 498   @param  MatchingHandle        Return the controller handle closest to the DevicePathToConnect
 499
 500   @retval EFI_SUCCESS            All handles associate with every device path node
 501                                  have been created.
 502   @retval EFI_OUT_OF_RESOURCES   There is no resource to create new handles.
 503   @retval EFI_NOT_FOUND          Create the handle associate with one device path
 504                                  node failed.
 505   @retval EFI_SECURITY_VIOLATION The user has no permission to start UEFI device
 506                                  drivers on the DevicePath.
 507 **/
 508 EFI_STATUS
 509 EFIAPI
 510 EfiBootManagerConnectDevicePath (
 511   IN  EFI_DEVICE_PATH_PROTOCOL  *DevicePathToConnect,
 512   OUT EFI_HANDLE                *MatchingHandle          OPTIONAL
 513   );
 514
 515 /**
 516   This function will disconnect all current system handles.
 517
 518   gBS->DisconnectController() is invoked for each handle exists in system handle buffer.
 519   If handle is a bus type handle, all childrens also are disconnected recursively by
 520   gBS->DisconnectController().
 521 **/
 522 VOID
 523 EFIAPI
 524 EfiBootManagerDisconnectAll (
 525   VOID
 526   );
 527
 528
 529 //
 530 // Boot Manager console library functions
 531 //
 532
 533 typedef enum {
 534   ConIn,
 535   ConOut,
 536   ErrOut,
 537   ConInDev,
 538   ConOutDev,
 539   ErrOutDev,
 540   ConsoleTypeMax
 541 } CONSOLE_TYPE;
 542
 543 /**
 544   This function will connect all the console devices base on the console
 545   device variable ConIn, ConOut and ErrOut.
 546
 547   @retval EFI_DEVICE_ERROR         All the consoles were not connected due to an error.
 548   @retval EFI_SUCCESS              Success connect any one instance of the console
 549                                    device path base on the variable ConVarName.
 550 **/
 551 EFI_STATUS
 552 EFIAPI
 553 EfiBootManagerConnectAllDefaultConsoles (
 554   VOID
 555   );
 556
 557 /**
 558   This function updates the console variable based on ConVarName. It can
 559   add or remove one specific console device path from the variable
 560
 561   @param  ConsoleType              ConIn, ConOut, ErrOut, ConInDev, ConOutDev or ErrOutDev.
 562   @param  CustomizedConDevicePath  The console device path to be added to
 563                                    the console variable. Cannot be multi-instance.
 564   @param  ExclusiveDevicePath      The console device path to be removed
 565                                    from the console variable. Cannot be multi-instance.
 566
 567   @retval EFI_UNSUPPORTED          The added device path is the same as a removed one.
 568   @retval EFI_SUCCESS              Successfully added or removed the device path from the
 569                                    console variable.
 570
 571 **/
 572 EFI_STATUS
 573 EFIAPI
 574 EfiBootManagerUpdateConsoleVariable (
 575   IN  CONSOLE_TYPE              ConsoleType,
 576   IN  EFI_DEVICE_PATH_PROTOCOL  *CustomizedConDevicePath,
 577   IN  EFI_DEVICE_PATH_PROTOCOL  *ExclusiveDevicePath
 578   );
 579
 580 /**
 581   Connect the console device base on the variable ConVarName, if
 582   device path of the ConVarName is multi-instance device path, if
 583   anyone of the instances is connected success, then this function
 584   will return success.
 585
 586   @param  ConsoleType              ConIn, ConOut or ErrOut.
 587
 588   @retval EFI_NOT_FOUND            There is not any console devices connected
 589                                    success
 590   @retval EFI_SUCCESS              Success connect any one instance of the console
 591                                    device path base on the variable ConVarName.
 592
 593 **/
 594 EFI_STATUS
 595 EFIAPI
 596 EfiBootManagerConnectConsoleVariable (
 597   IN  CONSOLE_TYPE              ConsoleType
 598   );
 599
 600 /**
 601   Query all the children of VideoController and return the device paths of all the
 602   children that support GraphicsOutput protocol.
 603
 604   @param VideoController       PCI handle of video controller.
 605
 606   @return  Device paths of all the children that support GraphicsOutput protocol.
 607 **/
 608 EFI_DEVICE_PATH_PROTOCOL *
 609 EFIAPI
 610 EfiBootManagerGetGopDevicePath (
 611   IN  EFI_HANDLE               VideoController
 612   );
 613
 614 /**
 615   Connect the platform active active video controller.
 616
 617   @param VideoController       PCI handle of video controller.
 618
 619   @retval EFI_NOT_FOUND There is no active video controller.
 620   @retval EFI_SUCCESS   The video controller is connected.
 621 **/
 622 EFI_STATUS
 623 EFIAPI
 624 EfiBootManagerConnectVideoController (
 625   EFI_HANDLE                 VideoController  OPTIONAL
 626   );
 627
 628 //
 629 // Boot Manager driver health library functions.
 630 //
 631
 632 typedef struct {
 633   EFI_DRIVER_HEALTH_PROTOCOL      *DriverHealth;
 634
 635   ///
 636   /// Driver relative handles
 637   ///
 638   EFI_HANDLE                      DriverHealthHandle;
 639   EFI_HANDLE                      ControllerHandle;
 640   EFI_HANDLE                      ChildHandle;
 641
 642   ///
 643   /// Driver health messages of the specify Driver
 644   ///
 645   EFI_DRIVER_HEALTH_HII_MESSAGE   *MessageList;
 646
 647   ///
 648   /// HII relative handles
 649   ///
 650   EFI_HII_HANDLE                  HiiHandle;
 651
 652   ///
 653   /// Driver Health status
 654   ///
 655   EFI_DRIVER_HEALTH_STATUS        HealthStatus;
 656 } EFI_BOOT_MANAGER_DRIVER_HEALTH_INFO;
 657
 658 /**
 659   Return all the Driver Health information.
 660
 661   When the cumulative health status of all the controllers managed by the
 662   driver who produces the EFI_DRIVER_HEALTH_PROTOCOL is healthy, only one
 663   EFI_BOOT_MANAGER_DRIVER_HEALTH_INFO entry is created for such
 664   EFI_DRIVER_HEALTH_PROTOCOL instance.
 665   Otherwise, every controller creates one EFI_BOOT_MANAGER_DRIVER_HEALTH_INFO
 666   entry. Additionally every child controller creates one
 667   EFI_BOOT_MANAGER_DRIVER_HEALTH_INFO entry if the driver is a bus driver.
 668
 669   @param Count      Return the count of the Driver Health information.
 670
 671   @retval NULL      No Driver Health information is returned.
 672   @retval !NULL     Pointer to the Driver Health information array.
 673 **/
 674 EFI_BOOT_MANAGER_DRIVER_HEALTH_INFO *
 675 EFIAPI
 676 EfiBootManagerGetDriverHealthInfo (
 677   UINTN    *Count
 678   );
 679
 680 /**
 681   Free the Driver Health information array.
 682
 683   @param DriverHealthInfo       Pointer to array of the Driver Health information.
 684   @param Count                  Count of the array.
 685
 686   @retval EFI_SUCCESS           The array is freed.
 687   @retval EFI_INVALID_PARAMETER The array is NULL.
 688 **/
 689 EFI_STATUS
 690 EFIAPI
 691 EfiBootManagerFreeDriverHealthInfo (
 692   EFI_BOOT_MANAGER_DRIVER_HEALTH_INFO  *DriverHealthInfo,
 693   UINTN                                Count
 694   );
 695
 696 /**
 697   Process (load and execute) the load option.
 698
 699   @param LoadOption  Pointer to the load option.
 700
 701   @retval EFI_INVALID_PARAMETER  The load option type is invalid,
 702                                  or the load option file path doesn't point to a valid file.
 703   @retval EFI_UNSUPPORTED        The load option type is of LoadOptionTypeBoot.
 704   @retval EFI_SUCCESS            The load option is inactive, or successfully loaded and executed.
 705 **/
 706 EFI_STATUS
 707 EFIAPI
 708 EfiBootManagerProcessLoadOption (
 709   EFI_BOOT_MANAGER_LOAD_OPTION       *LoadOption
 710   );
 711 #endif