IntelFrameworkModulePkg/Include/Library/GenericBdsLib.h

   1 /** @file
   2   Generic BDS library defines general interfaces for BDS driver including:
   3     1) BDS boot policy interface;
   4     2) BDS boot device connect interface;
   5     3) BDS Misc interfaces for mainting boot variable, ouput string.
   6
   7 Copyright (c) 2004 - 2009, Intel Corporation. <BR>
   8 All rights reserved. This program and the accompanying materials
   9 are licensed and made available under the terms and conditions of the BSD License
  10 which accompanies this distribution.  The full text of the license may be found at
  11 http://opensource.org/licenses/bsd-license.php
  12
  13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  14 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  15
  16 **/
  17
  18 #ifndef _GENERIC_BDS_LIB_H_
  19 #define _GENERIC_BDS_LIB_H_
  20
  21 extern EFI_HANDLE mBdsImageHandle;
  22
  23 //
  24 // Constants which are variable names used to access variables
  25 //
  26 #define VAR_LEGACY_DEV_ORDER L"LegacyDevOrder"
  27
  28 //
  29 // Data structures and defines
  30 //
  31 #define FRONT_PAGE_QUESTION_ID  0x0000
  32 #define FRONT_PAGE_DATA_WIDTH   0x01
  33
  34 //
  35 // ConnectType
  36 //
  37 #define CONSOLE_OUT 0x00000001
  38 #define STD_ERROR   0x00000002
  39 #define CONSOLE_IN  0x00000004
  40 #define CONSOLE_ALL (CONSOLE_OUT | CONSOLE_IN | STD_ERROR)
  41
  42 //
  43 // Load Option Attributes defined in EFI Specification
  44 //
  45 #define LOAD_OPTION_ACTIVE              0x00000001
  46 #define LOAD_OPTION_FORCE_RECONNECT     0x00000002
  47
  48 #define LOAD_OPTION_HIDDEN              0x00000008
  49 #define LOAD_OPTION_CATEGORY            0x00001F00
  50
  51 #define LOAD_OPTION_CATEGORY_BOOT       0x00000000
  52 #define LOAD_OPTION_CATEGORY_APP        0x00000100
  53
  54 #define EFI_BOOT_OPTION_SUPPORT_KEY     0x00000001
  55 #define EFI_BOOT_OPTION_SUPPORT_APP     0x00000002
  56
  57 #define IS_LOAD_OPTION_TYPE(_c, _Mask)  (BOOLEAN) (((_c) & (_Mask)) != 0)
  58
  59 //
  60 // Define Maxmim characters that will be accepted
  61 //
  62 #define MAX_CHAR            480
  63 #define MAX_CHAR_SIZE       (MAX_CHAR * 2)
  64
  65 #define MIN_ALIGNMENT_SIZE  4
  66 #define ALIGN_SIZE(a)       ((a % MIN_ALIGNMENT_SIZE) ? MIN_ALIGNMENT_SIZE - (a % MIN_ALIGNMENT_SIZE) : 0)
  67
  68 //
  69 // Define maximum characters for boot option variable "BootXXXX"
  70 //
  71 #define BOOT_OPTION_MAX_CHAR 10
  72
  73 //
  74 // This data structure is the part of BDS_CONNECT_ENTRY that we can hard code.
  75 //
  76 #define BDS_LOAD_OPTION_SIGNATURE SIGNATURE_32 ('B', 'd', 'C', 'O')
  77
  78 typedef struct {
  79
  80   UINTN                     Signature;
  81   LIST_ENTRY                Link;
  82
  83   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
  84
  85   CHAR16                    *OptionName;
  86   UINTN                     OptionNumber;
  87   UINT16                    BootCurrent;
  88   UINT32                    Attribute;
  89   CHAR16                    *Description;
  90   VOID                      *LoadOptions;
  91   UINT32                    LoadOptionsSize;
  92   CHAR16                    *StatusString;
  93
  94 } BDS_COMMON_OPTION;
  95
  96 typedef struct {
  97   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
  98   UINTN                     ConnectType;
  99 } BDS_CONSOLE_CONNECT_ENTRY;
 100
 101 //
 102 // Lib Functions
 103 //
 104
 105 //
 106 // Bds boot related lib functions
 107 //
 108 /**
 109   Boot from the UEFI spec defined "BootNext" variable.
 110
 111 **/
 112 VOID
 113 EFIAPI
 114 BdsLibBootNext (
 115   VOID
 116   );
 117
 118 /**
 119   Process the boot option follow the UEFI specification and
 120   special treat the legacy boot option with BBS_DEVICE_PATH.
 121
 122   @param  Option                 The boot option need to be processed
 123   @param  DevicePath             The device path which describe where to load the
 124                                  boot image or the legcy BBS device path to boot
 125                                  the legacy OS
 126   @param  ExitDataSize           The size of exit data.
 127   @param  ExitData               Data returned when Boot image failed.
 128
 129   @retval EFI_SUCCESS            Boot from the input boot option successfully.
 130   @retval EFI_NOT_FOUND          If the Device Path is not found in the system
 131
 132 **/
 133 EFI_STATUS
 134 EFIAPI
 135 BdsLibBootViaBootOption (
 136   IN  BDS_COMMON_OPTION             * Option,
 137   IN  EFI_DEVICE_PATH_PROTOCOL      * DevicePath,
 138   OUT UINTN                         *ExitDataSize,
 139   OUT CHAR16                        **ExitData OPTIONAL
 140   );
 141
 142
 143 /**
 144   For EFI boot option, BDS separate them as six types:
 145   1. Network - The boot option points to the SimpleNetworkProtocol device.
 146                Bds will try to automatically create this type boot option when enumerate.
 147   2. Shell   - The boot option points to internal flash shell.
 148                Bds will try to automatically create this type boot option when enumerate.
 149   3. Removable BlockIo      - The boot option only points to the removable media
 150                               device, like USB flash disk, DVD, Floppy etc.
 151                               These device should contain a *removable* blockIo
 152                               protocol in their device handle.
 153                               Bds will try to automatically create this type boot option
 154                               when enumerate.
 155   4. Fixed BlockIo          - The boot option only points to a Fixed blockIo device,
 156                               like HardDisk.
 157                               These device should contain a *fixed* blockIo
 158                               protocol in their device handle.
 159                               BDS will skip fixed blockIo devices, and NOT
 160                               automatically create boot option for them. But BDS
 161                               will help to delete those fixed blockIo boot option,
 162                               whose description rule conflict with other auto-created
 163                               boot options.
 164   5. Non-BlockIo Simplefile - The boot option points to a device whose handle
 165                               has SimpleFileSystem Protocol, but has no blockio
 166                               protocol. These devices do not offer blockIo
 167                               protocol, but BDS still can get the
 168                               \EFI\BOOT\boot{machinename}.EFI by SimpleFileSystem
 169                               Protocol.
 170   6. File    - The boot option points to a file. These boot options are usually
 171                created by user manually or OS loader. BDS will not delete or modify
 172                these boot options.
 173
 174   This function will enumerate all possible boot device in the system, and
 175   automatically create boot options for Network, Shell, Removable BlockIo,
 176   and Non-BlockIo Simplefile devices.
 177   It will only excute once of every boot.
 178
 179   @param  BdsBootOptionList      The header of the link list which indexed all
 180                                  current boot options
 181
 182   @retval EFI_SUCCESS            Finished all the boot device enumerate and create
 183                                  the boot option base on that boot device
 184
 185 **/
 186 EFI_STATUS
 187 EFIAPI
 188 BdsLibEnumerateAllBootOption (
 189   IN OUT LIST_ENTRY          *BdsBootOptionList
 190   );
 191
 192 /**
 193   Build the boot option with the handle parsed in
 194
 195   @param  Handle                 The handle which present the device path to create
 196                                  boot option
 197   @param  BdsBootOptionList      The header of the link list which indexed all
 198                                  current boot options
 199   @param  String                 The description of the boot option.
 200
 201 **/
 202 VOID
 203 EFIAPI
 204 BdsLibBuildOptionFromHandle (
 205   IN  EFI_HANDLE                 Handle,
 206   IN  LIST_ENTRY                 *BdsBootOptionList,
 207   IN  CHAR16                     *String
 208   );
 209
 210
 211 /**
 212   Build the on flash shell boot option with the handle parsed in.
 213
 214   @param  Handle                 The handle which present the device path to create
 215                                  on flash shell boot option
 216   @param  BdsBootOptionList      The header of the link list which indexed all
 217                                  current boot options
 218
 219 **/
 220 VOID
 221 EFIAPI
 222 BdsLibBuildOptionFromShell (
 223   IN EFI_HANDLE                  Handle,
 224   IN OUT LIST_ENTRY              *BdsBootOptionList
 225   );
 226
 227 //
 228 // Bds misc lib functions
 229 //
 230 /**
 231   Get boot mode by looking up configuration table and parsing HOB list
 232
 233   @param  BootMode              Boot mode from PEI handoff HOB.
 234
 235   @retval EFI_SUCCESS           Successfully get boot mode
 236
 237 **/
 238 EFI_STATUS
 239 EFIAPI
 240 BdsLibGetBootMode (
 241   OUT EFI_BOOT_MODE       *BootMode
 242   );
 243
 244
 245 /**
 246   The function will go through the driver optoin link list, load and start
 247   every driver the driver optoin device path point to.
 248
 249   @param  BdsDriverLists        The header of the current driver option link list
 250
 251 **/
 252 VOID
 253 EFIAPI
 254 BdsLibLoadDrivers (
 255   IN LIST_ENTRY                   *BdsDriverLists
 256   );
 257
 258
 259 /**
 260   Process BootOrder, or DriverOrder variables, by calling
 261   BdsLibVariableToOption () for each UINT16 in the variables.
 262
 263   @param  BdsCommonOptionList   The header of the option list base on variable
 264                                 VariableName
 265   @param  VariableName          EFI Variable name indicate the BootOrder or
 266                                 DriverOrder
 267
 268   @retval EFI_SUCCESS           Success create the boot option or driver option
 269                                 list
 270   @retval EFI_OUT_OF_RESOURCES  Failed to get the boot option or driver option list
 271
 272 **/
 273 EFI_STATUS
 274 EFIAPI
 275 BdsLibBuildOptionFromVar (
 276   IN  LIST_ENTRY                      *BdsCommonOptionList,
 277   IN  CHAR16                          *VariableName
 278   );
 279
 280 /**
 281   Read the EFI variable (VendorGuid/Name) and return a dynamically allocated
 282   buffer, and the size of the buffer. If failure return NULL.
 283
 284   @param  Name                  String part of EFI variable name
 285   @param  VendorGuid            GUID part of EFI variable name
 286   @param  VariableSize          Returns the size of the EFI variable that was read
 287
 288   @return                       Dynamically allocated memory that contains a copy of the EFI variable
 289                                 Caller is responsible freeing the buffer.
 290   @retval NULL                  Variable was not read
 291
 292 **/
 293 VOID *
 294 EFIAPI
 295 BdsLibGetVariableAndSize (
 296   IN  CHAR16              *Name,
 297   IN  EFI_GUID            *VendorGuid,
 298   OUT UINTN               *VariableSize
 299   );
 300
 301
 302 /**
 303   This function prints a series of strings.
 304
 305   @param  ConOut                Pointer to EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
 306   @param  ...                   A variable argument list containing series of
 307                                 strings, the last string must be NULL.
 308
 309   @retval EFI_SUCCESS           Success print out the string using ConOut.
 310   @retval EFI_STATUS            Return the status of the ConOut->OutputString ().
 311
 312 **/
 313 EFI_STATUS
 314 EFIAPI
 315 BdsLibOutputStrings (
 316   IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL   *ConOut,
 317   ...
 318   );
 319
 320 /**
 321   Build the boot#### or driver#### option from the VariableName, the
 322   build boot#### or driver#### will also be linked to BdsCommonOptionList.
 323
 324   @param  BdsCommonOptionList   The header of the boot#### or driver#### option
 325                                 link list
 326   @param  VariableName          EFI Variable name indicate if it is boot#### or
 327                                 driver####
 328
 329   @retval BDS_COMMON_OPTION     Get the option just been created
 330   @retval NULL                  Failed to get the new option
 331
 332 **/
 333 BDS_COMMON_OPTION *
 334 EFIAPI
 335 BdsLibVariableToOption (
 336   IN OUT LIST_ENTRY                   *BdsCommonOptionList,
 337   IN  CHAR16                          *VariableName
 338   );
 339
 340 /**
 341   This function will register the new boot#### or driver#### option base on
 342   the VariableName. The new registered boot#### or driver#### will be linked
 343   to BdsOptionList and also update to the VariableName. After the boot#### or
 344   driver#### updated, the BootOrder or DriverOrder will also be updated.
 345
 346   @param  BdsOptionList         The header of the boot#### or driver#### link list
 347   @param  DevicePath            The device path which the boot#### or driver####
 348                                 option present
 349   @param  String                The description of the boot#### or driver####
 350   @param  VariableName          Indicate if the boot#### or driver#### option
 351
 352   @retval EFI_SUCCESS           The boot#### or driver#### have been success
 353                                 registered
 354   @retval EFI_STATUS            Return the status of gRT->SetVariable ().
 355
 356 **/
 357 EFI_STATUS
 358 EFIAPI
 359 BdsLibRegisterNewOption (
 360   IN  LIST_ENTRY                     *BdsOptionList,
 361   IN  EFI_DEVICE_PATH_PROTOCOL       *DevicePath,
 362   IN  CHAR16                         *String,
 363   IN  CHAR16                         *VariableName
 364   );
 365
 366 //
 367 // Bds connect or disconnect driver lib funcion
 368 //
 369 /**
 370   Connects all drivers to all controllers.
 371   This function make sure all the current system driver will manage
 372   the correspoinding controllers if have. And at the same time, make
 373   sure all the system controllers have driver to manage it if have.
 374
 375 **/
 376 VOID
 377 EFIAPI
 378 BdsLibConnectAllDriversToAllControllers (
 379   VOID
 380   );
 381
 382 /**
 383   This function will connect all the system driver to controller
 384   first, and then special connect the default console, this make
 385   sure all the system controller available and the platform default
 386   console connected.
 387
 388 **/
 389 VOID
 390 EFIAPI
 391 BdsLibConnectAll (
 392   VOID
 393   );
 394
 395 /**
 396   This function will create all handles associate with every device
 397   path node. If the handle associate with one device path node can not
 398   be created success, then still give one chance to do the dispatch,
 399   which load the missing drivers if possible.
 400
 401   @param  DevicePathToConnect   The device path which will be connected, it can be
 402                                 a multi-instance device path
 403
 404   @retval EFI_SUCCESS           All handles associate with every device path  node
 405                                 have been created
 406   @retval EFI_OUT_OF_RESOURCES  There is no resource to create new handles
 407   @retval EFI_NOT_FOUND         Create the handle associate with one device  path
 408                                 node failed
 409
 410 **/
 411 EFI_STATUS
 412 EFIAPI
 413 BdsLibConnectDevicePath (
 414   IN EFI_DEVICE_PATH_PROTOCOL  *DevicePathToConnect
 415   );
 416
 417 /**
 418   This function will connect all current system handles recursively. The
 419   connection will finish until every handle's child handle created if it have.
 420
 421   @retval EFI_SUCCESS           All handles and it's child handle have been
 422                                 connected
 423   @retval EFI_STATUS            Return the status of gBS->LocateHandleBuffer().
 424
 425 **/
 426 EFI_STATUS
 427 EFIAPI
 428 BdsLibConnectAllEfi (
 429   VOID
 430   );
 431
 432
 433 /**
 434   This function will disconnect all current system handles. The disconnection
 435   will finish until every handle have been disconnected.
 436
 437   @retval EFI_SUCCESS           All handles have been disconnected
 438   @retval EFI_STATUS            Return the status of gBS->LocateHandleBuffer().
 439
 440 **/
 441 EFI_STATUS
 442 EFIAPI
 443 BdsLibDisconnectAllEfi (
 444   VOID
 445   );
 446
 447 //
 448 // Bds console related lib functions
 449 //
 450 /**
 451   This function will search every simpletxt devive in current system,
 452   and make every simpletxt device as pertantial console device.
 453
 454 **/
 455 VOID
 456 EFIAPI
 457 BdsLibConnectAllConsoles (
 458   VOID
 459   );
 460
 461
 462 /**
 463   This function will connect console device base on the console
 464   device variable ConIn, ConOut and ErrOut.
 465
 466   @retval EFI_SUCCESS              At least one of the ConIn and ConOut device have
 467                                    been connected success.
 468   @retval EFI_STATUS               Return the status of BdsLibConnectConsoleVariable ().
 469
 470 **/
 471 EFI_STATUS
 472 EFIAPI
 473 BdsLibConnectAllDefaultConsoles (
 474   VOID
 475   );
 476
 477 /**
 478   This function update console variable based on ConVarName, it can
 479   add or remove one specific console device path from the variable
 480
 481   @param  ConVarName               Console related variable name, ConIn, ConOut,
 482                                    ErrOut.
 483   @param  CustomizedConDevicePath  The console device path which will be added to
 484                                    the console variable ConVarName, this parameter
 485                                    can not be multi-instance.
 486   @param  ExclusiveDevicePath      The console device path which will be removed
 487                                    from the console variable ConVarName, this
 488                                    parameter can not be multi-instance.
 489
 490   @retval EFI_UNSUPPORTED          The added device path is same to the removed one.
 491   @retval EFI_SUCCESS              Success add or remove the device path from  the
 492                                    console variable.
 493
 494 **/
 495 EFI_STATUS
 496 EFIAPI
 497 BdsLibUpdateConsoleVariable (
 498   IN  CHAR16                    *ConVarName,
 499   IN  EFI_DEVICE_PATH_PROTOCOL  *CustomizedConDevicePath,
 500   IN  EFI_DEVICE_PATH_PROTOCOL  *ExclusiveDevicePath
 501   );
 502
 503 /**
 504   Connect the console device base on the variable ConVarName, if
 505   device path of the ConVarName is multi-instance device path, if
 506   anyone of the instances is connected success, then this function
 507   will return success.
 508
 509   @param  ConVarName               Console related variable name, ConIn, ConOut,
 510                                    ErrOut.
 511
 512   @retval EFI_NOT_FOUND            There is not any console devices connected
 513                                    success
 514   @retval EFI_SUCCESS              Success connect any one instance of the console
 515                                    device path base on the variable ConVarName.
 516
 517 **/
 518 EFI_STATUS
 519 EFIAPI
 520 BdsLibConnectConsoleVariable (
 521   IN  CHAR16                 *ConVarName
 522   );
 523
 524 //
 525 // Bds device path related lib functions
 526 //
 527 /**
 528   Delete the instance in Multi which matches partly with Single instance
 529
 530   @param  Multi                 A pointer to a multi-instance device path data
 531                                 structure.
 532   @param  Single                A pointer to a single-instance device path data
 533                                 structure.
 534
 535   @return This function will remove the device path instances in Multi which partly
 536           match with the Single, and return the result device path. If there is no
 537           remaining device path as a result, this function will return NULL.
 538
 539 **/
 540 EFI_DEVICE_PATH_PROTOCOL *
 541 EFIAPI
 542 BdsLibDelPartMatchInstance (
 543   IN     EFI_DEVICE_PATH_PROTOCOL  *Multi,
 544   IN     EFI_DEVICE_PATH_PROTOCOL  *Single
 545   );
 546
 547 /**
 548   Function compares a device path data structure to that of all the nodes of a
 549   second device path instance.
 550
 551   @param  Multi                 A pointer to a multi-instance device path data
 552                                 structure.
 553   @param  Single                A pointer to a single-instance device path data
 554                                 structure.
 555
 556   @retval TRUE                  If the Single device path is contained within Multi device path.
 557   @retval FALSE                 The Single device path is not match within Multi device path.
 558
 559 **/
 560 BOOLEAN
 561 EFIAPI
 562 BdsLibMatchDevicePaths (
 563   IN  EFI_DEVICE_PATH_PROTOCOL  *Multi,
 564   IN  EFI_DEVICE_PATH_PROTOCOL  *Single
 565   );
 566
 567 /**
 568   This function converts an input device structure to a Unicode string.
 569
 570   @param DevPath                  A pointer to the device path structure.
 571
 572   @return A new allocated Unicode string that represents the device path.
 573
 574 **/
 575 CHAR16 *
 576 EFIAPI
 577 DevicePathToStr (
 578   IN EFI_DEVICE_PATH_PROTOCOL     *DevPath
 579   );
 580
 581
 582 //
 583 // Internal definitions
 584 //
 585 typedef struct {
 586   CHAR16  *Str;
 587   UINTN   Len;
 588   UINTN   Maxlen;
 589 } POOL_PRINT;
 590
 591 typedef struct {
 592   UINT8 Type;
 593   UINT8 SubType;
 594   VOID (*Function) (POOL_PRINT *, VOID *);
 595 } DEVICE_PATH_STRING_TABLE;
 596
 597 extern EFI_GUID mEfiDevicePathMessagingUartFlowControlGuid;
 598
 599 typedef struct {
 600   EFI_DEVICE_PATH_PROTOCOL  Header;
 601   EFI_GUID                  Guid;
 602   UINT8                     VendorDefinedData[1];
 603 } VENDOR_DEVICE_PATH_WITH_DATA;
 604
 605
 606 extern EFI_GUID mEfiDevicePathMessagingSASGuid;
 607
 608 typedef struct {
 609   EFI_DEVICE_PATH_PROTOCOL  Header;
 610   UINT16                    NetworkProtocol;
 611   UINT16                    LoginOption;
 612   UINT64                    Lun;
 613   UINT16                    TargetPortalGroupTag;
 614   CHAR16                    TargetName[1];
 615 } ISCSI_DEVICE_PATH_WITH_NAME;
 616
 617
 618 //
 619 // Notes: EFI 64 shadow all option rom
 620 //
 621 #if defined (MDE_CPU_IPF)
 622 #define EFI64_SHADOW_ALL_LEGACY_ROM() ShadowAllOptionRom ();
 623 #else
 624 #define EFI64_SHADOW_ALL_LEGACY_ROM()
 625 #endif
 626
 627 /**
 628   Shadow all Legacy OptionRom.
 629
 630 **/
 631 VOID
 632 EFIAPI
 633 ShadowAllOptionRom (
 634   VOID
 635   );
 636
 637 //
 638 // BBS support macros and functions
 639 //
 640
 641 #if defined(MDE_CPU_IA32) || defined(MDE_CPU_X64)
 642 #define REFRESH_LEGACY_BOOT_OPTIONS \
 643         BdsDeleteAllInvalidLegacyBootOptions ();\
 644         BdsAddNonExistingLegacyBootOptions (); \
 645         BdsUpdateLegacyDevOrder ()
 646 #else
 647 #define REFRESH_LEGACY_BOOT_OPTIONS
 648 #endif
 649
 650 /**
 651   Delete all the invalid legacy boot options.
 652
 653   @retval EFI_SUCCESS             All invalide legacy boot options are deleted.
 654   @retval EFI_OUT_OF_RESOURCES    Fail to allocate necessary memory.
 655   @retval EFI_NOT_FOUND           Fail to retrive variable of boot order.
 656
 657 **/
 658 EFI_STATUS
 659 EFIAPI
 660 BdsDeleteAllInvalidLegacyBootOptions (
 661   VOID
 662   );
 663
 664 /**
 665
 666   Add the legacy boot options from BBS table if they do not exist.
 667
 668   @retval EFI_SUCCESS       The boot options are added successfully
 669                             or they are already in boot options.
 670
 671 **/
 672 EFI_STATUS
 673 EFIAPI
 674 BdsAddNonExistingLegacyBootOptions (
 675   VOID
 676   );
 677
 678 /**
 679
 680   Add the legacy boot devices from BBS table into
 681   the legacy device boot order.
 682
 683   @retval EFI_SUCCESS       The boot devices are added successfully.
 684
 685 **/
 686 EFI_STATUS
 687 EFIAPI
 688 BdsUpdateLegacyDevOrder (
 689   VOID
 690   );
 691
 692 /**
 693
 694   Set the boot priority for BBS entries based on boot option entry and boot order.
 695
 696   @param  Entry             The boot option is to be checked for refresh BBS table.
 697
 698   @retval EFI_SUCCESS       The boot priority for BBS entries is refreshed successfully.
 699
 700 **/
 701 EFI_STATUS
 702 EFIAPI
 703 BdsRefreshBbsTableForBoot (
 704   IN BDS_COMMON_OPTION        *Entry
 705   );
 706
 707 /**
 708
 709   Delete boot option specified by OptionNumber and adjust the boot order.
 710
 711   @param  OptionNumber      The boot option to be deleted.
 712   @param  BootOrder         Boot order list to be adjusted by remove this boot option.
 713   @param  BootOrderSize     The size of Boot order list will be modified.
 714
 715   @retval EFI_SUCCESS       The boot option is deleted successfully.
 716
 717 **/
 718 EFI_STATUS
 719 EFIAPI
 720 BdsDeleteBootOption (
 721   IN UINTN                       OptionNumber,
 722   IN OUT UINT16                  *BootOrder,
 723   IN OUT UINTN                   *BootOrderSize
 724   );
 725
 726 //
 727 //The interface functions relate with Setup Browser Reset Reminder feature
 728 //
 729 /**
 730   Enable the setup browser reset reminder feature.
 731   This routine is used in platform tip. If the platform policy need the feature, use the routine to enable it.
 732
 733 **/
 734 VOID
 735 EFIAPI
 736 EnableResetReminderFeature (
 737   VOID
 738   );
 739
 740 /**
 741   Disable the setup browser reset reminder feature.
 742   This routine is used in platform tip. If the platform policy do not want the feature, use the routine to disable it.
 743
 744 **/
 745 VOID
 746 EFIAPI
 747 DisableResetReminderFeature (
 748   VOID
 749   );
 750
 751 /**
 752   Record the info that  a reset is required.
 753   A  module boolean variable is used to record whether a reset is required.
 754
 755 **/
 756 VOID
 757 EFIAPI
 758 EnableResetRequired (
 759   VOID
 760   );
 761
 762
 763 /**
 764   Record the info that  no reset is required.
 765   A  module boolean variable is used to record whether a reset is required.
 766
 767 **/
 768 VOID
 769 EFIAPI
 770 DisableResetRequired (
 771   VOID
 772   );
 773
 774 /**
 775   Check whether platform policy enable the reset reminder feature. The default is enabled.
 776
 777 **/
 778 BOOLEAN
 779 EFIAPI
 780 IsResetReminderFeatureEnable (
 781   VOID
 782   );
 783
 784 /**
 785   Check if  user changed any option setting which needs a system reset to be effective.
 786
 787 **/
 788 BOOLEAN
 789 EFIAPI
 790 IsResetRequired (
 791   VOID
 792   );
 793
 794 /**
 795   Check whether a reset is needed, and finish the reset reminder feature.
 796   If a reset is needed, Popup a menu to notice user, and finish the feature
 797   according to the user selection.
 798
 799 **/
 800 VOID
 801 EFIAPI
 802 SetupResetReminder (
 803   VOID
 804   );
 805
 806
 807 //
 808 // Define the boot option default description
 809 // NOTE: This is not defined in UEFI spec.
 810 //
 811 #define DESCRIPTION_FLOPPY        L"EFI Floppy"
 812 #define DESCRIPTION_FLOPPY_NUM    L"EFI Floppy %d"
 813 #define DESCRIPTION_DVD           L"EFI DVD/CDROM"
 814 #define DESCRIPTION_DVD_NUM       L"EFI DVD/CDROM %d"
 815 #define DESCRIPTION_USB           L"EFI USB Device"
 816 #define DESCRIPTION_USB_NUM       L"EFI USB Device %d"
 817 #define DESCRIPTION_SCSI          L"EFI SCSI Device"
 818 #define DESCRIPTION_SCSI_NUM      L"EFI SCSI Device %d"
 819 #define DESCRIPTION_MISC          L"EFI Misc Device"
 820 #define DESCRIPTION_MISC_NUM      L"EFI Misc Device %d"
 821 #define DESCRIPTION_NETWORK       L"EFI Network"
 822 #define DESCRIPTION_NETWORK_NUM   L"EFI Network %d"
 823 #define DESCRIPTION_NON_BLOCK     L"EFI Non-Block Boot Device"
 824 #define DESCRIPTION_NON_BLOCK_NUM L"EFI Non-Block Boot Device %d"
 825
 826 //
 827 // Define the boot type which to classify the boot option type
 828 // Different boot option type could have different boot behavior
 829 // Use their device path node (Type + SubType) as type value
 830 // The boot type here can be added according to requirement
 831 //
 832 //
 833 // ACPI boot type. For ACPI device, cannot use sub-type to distinguish device, so hardcode their value
 834 //
 835 #define  BDS_EFI_ACPI_FLOPPY_BOOT         0x0201
 836 //
 837 // Message boot type
 838 // If a device path of boot option only point to a message node, the boot option is message boot type
 839 //
 840 #define  BDS_EFI_MESSAGE_ATAPI_BOOT       0x0301 // Type 03; Sub-Type 01
 841 #define  BDS_EFI_MESSAGE_SCSI_BOOT        0x0302 // Type 03; Sub-Type 02
 842 #define  BDS_EFI_MESSAGE_USB_DEVICE_BOOT  0x0305 // Type 03; Sub-Type 05
 843 #define  BDS_EFI_MESSAGE_SATA_BOOT        0x0318 // Type 03; Sub-Type 18
 844 #define  BDS_EFI_MESSAGE_MISC_BOOT        0x03FF
 845 //
 846 // Media boot type
 847 // If a device path of boot option contain a media node, the boot option is media boot type
 848 //
 849 #define  BDS_EFI_MEDIA_HD_BOOT            0x0401 // Type 04; Sub-Type 01
 850 #define  BDS_EFI_MEDIA_CDROM_BOOT         0x0402 // Type 04; Sub-Type 02
 851 //
 852 // BBS boot type
 853 // If a device path of boot option contain a BBS node, the boot option is BBS boot type
 854 //
 855 #define  BDS_LEGACY_BBS_BOOT              0x0501 //  Type 05; Sub-Type 01
 856
 857 #define  BDS_EFI_UNSUPPORT                0xFFFF
 858
 859 //
 860 // USB host controller Programming Interface.
 861 //
 862 #define  PCI_CLASSC_PI_UHCI               0x00
 863 #define  PCI_CLASSC_PI_EHCI               0x20
 864
 865 /**
 866   Check whether there is a instance in BlockIoDevicePath, which contain multi device path
 867   instances, has the same partition node with HardDriveDevicePath device path
 868
 869   @param  BlockIoDevicePath      Multi device path instances which need to check
 870   @param  HardDriveDevicePath    A device path which starts with a hard drive media
 871                                  device path.
 872
 873   @retval TRUE                   There is a matched device path instance.
 874   @retval FALSE                  There is no matched device path instance.
 875
 876 **/
 877 BOOLEAN
 878 EFIAPI
 879 MatchPartitionDevicePathNode (
 880   IN  EFI_DEVICE_PATH_PROTOCOL   *BlockIoDevicePath,
 881   IN  HARDDRIVE_DEVICE_PATH      *HardDriveDevicePath
 882   );
 883
 884
 885 /**
 886   Expand a device path that starts with a hard drive media device path node to be a
 887   full device path that includes the full hardware path to the device. We need
 888   to do this so it can be booted. As an optimizaiton the front match (the part point
 889   to the partition node. E.g. ACPI() /PCI()/ATA()/Partition() ) is saved in a variable
 890   so a connect all is not required on every boot. All successful history device path
 891   which point to partition node (the front part) will be saved.
 892
 893   @param  HardDriveDevicePath    EFI Device Path to boot, if it starts with a hard
 894                                  drive media device path.
 895   @return A Pointer to the full device path or NULL if a valid Hard Drive devic path
 896           cannot be found.
 897
 898 **/
 899 EFI_DEVICE_PATH_PROTOCOL *
 900 EFIAPI
 901 BdsExpandPartitionPartialDevicePathToFull (
 902   IN  HARDDRIVE_DEVICE_PATH      *HardDriveDevicePath
 903   );
 904
 905 /**
 906   Return the bootable media handle.
 907   First, check the device is connected
 908   Second, check whether the device path point to a device which support SimpleFileSystemProtocol,
 909   Third, detect the the default boot file in the Media, and return the removable Media handle.
 910
 911   @param  DevicePath             Device Path to a  bootable device
 912
 913   @retval NULL                   The media on the DevicePath is not bootable
 914
 915 **/
 916 EFI_HANDLE
 917 EFIAPI
 918 BdsLibGetBootableHandle (
 919   IN  EFI_DEVICE_PATH_PROTOCOL      *DevicePath
 920   );
 921
 922
 923 /**
 924   Check whether the Device path in a boot option point to a valide bootable device,
 925   And if CheckMedia is true, check the device is ready to boot now.
 926
 927   @param  DevPath     the Device path in a boot option
 928   @param  CheckMedia  if true, check the device is ready to boot now.
 929
 930   @retval TRUE        the Device path  is valide
 931   @retval FALSE       the Device path  is invalide .
 932
 933 **/
 934 BOOLEAN
 935 EFIAPI
 936 BdsLibIsValidEFIBootOptDevicePath (
 937   IN EFI_DEVICE_PATH_PROTOCOL     *DevPath,
 938   IN BOOLEAN                      CheckMedia
 939   );
 940
 941 /**
 942   Check whether the Device path in a boot option point to a valid bootable device,
 943   And if CheckMedia is true, check the device is ready to boot now.
 944   If Description is not NULL and the device path point to a fixed BlockIo
 945   device, check the description whether conflict with other auto-created
 946   boot options.
 947
 948   @param  DevPath     the Device path in a boot option
 949   @param  CheckMedia  if true, check the device is ready to boot now.
 950   @param  Description the description in a boot option
 951
 952   @retval TRUE        the Device path  is valid
 953   @retval FALSE       the Device path  is invalid .
 954
 955 **/
 956 BOOLEAN
 957 EFIAPI
 958 BdsLibIsValidEFIBootOptDevicePathExt (
 959   IN EFI_DEVICE_PATH_PROTOCOL     *DevPath,
 960   IN BOOLEAN                      CheckMedia,
 961   IN CHAR16                       *Description
 962   );
 963
 964 /**
 965   For a bootable Device path, return its boot type.
 966
 967   @param  DevicePath                      The bootable device Path to check
 968
 969   @retval BDS_EFI_MEDIA_HD_BOOT           If the device path contains any media deviec path node, it is media boot type
 970                                           For the floppy node, handle it as media node
 971   @retval BDS_EFI_MEDIA_CDROM_BOOT        If the device path contains any media deviec path node, it is media boot type
 972                                           For the floppy node, handle it as media node
 973   @retval BDS_EFI_ACPI_FLOPPY_BOOT        If the device path contains any media deviec path node, it is media boot type
 974                                           For the floppy node, handle it as media node
 975   @retval BDS_EFI_MESSAGE_ATAPI_BOOT      If the device path not contains any media deviec path node,  and
 976                                           its last device path node point to a message device path node, it is
 977
 978   @retval BDS_EFI_MESSAGE_SCSI_BOOT       If the device path not contains any media deviec path node,  and
 979                                           its last device path node point to a message device path node, it is
 980   @retval BDS_EFI_MESSAGE_USB_DEVICE_BOOT If the device path not contains any media deviec path node,  and
 981                                           its last device path node point to a message device path node, it is
 982   @retval BDS_EFI_MESSAGE_MISC_BOOT       If the device path not contains any media deviec path node,  and
 983                                           its last device path node point to a message device path node, it is
 984   @retval BDS_LEGACY_BBS_BOOT             Legacy boot type
 985   @retval BDS_EFI_UNSUPPORT               An EFI Removable BlockIO device path not point to a media and message devie,
 986
 987 **/
 988 UINT32
 989 EFIAPI
 990 BdsGetBootTypeFromDevicePath (
 991   IN  EFI_DEVICE_PATH_PROTOCOL     *DevicePath
 992   );
 993
 994
 995 /**
 996   This routine register a function to adjust the different type memory page number
 997   just before booting and save the updated info into the variable for next boot to use.
 998
 999 **/
