MdeModulePkg/Include/Library/GenericBdsLib.h

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