EdkModulePkg/Library/EdkGenericBdsLib/BdsMisc.c

   1 /*++
   2
   3 Copyright (c) 2006 - 2007, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   BdsMisc.c
  15
  16 Abstract:
  17
  18   Misc BDS library function
  19
  20 --*/
  21
  22 #define MAX_STRING_LEN        200
  23 static BOOLEAN   mFeaturerSwitch = TRUE;
  24 static BOOLEAN   mResetRequired  = FALSE;
  25 extern UINT16 gPlatformBootTimeOutDefault;
  26
  27 UINT16
  28 BdsLibGetTimeout (
  29   VOID
  30   )
  31 /*++
  32
  33 Routine Description:
  34
  35   Return the default value for system Timeout variable.
  36
  37 Arguments:
  38
  39   None
  40
  41 Returns:
  42
  43   Timeout value.
  44
  45 --*/
  46 {
  47   UINT16      Timeout;
  48   UINTN       Size;
  49   EFI_STATUS  Status;
  50
  51   //
  52   // Return Timeout variable or 0xffff if no valid
  53   // Timeout variable exists.
  54   //
  55   Size    = sizeof (UINT16);
  56   Status  = gRT->GetVariable (L"Timeout", &gEfiGlobalVariableGuid, NULL, &Size, &Timeout);
  57   if (!EFI_ERROR (Status)) {
  58     return Timeout;
  59   }
  60   //
  61   // To make the current EFI Automatic-Test activity possible, just add
  62   // following code to make AutoBoot enabled when this variable is not
  63   // present.
  64   // This code should be removed later.
  65   //
  66   Timeout = gPlatformBootTimeOutDefault;
  67
  68   //
  69   // Notes: Platform should set default variable if non exists on all error cases!!!
  70   //
  71   Status = gRT->SetVariable (
  72                   L"Timeout",
  73                   &gEfiGlobalVariableGuid,
  74                   EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
  75                   sizeof (UINT16),
  76                   &Timeout
  77                   );
  78   return Timeout;
  79 }
  80
  81 VOID
  82 BdsLibLoadDrivers (
  83   IN LIST_ENTRY               *BdsDriverLists
  84   )
  85 /*++
  86
  87 Routine Description:
  88
  89   The function will go through the driver optoin link list, load and start
  90   every driver the driver optoin device path point to.
  91
  92 Arguments:
  93
  94   BdsDriverLists   - The header of the current driver option link list
  95
  96 Returns:
  97
  98   None
  99
 100 --*/
 101 {
 102   EFI_STATUS                Status;
 103   LIST_ENTRY                *Link;
 104   BDS_COMMON_OPTION         *Option;
 105   EFI_HANDLE                ImageHandle;
 106   EFI_LOADED_IMAGE_PROTOCOL *ImageInfo;
 107   UINTN                     ExitDataSize;
 108   CHAR16                    *ExitData;
 109   BOOLEAN                   ReconnectAll;
 110
 111   ReconnectAll = FALSE;
 112
 113   //
 114   // Process the driver option
 115   //
 116   for (Link = BdsDriverLists->ForwardLink; Link != BdsDriverLists; Link = Link->ForwardLink) {
 117     Option = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
 118     //
 119     // If a load option is not marked as LOAD_OPTION_ACTIVE,
 120     // the boot manager will not automatically load the option.
 121     //
 122     if (!IS_LOAD_OPTION_TYPE (Option->Attribute, LOAD_OPTION_ACTIVE)) {
 123       continue;
 124     }
 125     //
 126     // If a driver load option is marked as LOAD_OPTION_FORCE_RECONNECT,
 127     // then all of the EFI drivers in the system will be disconnected and
 128     // reconnected after the last driver load option is processed.
 129     //
 130     if (IS_LOAD_OPTION_TYPE (Option->Attribute, LOAD_OPTION_FORCE_RECONNECT)) {
 131       ReconnectAll = TRUE;
 132     }
 133     //
 134     // Make sure the driver path is connected.
 135     //
 136     BdsLibConnectDevicePath (Option->DevicePath);
 137
 138     //
 139     // Load and start the image that Driver#### describes
 140     //
 141     Status = gBS->LoadImage (
 142                     FALSE,
 143                     mBdsImageHandle,
 144                     Option->DevicePath,
 145                     NULL,
 146                     0,
 147                     &ImageHandle
 148                     );
 149
 150     if (!EFI_ERROR (Status)) {
 151       gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid,
 152                            (VOID **)&ImageInfo);
 153
 154       //
 155       // Verify whether this image is a driver, if not,
 156       // exit it and continue to parse next load option
 157       //
 158       if (ImageInfo->ImageCodeType != EfiBootServicesCode && ImageInfo->ImageCodeType != EfiRuntimeServicesCode) {
 159         gBS->Exit (ImageHandle, EFI_INVALID_PARAMETER, 0, NULL);
 160         continue;
 161       }
 162
 163       if (Option->LoadOptionsSize != 0) {
 164         ImageInfo->LoadOptionsSize  = Option->LoadOptionsSize;
 165         ImageInfo->LoadOptions      = Option->LoadOptions;
 166       }
 167       //
 168       // Before calling the image, enable the Watchdog Timer for
 169       // the 5 Minute period
 170       //
 171       gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
 172
 173       Status = gBS->StartImage (ImageHandle, &ExitDataSize, &ExitData);
 174       DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Driver Return Status = %r\n", Status));
 175
 176       //
 177       // Clear the Watchdog Timer after the image returns
 178       //
 179       gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
 180     }
 181   }
 182   //
 183   // Process the LOAD_OPTION_FORCE_RECONNECT driver option
 184   //
 185   if (ReconnectAll) {
 186     BdsLibDisconnectAllEfi ();
 187     BdsLibConnectAll ();
 188   }
 189
 190 }
 191
 192 EFI_STATUS
 193 BdsLibRegisterNewOption (
 194   IN  LIST_ENTRY                     *BdsOptionList,
 195   IN  EFI_DEVICE_PATH_PROTOCOL       *DevicePath,
 196   IN  CHAR16                         *String,
 197   IN  CHAR16                         *VariableName
 198   )
 199 /*++
 200
 201 Routine Description:
 202
 203   This function will register the new boot#### or driver#### option base on
 204   the VariableName. The new registered boot#### or driver#### will be linked
 205   to BdsOptionList and also update to the VariableName. After the boot#### or
 206   driver#### updated, the BootOrder or DriverOrder will also be updated.
 207
 208 Arguments:
 209
 210   BdsOptionList    - The header of the boot#### or driver#### link list
 211
 212   DevicePath       - The device path which the boot####
 213                      or driver#### option present
 214
 215   String           - The description of the boot#### or driver####
 216
 217   VariableName     - Indicate if the boot#### or driver#### option
 218
 219 Returns:
 220
 221   EFI_SUCCESS      - The boot#### or driver#### have been success registered
 222
 223   EFI_STATUS       - Return the status of gRT->SetVariable ().
 224
 225 --*/
 226 {
 227   EFI_STATUS                Status;
 228   UINTN                     Index;
 229   UINT16                    MaxOptionNumber;
 230   UINT16                    RegisterOptionNumber;
 231   UINT16                    *TempOptionPtr;
 232   UINTN                     TempOptionSize;
 233   UINT16                    *OptionOrderPtr;
 234   VOID                      *OptionPtr;
 235   UINTN                     OptionSize;
 236   UINT8                     *TempPtr;
 237   EFI_DEVICE_PATH_PROTOCOL  *OptionDevicePath;
 238   CHAR16                    *Description;
 239   CHAR16                    OptionName[10];
 240   BOOLEAN                   UpdateBootDevicePath;
 241
 242   OptionPtr             = NULL;
 243   OptionSize            = 0;
 244   TempPtr               = NULL;
 245   OptionDevicePath      = NULL;
 246   Description           = NULL;
 247   MaxOptionNumber       = 0;
 248   OptionOrderPtr        = NULL;
 249   UpdateBootDevicePath  = FALSE;
 250   ZeroMem (OptionName, sizeof (OptionName));
 251
 252   TempOptionSize = 0;
 253   TempOptionPtr = BdsLibGetVariableAndSize (
 254                     VariableName,
 255                     &gEfiGlobalVariableGuid,
 256                     &TempOptionSize
 257                     );
 258   //
 259   // Compare with current option variable
 260   //
 261   for (Index = 0; Index < TempOptionSize / sizeof (UINT16); Index++) {
 262     //
 263     // Got the max option#### number
 264     //
 265     if (MaxOptionNumber < TempOptionPtr[Index]) {
 266       MaxOptionNumber = TempOptionPtr[Index];
 267     }
 268
 269     if (*VariableName == 'B') {
 270       UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", TempOptionPtr[Index]);
 271     } else {
 272       UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", TempOptionPtr[Index]);
 273     }
 274
 275     OptionPtr = BdsLibGetVariableAndSize (
 276                   OptionName,
 277                   &gEfiGlobalVariableGuid,
 278                   &OptionSize
 279                   );
 280     TempPtr = OptionPtr;
 281     TempPtr += sizeof (UINT32) + sizeof (UINT16);
 282     Description = (CHAR16 *) TempPtr;
 283     TempPtr += StrSize ((CHAR16 *) TempPtr);
 284     OptionDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
 285
 286     //
 287     // Notes: the description may will change base on the GetStringToken
 288     //
 289     if (CompareMem (Description, String, StrSize (Description)) == 0) {
 290       if (CompareMem (OptionDevicePath, DevicePath, GetDevicePathSize (OptionDevicePath)) == 0) {
 291         //
 292         // Got the option, so just return
 293         //
 294         gBS->FreePool (OptionPtr);
 295         gBS->FreePool (TempOptionPtr);
 296         return EFI_SUCCESS;
 297       } else {
 298         //
 299         // Boot device path changed, need update.
 300         //
 301         UpdateBootDevicePath = TRUE;
 302         break;
 303       }
 304     }
 305
 306     gBS->FreePool (OptionPtr);
 307   }
 308
 309   OptionSize          = sizeof (UINT32) + sizeof (UINT16) + StrSize (String) + GetDevicePathSize (DevicePath);
 310   OptionPtr           = AllocateZeroPool (OptionSize);
 311   TempPtr             = OptionPtr;
 312   *(UINT32 *) TempPtr = LOAD_OPTION_ACTIVE;
 313   TempPtr += sizeof (UINT32);
 314   *(UINT16 *) TempPtr = (UINT16) GetDevicePathSize (DevicePath);
 315   TempPtr += sizeof (UINT16);
 316   CopyMem (TempPtr, String, StrSize (String));
 317   TempPtr += StrSize (String);
 318   CopyMem (TempPtr, DevicePath, GetDevicePathSize (DevicePath));
 319
 320   if (UpdateBootDevicePath) {
 321     //
 322     // The number in option#### to be updated
 323     //
 324     RegisterOptionNumber = TempOptionPtr[Index];
 325   } else {
 326     //
 327     // The new option#### number
 328     //
 329     RegisterOptionNumber = MaxOptionNumber + 1;
 330   }
 331
 332   if (*VariableName == 'B') {
 333     UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", RegisterOptionNumber);
 334   } else {
 335     UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", RegisterOptionNumber);
 336   }
 337
 338   Status = gRT->SetVariable (
 339                   OptionName,
 340                   &gEfiGlobalVariableGuid,
 341                   EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
 342                   OptionSize,
 343                   OptionPtr
 344                   );
 345   if (EFI_ERROR (Status) || UpdateBootDevicePath) {
 346     gBS->FreePool (OptionPtr);
 347     gBS->FreePool (TempOptionPtr);
 348     return Status;
 349   }
 350
 351   gBS->FreePool (OptionPtr);
 352
 353   //
 354   // Update the option order variable
 355   //
 356   OptionOrderPtr = AllocateZeroPool ((Index + 1) * sizeof (UINT16));
 357   CopyMem (OptionOrderPtr, TempOptionPtr, Index * sizeof (UINT16));
 358   OptionOrderPtr[Index] = RegisterOptionNumber;
 359   Status = gRT->SetVariable (
 360                   VariableName,
 361                   &gEfiGlobalVariableGuid,
 362                   EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
 363                   (Index + 1) * sizeof (UINT16),
 364                   OptionOrderPtr
 365                   );
 366   if (EFI_ERROR (Status)) {
 367     gBS->FreePool (TempOptionPtr);
 368     gBS->FreePool (OptionOrderPtr);
 369     return Status;
 370   }
 371
 372   gBS->FreePool (TempOptionPtr);
 373   gBS->FreePool (OptionOrderPtr);
 374
 375   return EFI_SUCCESS;
 376 }
 377
 378 BDS_COMMON_OPTION *
 379 BdsLibVariableToOption (
 380   IN OUT LIST_ENTRY               *BdsCommonOptionList,
 381   IN  CHAR16                      *VariableName
 382   )
 383 /*++
 384
 385 Routine Description:
 386
 387   Build the boot#### or driver#### option from the VariableName, the
 388   build boot#### or driver#### will also be linked to BdsCommonOptionList
 389
 390 Arguments:
 391
 392   BdsCommonOptionList - The header of the boot#### or driver#### option link list
 393
 394   VariableName - EFI Variable name indicate if it is boot#### or driver####
 395
 396 Returns:
 397
 398   BDS_COMMON_OPTION    - Get the option just been created
 399
 400   NULL                 - Failed to get the new option
 401
 402 --*/
 403 {
 404   UINT32                    Attribute;
 405   UINT16                    FilePathSize;
 406   UINT8                     *Variable;
 407   UINT8                     *TempPtr;
 408   UINTN                     VariableSize;
 409   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 410   BDS_COMMON_OPTION         *Option;
 411   VOID                      *LoadOptions;
 412   UINT32                    LoadOptionsSize;
 413   CHAR16                    *Description;
 414
 415   //
 416   // Read the variable. We will never free this data.
 417   //
 418   Variable = BdsLibGetVariableAndSize (
 419               VariableName,
 420               &gEfiGlobalVariableGuid,
 421               &VariableSize
 422               );
 423   if (Variable == NULL) {
 424     return NULL;
 425   }
 426   //
 427   // Notes: careful defined the variable of Boot#### or
 428   // Driver####, consider use some macro to abstract the code
 429   //
 430   //
 431   // Get the option attribute
 432   //
 433   TempPtr   = Variable;
 434   Attribute = *(UINT32 *) Variable;
 435   TempPtr += sizeof (UINT32);
 436
 437   //
 438   // Get the option's device path size
 439   //
 440   FilePathSize = *(UINT16 *) TempPtr;
 441   TempPtr += sizeof (UINT16);
 442
 443   //
 444   // Get the option's description string
 445   //
 446   Description = (CHAR16 *) TempPtr;
 447
 448   //
 449   // Get the option's description string size
 450   //
 451   TempPtr += StrSize ((CHAR16 *) TempPtr);
 452
 453   //
 454   // Get the option's device path
 455   //
 456   DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
 457   TempPtr += FilePathSize;
 458
 459   LoadOptions     = TempPtr;
 460   LoadOptionsSize = (UINT32) (VariableSize - (UINTN) (TempPtr - Variable));
 461
 462   //
 463   // The Console variables may have multiple device paths, so make
 464   // an Entry for each one.
 465   //
 466   Option = AllocateZeroPool (sizeof (BDS_COMMON_OPTION));
 467   if (Option == NULL) {
 468     return NULL;
 469   }
 470
 471   Option->Signature   = BDS_LOAD_OPTION_SIGNATURE;
 472   Option->DevicePath  = AllocateZeroPool (GetDevicePathSize (DevicePath));
 473   CopyMem (Option->DevicePath, DevicePath, GetDevicePathSize (DevicePath));
 474   Option->Attribute   = Attribute;
 475   Option->Description = AllocateZeroPool (StrSize (Description));
 476   CopyMem (Option->Description, Description, StrSize (Description));
 477   Option->LoadOptions = AllocateZeroPool (LoadOptionsSize);
 478   CopyMem (Option->LoadOptions, LoadOptions, LoadOptionsSize);
 479   Option->LoadOptionsSize = LoadOptionsSize;
 480
 481   //
 482   // Insert active entry to BdsDeviceList
 483   //
 484   if ((Option->Attribute & LOAD_OPTION_ACTIVE) == LOAD_OPTION_ACTIVE) {
 485     InsertTailList (BdsCommonOptionList, &Option->Link);
 486     gBS->FreePool (Variable);
 487     return Option;
 488   }
 489
 490   gBS->FreePool (Variable);
 491   gBS->FreePool (Option);
 492   return NULL;
 493
 494 }
 495
 496 EFI_STATUS
 497 BdsLibBuildOptionFromVar (
 498   IN  LIST_ENTRY                  *BdsCommonOptionList,
 499   IN  CHAR16                      *VariableName
 500   )
 501 /*++
 502
 503 Routine Description:
 504
 505   Process BootOrder, or DriverOrder variables, by calling
 506   BdsLibVariableToOption () for each UINT16 in the variables.
 507
 508 Arguments:
 509
 510   BdsCommonOptionList - The header of the option list base on variable
 511                         VariableName
 512
 513   VariableName - EFI Variable name indicate the BootOrder or DriverOrder
 514
 515 Returns:
 516
 517   EFI_SUCCESS - Success create the boot option or driver option list
 518
 519   EFI_OUT_OF_RESOURCES - Failed to get the boot option or driver option list
 520
 521 --*/
 522 {
 523   UINT16            *OptionOrder;
 524   UINTN             OptionOrderSize;
 525   UINTN             Index;
 526   BDS_COMMON_OPTION *Option;
 527   CHAR16            OptionName[20];
 528
 529   //
 530   // Zero Buffer in order to get all BOOT#### variables
 531   //
 532   ZeroMem (OptionName, sizeof (OptionName));
 533
 534   //
 535   // Read the BootOrder, or DriverOrder variable.
 536   //
 537   OptionOrder = BdsLibGetVariableAndSize (
 538                   VariableName,
 539                   &gEfiGlobalVariableGuid,
 540                   &OptionOrderSize
 541                   );
 542   if (OptionOrder == NULL) {
 543     return EFI_OUT_OF_RESOURCES;
 544   }
 545
 546   for (Index = 0; Index < OptionOrderSize / sizeof (UINT16); Index++) {
 547     if (*VariableName == 'B') {
 548       UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", OptionOrder[Index]);
 549     } else {
 550       UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", OptionOrder[Index]);
 551     }
 552     Option              = BdsLibVariableToOption (BdsCommonOptionList, OptionName);
 553     Option->BootCurrent = OptionOrder[Index];
 554
 555   }
 556
 557   gBS->FreePool (OptionOrder);
 558
 559   return EFI_SUCCESS;
 560 }
 561
 562 VOID *
 563 BdsLibGetVariableAndSize (
 564   IN  CHAR16              *Name,
 565   IN  EFI_GUID            *VendorGuid,
 566   OUT UINTN               *VariableSize
 567   )
 568 /*++
 569
 570 Routine Description:
 571
 572   Read the EFI variable (VendorGuid/Name) and return a dynamically allocated
 573   buffer, and the size of the buffer. If failure return NULL.
 574
 575 Arguments:
 576
 577   Name       - String part of EFI variable name
 578
 579   VendorGuid - GUID part of EFI variable name
 580
 581   VariableSize - Returns the size of the EFI variable that was read
 582
 583 Returns:
 584
 585   Dynamically allocated memory that contains a copy of the EFI variable.
 586   Caller is responsible freeing the buffer.
 587
 588   NULL - Variable was not read
 589
 590 --*/
 591 {
 592   EFI_STATUS  Status;
 593   UINTN       BufferSize;
 594   VOID        *Buffer;
 595
 596   Buffer = NULL;
 597
 598   //
 599   // Pass in a zero size buffer to find the required buffer size.
 600   //
 601   BufferSize  = 0;
 602   Status      = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
 603   if (Status == EFI_BUFFER_TOO_SMALL) {
 604     //
 605     // Allocate the buffer to return
 606     //
 607     Buffer = AllocateZeroPool (BufferSize);
 608     if (Buffer == NULL) {
 609       return NULL;
 610     }
 611     //
 612     // Read variable into the allocated buffer.
 613     //
 614     Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
 615     if (EFI_ERROR (Status)) {
 616       BufferSize = 0;
 617     }
 618   }
 619
 620   *VariableSize = BufferSize;
 621   return Buffer;
 622 }
 623
 624 VOID
 625 BdsLibSafeFreePool (
 626   IN  VOID             *Buffer
 627   )
 628 /*++
 629
 630 Routine Description:
 631
 632   Free pool safely.
 633
 634 Arguments:
 635
 636   Buffer          - The allocated pool entry to free
 637
 638 Returns:
 639
 640   Pointer of the buffer allocated.
 641
 642 --*/
 643 {
 644   if (Buffer != NULL) {
 645     gBS->FreePool (Buffer);
 646     Buffer = NULL;
 647   }
 648 }
 649
 650 EFI_DEVICE_PATH_PROTOCOL *
 651 BdsLibDelPartMatchInstance (
 652   IN     EFI_DEVICE_PATH_PROTOCOL  *Multi,
 653   IN     EFI_DEVICE_PATH_PROTOCOL  *Single
 654   )
 655 /*++
 656
 657 Routine Description:
 658
 659   Delete the instance in Multi which matches partly with Single instance
 660
 661 Arguments:
 662
 663   Multi        - A pointer to a multi-instance device path data structure.
 664
 665   Single       - A pointer to a single-instance device path data structure.
 666
 667 Returns:
 668
 669   This function will remove the device path instances in Multi which partly
 670   match with the Single, and return the result device path. If there is no
 671   remaining device path as a result, this function will return NULL.
 672
 673 --*/
 674 {
 675   EFI_DEVICE_PATH_PROTOCOL  *Instance;
 676   EFI_DEVICE_PATH_PROTOCOL  *NewDevicePath;
 677   EFI_DEVICE_PATH_PROTOCOL  *TempNewDevicePath;
 678   UINTN                     InstanceSize;
 679   UINTN                     SingleDpSize;
 680   UINTN                     Size;
 681
 682   NewDevicePath     = NULL;
 683   TempNewDevicePath = NULL;
 684
 685   if (Multi == NULL || Single == NULL) {
 686     return Multi;
 687   }
 688
 689   Instance        =  GetNextDevicePathInstance (&Multi, &InstanceSize);
 690   SingleDpSize    =  GetDevicePathSize (Single) - END_DEVICE_PATH_LENGTH;
 691   InstanceSize    -= END_DEVICE_PATH_LENGTH;
 692
 693   while (Instance != NULL) {
 694
 695     Size = (SingleDpSize < InstanceSize) ? SingleDpSize : InstanceSize;
 696
 697     if ((CompareMem (Instance, Single, Size) != 0)) {
 698       //
 699       // Append the device path instance which does not match with Single
 700       //
 701       TempNewDevicePath = NewDevicePath;
 702       NewDevicePath = AppendDevicePathInstance (NewDevicePath, Instance);
 703       BdsLibSafeFreePool(TempNewDevicePath);
 704     }
 705     BdsLibSafeFreePool(Instance);
 706     Instance = GetNextDevicePathInstance (&Multi, &InstanceSize);
 707     InstanceSize  -= END_DEVICE_PATH_LENGTH;
 708   }
 709
 710   return NewDevicePath;
 711 }
 712
 713 BOOLEAN
 714 BdsLibMatchDevicePaths (
 715   IN  EFI_DEVICE_PATH_PROTOCOL  *Multi,
 716   IN  EFI_DEVICE_PATH_PROTOCOL  *Single
 717   )
 718 /*++
 719
 720 Routine Description:
 721
 722   Function compares a device path data structure to that of all the nodes of a
 723   second device path instance.
 724
 725 Arguments:
 726
 727   Multi        - A pointer to a multi-instance device path data structure.
 728
 729   Single       - A pointer to a single-instance device path data structure.
 730
 731 Returns:
 732
 733   TRUE   - If the Single is contained within Multi
 734
 735   FALSE  - The Single is not match within Multi
 736
 737
 738 --*/
 739 {
 740   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 741   EFI_DEVICE_PATH_PROTOCOL  *DevicePathInst;
 742   UINTN                     Size;
 743
 744   if (!Multi || !Single) {
 745     return FALSE;
 746   }
 747
 748   DevicePath      = Multi;
 749   DevicePathInst  = GetNextDevicePathInstance (&DevicePath, &Size);
 750
 751   //
 752   // Search for the match of 'Single' in 'Multi'
 753   //
 754   while (DevicePathInst != NULL) {
 755     //
 756     // If the single device path is found in multiple device paths,
 757     // return success
 758     //
 759     if (CompareMem (Single, DevicePathInst, Size) == 0) {
 760       gBS->FreePool (DevicePathInst);
 761       return TRUE;
 762     }
 763
 764     gBS->FreePool (DevicePathInst);
 765     DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
 766   }
 767
 768   return FALSE;
 769 }
 770
 771 EFI_STATUS
 772 BdsLibOutputStrings (
 773   IN EFI_SIMPLE_TEXT_OUT_PROTOCOL   *ConOut,
 774   ...
 775   )
 776 /*++
 777
 778 Routine Description:
 779
 780   This function prints a series of strings.
 781
 782 Arguments:
 783
 784   ConOut               - Pointer to EFI_SIMPLE_TEXT_OUT_PROTOCOL
 785
 786   ...                  - A variable argument list containing series of strings,
 787                          the last string must be NULL.
 788
 789 Returns:
 790
 791   EFI_SUCCESS          - Success print out the string using ConOut.
 792
 793   EFI_STATUS           - Return the status of the ConOut->OutputString ().
 794
 795 --*/
 796 {
 797   VA_LIST     args;
 798   EFI_STATUS  Status;
 799   CHAR16      *String;
 800
 801   Status = EFI_SUCCESS;
 802   VA_START (args, ConOut);
 803
 804   while (!EFI_ERROR (Status)) {
 805     //
 806     // If String is NULL, then it's the end of the list
 807     //
 808     String = VA_ARG (args, CHAR16 *);
 809     if (!String) {
 810       break;
 811     }
 812
 813     Status = ConOut->OutputString (ConOut, String);
 814
 815     if (EFI_ERROR (Status)) {
 816       break;
 817     }
 818   }
 819
 820   return Status;
 821 }
 822
 823 //
 824 //  Following are BDS Lib functions which  contain all the code about setup browser reset reminder feature.
 825 //  Setup Browser reset reminder feature is that an reset reminder will be given before user leaves the setup browser  if
 826 //  user change any option setting which needs a reset to be effective, and  the reset will be applied according to  the user selection.
 827 //
 828
 829 VOID
 830 EnableResetReminderFeature (
 831   VOID
 832   )
 833 /*++
 834
 835 Routine Description:
 836
 837   Enable the setup browser reset reminder feature.
 838   This routine is used in platform tip. If the platform policy need the feature, use the routine to enable it.
 839
 840 Arguments:
 841
 842   VOID
 843
 844 Returns:
 845
 846   VOID
 847
 848 --*/
 849 {
 850   mFeaturerSwitch = TRUE;
 851 }
 852
 853 VOID
 854 DisableResetReminderFeature (
 855   VOID
 856   )
 857 /*++
 858
 859 Routine Description:
 860
 861   Disable the setup browser reset reminder feature.
 862   This routine is used in platform tip. If the platform policy do not want the feature, use the routine to disable it.
 863
 864 Arguments:
 865
 866   VOID
 867
 868 Returns:
 869
 870   VOID
 871
 872 --*/
 873 {
 874   mFeaturerSwitch = FALSE;
 875 }
 876
 877 VOID
 878 EnableResetRequired (
 879   VOID
 880   )
 881 /*++
 882
 883 Routine Description:
 884
 885    Record the info that  a reset is required.
 886    A  module boolean variable is used to record whether a reset is required.
 887
 888 Arguments:
 889
 890   VOID
 891
 892 Returns:
 893
 894   VOID
 895
 896 --*/
 897 {
 898   mResetRequired = TRUE;
 899 }
 900
 901 VOID
 902 DisableResetRequired (
 903   VOID
 904   )
 905 /*++
 906
 907 Routine Description:
 908
 909    Record the info that  no reset is required.
 910    A  module boolean variable is used to record whether a reset is required.
 911
 912 Arguments:
 913
 914   VOID
 915
 916 Returns:
 917
 918   VOID
 919
 920 --*/
 921 {
 922   mResetRequired = FALSE;
 923 }
 924
 925 BOOLEAN
 926 IsResetReminderFeatureEnable (
 927   VOID
 928   )
 929 /*++
 930
 931 Routine Description:
 932
 933   Check whether platform policy enable the reset reminder feature. The default is enabled.
 934
 935 Arguments:
 936
 937   VOID
 938
 939 Returns:
 940
 941   VOID
 942
 943 --*/
 944 {
 945   return mFeaturerSwitch;
 946 }
 947
 948 BOOLEAN
 949 IsResetRequired (
 950   VOID
 951   )
 952 /*++
 953
 954 Routine Description:
 955
 956   Check if  user changed any option setting which needs a system reset to be effective.
 957
 958 Arguments:
 959
 960   VOID
 961
 962 Returns:
 963
 964   VOID
 965
 966 --*/
 967 {
 968   return mResetRequired;
 969 }
 970
 971 VOID
 972 SetupResetReminder (
 973   VOID
 974   )
 975 /*++
 976
 977 Routine Description:
 978
 979   Check whether a reset is needed, and finish the reset reminder feature.
 980   If a reset is needed, Popup a menu to notice user, and finish the feature
 981   according to the user selection.
 982
 983 Arguments:
 984
 985   VOID
 986
 987 Returns:
 988
 989   VOID
 990
 991 --*/
 992 {
 993   EFI_STATUS                    Status;
 994   EFI_FORM_BROWSER_PROTOCOL     *Browser;
 995   EFI_INPUT_KEY                 Key;
 996   CHAR16                        *StringBuffer1;
 997   CHAR16                        *StringBuffer2;
 998
 999
1000   //
1001   //check any reset required change is applied? if yes, reset system
1002   //
1003   if (IsResetReminderFeatureEnable ()) {
1004     if (IsResetRequired ()) {
1005
1006       Status = gBS->LocateProtocol (
1007                       &gEfiFormBrowserProtocolGuid,
1008                       NULL,
1009                       (VOID **)&Browser
1010                       );
1011
1012       StringBuffer1 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
1013       ASSERT (StringBuffer1 != NULL);
1014       StringBuffer2 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
1015       ASSERT (StringBuffer2 != NULL);
1016       StrCpy (StringBuffer1, L"Configuration changed. Reset to apply it Now ? ");
1017       StrCpy (StringBuffer2, L"Enter (YES)  /   Esc (NO)");
1018       //
1019       // Popup a menu to notice user
1020       //
1021       do {
1022         Browser->CreatePopUp (2, TRUE, 0, NULL, &Key, StringBuffer1, StringBuffer2);
1023       } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
1024
1025       gBS->FreePool (StringBuffer1);
1026       gBS->FreePool (StringBuffer2);
1027       //
1028       // If the user hits the YES Response key, reset
1029       //
1030       if ((Key.UnicodeChar == CHAR_CARRIAGE_RETURN)) {
1031         gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
1032       }
1033       gST->ConOut->ClearScreen (gST->ConOut);
1034     }
1035   }
1036 }
1037
1038 EFI_STATUS
1039 BdsLibGetHiiHandles (
1040   IN     EFI_HII_PROTOCOL *Hii,
1041   IN OUT UINT16           *HandleBufferLength,
1042   OUT    EFI_HII_HANDLE   **HiiHandleBuffer
1043   )
1044 /*++
1045
1046 Routine Description:
1047
1048   Determines the handles that are currently active in the database.
1049   It's the caller's responsibility to free handle buffer.
1050
1051 Arguments:
1052
1053   This                  - A pointer to the EFI_HII_PROTOCOL instance.
1054   HandleBufferLength    - On input, a pointer to the length of the handle buffer. On output,
1055                           the length of the handle buffer that is required for the handles found.
1056   HiiHandleBuffer       - Pointer to an array of EFI_HII_PROTOCOL instances returned.
1057
1058 Returns:
1059
1060   EFI_SUCCESS           - Get an array of EFI_HII_PROTOCOL instances successfully.
1061   EFI_INVALID_PARAMETER - Hii is NULL.
1062   EFI_NOT_FOUND         - Database not found.
1063
1064 --*/
1065 {
1066   UINT16      TempBufferLength;
1067   EFI_STATUS  Status;
1068
1069   TempBufferLength = 0;
1070
1071   //
1072   // Try to find the actual buffer size for HiiHandle Buffer.
1073   //
1074   Status = Hii->FindHandles (Hii, &TempBufferLength, *HiiHandleBuffer);
1075
1076   if (Status == EFI_BUFFER_TOO_SMALL) {
1077     *HiiHandleBuffer = AllocateZeroPool (TempBufferLength);
1078     Status = Hii->FindHandles (Hii, &TempBufferLength, *HiiHandleBuffer);
1079     //
1080     // we should not fail here.
1081     //
1082     ASSERT_EFI_ERROR (Status);
1083   }
1084
1085   *HandleBufferLength = TempBufferLength;
1086
1087   return Status;
1088
1089 }