1000 VOID
1001 EFIAPI
1002 BdsLibSaveMemoryTypeInformation (
1003   VOID
1004   );
1005
1006
1007 /**
1008   According to a file guild, check a Fv file device path is valid. If it is invalid,
1009   try to return the valid device path.
1010   FV address maybe changes for memory layout adjust from time to time, use this funciton
1011   could promise the Fv file device path is right.
1012
1013   @param  DevicePath             on input, the Fv file device path need to check on
1014                                  output, the updated valid Fv file device path
1015   @param  FileGuid               the Fv file guild
1016
1017   @retval EFI_INVALID_PARAMETER  the input DevicePath or FileGuid is invalid
1018                                  parameter
1019   @retval EFI_UNSUPPORTED        the input DevicePath does not contain Fv file
1020                                  guild at all
1021   @retval EFI_ALREADY_STARTED    the input DevicePath has pointed to Fv file, it is
1022                                  valid
1023   @retval EFI_SUCCESS            has successfully updated the invalid DevicePath,
1024                                  and return the updated device path in DevicePath
1025
1026 **/
1027 EFI_STATUS
1028 EFIAPI
1029 BdsLibUpdateFvFileDevicePath (
1030   IN  OUT EFI_DEVICE_PATH_PROTOCOL      ** DevicePath,
1031   IN  EFI_GUID                          *FileGuid
1032   );
1033
1034
1035 /**
1036   Connect the specific Usb device which match the short form device path,
1037   and whose bus is determined by Host Controller (Uhci or Ehci)
1038
1039   @param  HostControllerPI      Uhci (0x00) or Ehci (0x20) or Both uhci and ehci
1040                                 (0xFF)
1041   @param  RemainingDevicePath   a short-form device path that starts with the first
1042                                 element being a USB WWID or a USB Class device
1043                                 path
1044
1045   @retval EFI_SUCCESS           The specific Usb device is connected successfully.
1046   @retval EFI_INVALID_PARAMETER Invalid HostControllerPi (not 0x00, 0x20 or 0xFF)
1047                                 or RemainingDevicePath is not the USB class device path.
1048   @retval EFI_NOT_FOUND         The device specified by device path is not found.
1049
1050 **/
1051 EFI_STATUS
1052 EFIAPI
1053 BdsLibConnectUsbDevByShortFormDP(
1054   IN UINT8                      HostControllerPI,
1055   IN EFI_DEVICE_PATH_PROTOCOL   *RemainingDevicePath
1056   );
1057
1058
1059 //
1060 // The implementation of this function is provided by Platform code.
1061 //
1062 /**
1063   Convert Vendor device path to device name.
1064
1065   @param  Str      The buffer store device name
1066   @param  DevPath  Pointer to vendor device path
1067
1068 **/
1069 VOID
1070 DevPathVendor (
1071   IN OUT POOL_PRINT       *Str,
1072   IN VOID                 *DevPath
1073   );
1074
1075 /**
1076   Concatenates a formatted unicode string to allocated pool.
1077   The caller must free the resulting buffer.
1078
1079   @param  Str      Tracks the allocated pool, size in use, and amount of pool allocated.
1080   @param  Fmt      The format string
1081   @param  ...      The data will be printed.
1082
1083   @return Allocated buffer with the formatted string printed in it.
1084           The caller must free the allocated buffer.
1085           The buffer allocation is not packed.
1086
1087 **/
1088 CHAR16 *
1089 EFIAPI
1090 CatPrint (
1091   IN OUT POOL_PRINT   *Str,
1092   IN CHAR16           *Fmt,
1093   ...
1094   );
1095
1096 /**
1097   Use Console Control to turn off UGA based Simple Text Out consoles from going
1098   to the UGA device. Put up LogoFile on every UGA device that is a console
1099
1100   @param[in]  LogoFile   File name of logo to display on the center of the screen.
1101
1102   @retval EFI_SUCCESS     ConsoleControl has been flipped to graphics and logo displayed.
1103   @retval EFI_UNSUPPORTED Logo not found
1104
1105 **/
1106 EFI_STATUS
1107 EFIAPI
1108 EnableQuietBoot (
1109   IN  EFI_GUID  *LogoFile
1110   );
1111
1112
1113 /**
1114   Use Console Control to turn on UGA based Simple Text Out consoles. The UGA
1115   Simple Text Out screens will now be synced up with all non UGA output devices
1116
1117   @retval EFI_SUCCESS     UGA devices are back in text mode and synced up.
1118
1119 **/
1120 EFI_STATUS
1121 EFIAPI
1122 DisableQuietBoot (
1123   VOID
1124   );
1125
1126 /**
1127   Use Console Control Protocol to lock the Console In Spliter virtual handle.
1128   This is the ConInHandle and ConIn handle in the EFI system table. All key
1129   presses will be ignored until the Password is typed in. The only way to
1130   disable the password is to type it in to a ConIn device.
1131
1132   @param  Password        Password used to lock ConIn device.
1133
1134   @retval EFI_SUCCESS     lock the Console In Spliter virtual handle successfully.
1135   @retval EFI_UNSUPPORTED Password not found
1136
1137 **/
1138 EFI_STATUS
1139 EFIAPI
1140 LockKeyboards (
1141   IN  CHAR16    *Password
1142   );
1143
1144 #endif
1145