ShellPkg/Library/UefiShellDriver1CommandsLib/DrvCfg.c

   1 /** @file
   2   Main file for DrvCfg shell Driver1 function.
   3
   4   (C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR>
   5   Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
   6   SPDX-License-Identifier: BSD-2-Clause-Patent
   7
   8 **/
   9
  10 #include "UefiShellDriver1CommandsLib.h"
  11 #include <Protocol/HiiConfigAccess.h>
  12 #include <Protocol/HiiDatabase.h>
  13
  14 STATIC CONST EFI_GUID  *CfgGuidList[] = { &gEfiDriverConfigurationProtocolGuid, &gEfiDriverConfiguration2ProtocolGuid, NULL };
  15
  16 /**
  17   Find the EFI_HII_HANDLE by device path.
  18
  19   @param[in] DevPath1     The Device Path to match.
  20   @param[out] HiiHandle   The EFI_HII_HANDLE after the converstion.
  21   @param[in] HiiDb        The Hii database protocol
  22
  23   @retval EFI_SUCCESS     The operation was successful.
  24   @retval EFI_NOT_FOUND   There was no EFI_HII_HANDLE found for that deviec path.
  25 **/
  26 EFI_STATUS
  27 FindHiiHandleViaDevPath (
  28   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevPath1,
  29   OUT EFI_HII_HANDLE                 *HiiHandle,
  30   IN EFI_HII_DATABASE_PROTOCOL       *HiiDb
  31   )
  32 {
  33   EFI_HII_HANDLE               *HandleBuffer;
  34   UINTN                        HandleBufferSize;
  35   VOID                         *MainBuffer;
  36   UINTN                        MainBufferSize;
  37   EFI_HII_PACKAGE_LIST_HEADER  *PackageListHeader;
  38   EFI_HII_PACKAGE_HEADER       *PackageHeader;
  39   UINTN                        LoopVariable;
  40   EFI_DEVICE_PATH_PROTOCOL     *DevPath2;
  41   EFI_STATUS                   Status;
  42
  43   ASSERT (DevPath1 != NULL);
  44   ASSERT (HiiHandle != NULL);
  45   ASSERT (*HiiHandle == NULL);
  46   ASSERT (HiiDb != NULL);
  47
  48   HandleBufferSize = 0;
  49   HandleBuffer     = NULL;
  50   Status           = HiiDb->ListPackageLists (HiiDb, EFI_HII_PACKAGE_DEVICE_PATH, NULL, &HandleBufferSize, HandleBuffer);
  51   if (Status == EFI_BUFFER_TOO_SMALL) {
  52     HandleBuffer = AllocateZeroPool (HandleBufferSize);
  53     if (HandleBuffer == NULL) {
  54       Status = EFI_OUT_OF_RESOURCES;
  55     } else {
  56       Status = HiiDb->ListPackageLists (HiiDb, EFI_HII_PACKAGE_DEVICE_PATH, NULL, &HandleBufferSize, HandleBuffer);
  57     }
  58   }
  59
  60   if (EFI_ERROR (Status)) {
  61     SHELL_FREE_NON_NULL (HandleBuffer);
  62     return (Status);
  63   }
  64
  65   if (HandleBuffer == NULL) {
  66     return EFI_NOT_FOUND;
  67   }
  68
  69   for (LoopVariable = 0; LoopVariable < (HandleBufferSize/sizeof (HandleBuffer[0])) && *HiiHandle == NULL; LoopVariable++) {
  70     MainBufferSize = 0;
  71     MainBuffer     = NULL;
  72     Status         = HiiDb->ExportPackageLists (HiiDb, HandleBuffer[LoopVariable], &MainBufferSize, MainBuffer);
  73     if (Status == EFI_BUFFER_TOO_SMALL) {
  74       MainBuffer = AllocateZeroPool (MainBufferSize);
  75       if (MainBuffer != NULL) {
  76         Status = HiiDb->ExportPackageLists (HiiDb, HandleBuffer[LoopVariable], &MainBufferSize, MainBuffer);
  77       }
  78     }
  79
  80     if (EFI_ERROR (Status)) {
  81       continue;
  82     }
  83
  84     //
  85     // Enumerate through the block of returned memory.
  86     // This should actually be a small block, but we need to be sure.
  87     //
  88     for (PackageListHeader = (EFI_HII_PACKAGE_LIST_HEADER *)MainBuffer
  89          ; PackageListHeader != NULL && ((CHAR8 *)PackageListHeader) < (((CHAR8 *)MainBuffer)+MainBufferSize) && *HiiHandle == NULL
  90          ; PackageListHeader = (EFI_HII_PACKAGE_LIST_HEADER *)(((CHAR8 *)(PackageListHeader)) + PackageListHeader->PackageLength))
  91     {
  92       for (PackageHeader = (EFI_HII_PACKAGE_HEADER *)(((CHAR8 *)(PackageListHeader))+sizeof (EFI_HII_PACKAGE_LIST_HEADER))
  93            ; PackageHeader != NULL && ((CHAR8 *)PackageHeader) < (((CHAR8 *)MainBuffer)+MainBufferSize) && PackageHeader->Type != EFI_HII_PACKAGE_END && *HiiHandle == NULL
  94            ; PackageHeader = (EFI_HII_PACKAGE_HEADER *)(((CHAR8 *)(PackageHeader))+PackageHeader->Length))
  95       {
  96         if (PackageHeader->Type == EFI_HII_PACKAGE_DEVICE_PATH) {
  97           DevPath2 = (EFI_DEVICE_PATH_PROTOCOL *)(((CHAR8 *)PackageHeader) + sizeof (EFI_HII_PACKAGE_HEADER));
  98           if (DevicePathCompare (&DevPath1, &DevPath2) == 0) {
  99             *HiiHandle = HandleBuffer[LoopVariable];
 100             break;
 101           }
 102         }
 103       }
 104     }
 105
 106     SHELL_FREE_NON_NULL (MainBuffer);
 107   }
 108
 109   SHELL_FREE_NON_NULL (HandleBuffer);
 110
 111   if (*HiiHandle == NULL) {
 112     return (EFI_NOT_FOUND);
 113   }
 114
 115   return (EFI_SUCCESS);
 116 }
 117
 118 /**
 119   Convert a EFI_HANDLE to a EFI_HII_HANDLE.
 120
 121   @param[in] Handle       The EFI_HANDLE to convert.
 122   @param[out] HiiHandle   The EFI_HII_HANDLE after the converstion.
 123   @param[in] HiiDb        The Hii database protocol
 124
 125   @retval EFI_SUCCESS   The operation was successful.
 126 **/
 127 EFI_STATUS
 128 ConvertHandleToHiiHandle (
 129   IN CONST EFI_HANDLE           Handle,
 130   OUT EFI_HII_HANDLE            *HiiHandle,
 131   IN EFI_HII_DATABASE_PROTOCOL  *HiiDb
 132   )
 133 {
 134   EFI_STATUS                Status;
 135   EFI_DEVICE_PATH_PROTOCOL  *DevPath1;
 136
 137   if ((HiiHandle == NULL) || (HiiDb == NULL)) {
 138     return (EFI_INVALID_PARAMETER);
 139   }
 140
 141   *HiiHandle = NULL;
 142
 143   if (Handle == NULL) {
 144     return (EFI_SUCCESS);
 145   }
 146
 147   DevPath1 = NULL;
 148   Status   = gBS->OpenProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevPath1, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
 149   if (EFI_ERROR (Status) || (DevPath1 == NULL)) {
 150     return (EFI_NOT_FOUND);
 151   }
 152
 153   return (FindHiiHandleViaDevPath (DevPath1, HiiHandle, HiiDb));
 154 }
 155
 156 /**
 157   Function to print out all HII configuration information to a file.
 158
 159   @param[in] Handle           The handle to get info on.  NULL to do all handles.
 160   @param[in] FileName         The filename to rwite the info to.
 161 **/
 162 SHELL_STATUS
 163 ConfigToFile (
 164   IN CONST EFI_HANDLE  Handle,
 165   IN CONST CHAR16      *FileName
 166   )
 167 {
 168   EFI_HII_DATABASE_PROTOCOL  *HiiDatabase;
 169   EFI_STATUS                 Status;
 170   VOID                       *MainBuffer;
 171   UINTN                      MainBufferSize;
 172   EFI_HII_HANDLE             HiiHandle;
 173   SHELL_FILE_HANDLE          FileHandle;
 174
 175   HiiDatabase    = NULL;
 176   MainBufferSize = 0;
 177   MainBuffer     = NULL;
 178   FileHandle     = NULL;
 179
 180   Status = ShellOpenFileByName (FileName, &FileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0);
 181   if (EFI_ERROR (Status)) {
 182     ShellPrintHiiEx (
 183       -1,
 184       -1,
 185       NULL,
 186       STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL),
 187       gShellDriver1HiiHandle,
 188       L"drvcfg",
 189       FileName,
 190       Status
 191       );
 192     return (SHELL_DEVICE_ERROR);
 193   }
 194
 195   //
 196   // Locate HII Database protocol
 197   //
 198   Status = gBS->LocateProtocol (
 199                   &gEfiHiiDatabaseProtocolGuid,
 200                   NULL,
 201                   (VOID **)&HiiDatabase
 202                   );
 203
 204   if (EFI_ERROR (Status) || (HiiDatabase == NULL)) {
 205     ShellPrintHiiEx (
 206       -1,
 207       -1,
 208       NULL,
 209       STRING_TOKEN (STR_GEN_PROTOCOL_NF),
 210       gShellDriver1HiiHandle,
 211       L"drvcfg",
 212       L"EfiHiiDatabaseProtocol",
 213       &gEfiHiiDatabaseProtocolGuid
 214       );
 215     ShellCloseFile (&FileHandle);
 216     return (SHELL_NOT_FOUND);
 217   }
 218
 219   HiiHandle = NULL;
 220   Status    = ConvertHandleToHiiHandle (Handle, &HiiHandle, HiiDatabase);
 221   if (EFI_ERROR (Status)) {
 222     ShellPrintHiiEx (
 223       -1,
 224       -1,
 225       NULL,
 226       STRING_TOKEN (STR_GEN_HANDLE_NOT),
 227       gShellDriver1HiiHandle,
 228       L"drvcfg",
 229       ConvertHandleToHandleIndex (Handle),
 230       L"Device"
 231       );
 232     ShellCloseFile (&FileHandle);
 233     return (SHELL_DEVICE_ERROR);
 234   }
 235
 236   Status = HiiDatabase->ExportPackageLists (HiiDatabase, HiiHandle, &MainBufferSize, MainBuffer);
 237   if (Status == EFI_BUFFER_TOO_SMALL) {
 238     MainBuffer = AllocateZeroPool (MainBufferSize);
 239     Status     = HiiDatabase->ExportPackageLists (HiiDatabase, HiiHandle, &MainBufferSize, MainBuffer);
 240   }
 241
 242   Status = ShellWriteFile (FileHandle, &MainBufferSize, MainBuffer);
 243
 244   ShellCloseFile (&FileHandle);
 245   SHELL_FREE_NON_NULL (MainBuffer);
 246
 247   if (EFI_ERROR (Status)) {
 248     ShellPrintHiiEx (
 249       -1,
 250       -1,
 251       NULL,
 252       STRING_TOKEN (STR_FILE_WRITE_FAIL),
 253       gShellDriver1HiiHandle,
 254       L"drvcfg",
 255       FileName
 256       );
 257     return (SHELL_DEVICE_ERROR);
 258   }
 259
 260   ShellPrintHiiEx (
 261     -1,
 262     -1,
 263     NULL,
 264     STRING_TOKEN (STR_DRVCFG_COMP),
 265     gShellDriver1HiiHandle
 266     );
 267
 268   return (SHELL_SUCCESS);
 269 }
 270
 271 /**
 272   Function to read in HII configuration information from a file.
 273
 274   @param[in] Handle           The handle to get info for.
 275   @param[in] FileName         The filename to read the info from.
 276 **/
 277 SHELL_STATUS
 278 ConfigFromFile (
 279   IN       EFI_HANDLE  Handle,
 280   IN CONST CHAR16      *FileName
 281   )
 282 {
 283   EFI_HII_DATABASE_PROTOCOL    *HiiDatabase;
 284   EFI_STATUS                   Status;
 285   VOID                         *MainBuffer;
 286   UINT64                       Temp;
 287   UINTN                        MainBufferSize;
 288   EFI_HII_HANDLE               HiiHandle;
 289   SHELL_FILE_HANDLE            FileHandle;
 290   CHAR16                       *TempDevPathString;
 291   EFI_HII_PACKAGE_LIST_HEADER  *PackageListHeader;
 292   EFI_HII_PACKAGE_HEADER       *PackageHeader;
 293   EFI_DEVICE_PATH_PROTOCOL     *DevPath;
 294   UINTN                        HandleIndex;
 295
 296   HiiDatabase    = NULL;
 297   MainBufferSize = 0;
 298   MainBuffer     = NULL;
 299   FileHandle     = NULL;
 300
 301   Status = ShellOpenFileByName (FileName, &FileHandle, EFI_FILE_MODE_READ, 0);
 302   if (EFI_ERROR (Status)) {
 303     ShellPrintHiiEx (
 304       -1,
 305       -1,
 306       NULL,
 307       STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL),
 308       gShellDriver1HiiHandle,
 309       L"drvcfg",
 310       FileName,
 311       Status
 312       );
 313     return (SHELL_DEVICE_ERROR);
 314   }
 315
 316   //
 317   // Locate HII Database protocol
 318   //
 319   Status = gBS->LocateProtocol (
 320                   &gEfiHiiDatabaseProtocolGuid,
 321                   NULL,
 322                   (VOID **)&HiiDatabase
 323                   );
 324
 325   if (EFI_ERROR (Status) || (HiiDatabase == NULL)) {
 326     ShellPrintHiiEx (
 327       -1,
 328       -1,
 329       NULL,
 330       STRING_TOKEN (STR_GEN_PROTOCOL_NF),
 331       gShellDriver1HiiHandle,
 332       L"drvcfg",
 333       L"EfiHiiDatabaseProtocol",
 334       &gEfiHiiDatabaseProtocolGuid
 335       );
 336     ShellCloseFile (&FileHandle);
 337     return (SHELL_NOT_FOUND);
 338   }
 339
 340   Status         = ShellGetFileSize (FileHandle, &Temp);
 341   MainBufferSize = (UINTN)Temp;
 342   if (EFI_ERROR (Status)) {
 343     ShellPrintHiiEx (
 344       -1,
 345       -1,
 346       NULL,
 347       STRING_TOKEN (STR_FILE_READ_FAIL),
 348       gShellDriver1HiiHandle,
 349       L"drvcfg",
 350       FileName
 351       );
 352
 353     ShellCloseFile (&FileHandle);
 354     return (SHELL_DEVICE_ERROR);
 355   }
 356
 357   MainBuffer = AllocateZeroPool ((UINTN)MainBufferSize);
 358   if (EFI_ERROR (Status)) {
 359     ShellPrintHiiEx (
 360       -1,
 361       -1,
 362       NULL,
 363       STRING_TOKEN (STR_GEN_OUT_MEM),
 364       gShellDriver1HiiHandle,
 365       L"drvcfg"
 366       );
 367     ShellCloseFile (&FileHandle);
 368     return (SHELL_DEVICE_ERROR);
 369   }
 370
 371   Status = ShellReadFile (FileHandle, &MainBufferSize, MainBuffer);
 372   if (EFI_ERROR (Status)) {
 373     ShellPrintHiiEx (
 374       -1,
 375       -1,
 376       NULL,
 377       STRING_TOKEN (STR_FILE_READ_FAIL),
 378       gShellDriver1HiiHandle,
 379       L"drvcfg",
 380       FileName
 381       );
 382
 383     ShellCloseFile (&FileHandle);
 384     SHELL_FREE_NON_NULL (MainBuffer);
 385     return (SHELL_DEVICE_ERROR);
 386   }
 387
 388   ShellCloseFile (&FileHandle);
 389
 390   if (Handle != NULL) {
 391     //
 392     // User override in place.  Just do it.
 393     //
 394     HiiHandle = NULL;
 395     Status    = ConvertHandleToHiiHandle (Handle, &HiiHandle, HiiDatabase);
 396     if (EFI_ERROR (Status)) {
 397       ShellPrintHiiEx (
 398         -1,
 399         -1,
 400         NULL,
 401         STRING_TOKEN (STR_GEN_HANDLE_NOT),
 402         gShellDriver1HiiHandle,
 403         L"drvcfg",
 404         ConvertHandleToHandleIndex (Handle),
 405         L"Device"
 406         );
 407       ShellCloseFile (&FileHandle);
 408       return (SHELL_DEVICE_ERROR);
 409     }
 410
 411     Status = HiiDatabase->UpdatePackageList (HiiDatabase, HiiHandle, MainBuffer);
 412     if (EFI_ERROR (Status)) {
 413       ShellPrintHiiEx (
 414         -1,
 415         -1,
 416         NULL,
 417         STRING_TOKEN (STR_GEN_UEFI_FUNC_WARN),
 418         gShellDriver1HiiHandle,
 419         L"drvcfg",
 420         L"HiiDatabase->UpdatePackageList",
 421         Status
 422         );
 423       return (SHELL_DEVICE_ERROR);
 424     }
 425   } else {
 426     //
 427     // we need to parse the buffer and try to match the device paths for each item to try to find it's device path.
 428     //
 429
 430     for (PackageListHeader = (EFI_HII_PACKAGE_LIST_HEADER *)MainBuffer
 431          ; PackageListHeader != NULL && ((CHAR8 *)PackageListHeader) < (((CHAR8 *)MainBuffer)+MainBufferSize)
 432          ; PackageListHeader = (EFI_HII_PACKAGE_LIST_HEADER *)(((CHAR8 *)(PackageListHeader)) + PackageListHeader->PackageLength))
 433     {
 434       for (PackageHeader = (EFI_HII_PACKAGE_HEADER *)(((CHAR8 *)(PackageListHeader))+sizeof (EFI_HII_PACKAGE_LIST_HEADER))
 435            ; PackageHeader != NULL && ((CHAR8 *)PackageHeader) < (((CHAR8 *)MainBuffer)+MainBufferSize) && PackageHeader->Type != EFI_HII_PACKAGE_END
 436            ; PackageHeader = (EFI_HII_PACKAGE_HEADER *)(((CHAR8 *)(PackageHeader))+PackageHeader->Length))
 437       {
 438         if (PackageHeader->Type == EFI_HII_PACKAGE_DEVICE_PATH) {
 439           HiiHandle = NULL;
 440           Status    = FindHiiHandleViaDevPath ((EFI_DEVICE_PATH_PROTOCOL *)(((CHAR8 *)PackageHeader) + sizeof (EFI_HII_PACKAGE_HEADER)), &HiiHandle, HiiDatabase);
 441           if (EFI_ERROR (Status)) {
 442             //
 443             // print out an error.
 444             //
 445             TempDevPathString = ConvertDevicePathToText ((EFI_DEVICE_PATH_PROTOCOL *)(((CHAR8 *)PackageHeader) + sizeof (EFI_HII_PACKAGE_HEADER)), TRUE, TRUE);
 446             ShellPrintHiiEx (
 447               -1,
 448               -1,
 449               NULL,
 450               STRING_TOKEN (STR_DRVCFG_IN_FILE_NF),
 451               gShellDriver1HiiHandle,
 452               TempDevPathString
 453               );
 454             SHELL_FREE_NON_NULL (TempDevPathString);
 455           } else {
 456             Status = HiiDatabase->UpdatePackageList (HiiDatabase, HiiHandle, PackageListHeader);
 457             if (EFI_ERROR (Status)) {
 458               ShellPrintHiiEx (
 459                 -1,
 460                 -1,
 461                 NULL,
 462                 STRING_TOKEN (STR_GEN_UEFI_FUNC_WARN),
 463                 gShellDriver1HiiHandle,
 464                 L"drvcfg",
 465                 L"HiiDatabase->UpdatePackageList",
 466                 Status
 467                 );
 468               return (SHELL_DEVICE_ERROR);
 469             } else {
 470               DevPath = (EFI_DEVICE_PATH_PROTOCOL *)(((CHAR8 *)PackageHeader) + sizeof (EFI_HII_PACKAGE_HEADER));
 471               gBS->LocateDevicePath (&gEfiHiiConfigAccessProtocolGuid, &DevPath, &Handle);
 472               HandleIndex = ConvertHandleToHandleIndex (Handle);
 473               ShellPrintHiiEx (
 474                 -1,
 475                 -1,
 476                 NULL,
 477                 STRING_TOKEN (STR_DRVCFG_DONE_HII),
 478                 gShellDriver1HiiHandle,
 479                 HandleIndex
 480                 );
 481             }
 482           }
 483         }
 484       }
 485     }
 486   }
 487
 488   SHELL_FREE_NON_NULL (MainBuffer);
 489
 490   ShellPrintHiiEx (
 491     -1,
 492     -1,
 493     NULL,
 494     STRING_TOKEN (STR_DRVCFG_COMP),
 495     gShellDriver1HiiHandle
 496     );
 497   return (SHELL_SUCCESS);
 498 }
 499
 500 /**
 501   Present a requested action to the user.
 502
 503   @param[in] DriverImageHandle  The handle for the driver to configure.
 504   @param[in] ControllerHandle   The handle of the device being managed by the Driver specified.
 505   @param[in] ChildHandle        The handle of a child device of the specified device.
 506   @param[in] ActionRequired     The required HII action.
 507
 508   @retval SHELL_INVALID_PARAMETER   A parameter has a invalid value.
 509 **/
 510 EFI_STATUS
 511 ShellCmdDriverConfigurationProcessActionRequired (
 512   EFI_HANDLE                                DriverImageHandle,
 513   EFI_HANDLE                                ControllerHandle,
 514   EFI_HANDLE                                ChildHandle,
 515   EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED  ActionRequired
 516   )
 517 {
 518   EFI_HANDLE  ConnectControllerContextOverride[2];
 519
 520   switch (ActionRequired) {
 521     case EfiDriverConfigurationActionNone:
 522       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_NONE), gShellDriver1HiiHandle);
 523       break;
 524
 525     case EfiDriverConfigurationActionStopController:
 526       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_STOP), gShellDriver1HiiHandle);
 527       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_ENTER_S), gShellDriver1HiiHandle, L"stop controller");
 528       ShellPromptForResponse (ShellPromptResponseTypeEnterContinue, NULL, NULL);
 529
 530       gBS->DisconnectController (ControllerHandle, DriverImageHandle, ChildHandle);
 531       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_CTLR_S), gShellDriver1HiiHandle, L"stopped");
 532       break;
 533
 534     case EfiDriverConfigurationActionRestartController:
 535       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_RESTART_S), gShellDriver1HiiHandle, L"controller");
 536       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_ENTER_S), gShellDriver1HiiHandle, L"restart controller");
 537       ShellPromptForResponse (ShellPromptResponseTypeEnterContinue, NULL, NULL);
 538
 539       gBS->DisconnectController (ControllerHandle, DriverImageHandle, ChildHandle);
 540       ConnectControllerContextOverride[0] = DriverImageHandle;
 541       ConnectControllerContextOverride[1] = NULL;
 542       gBS->ConnectController (ControllerHandle, ConnectControllerContextOverride, NULL, TRUE);
 543       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_CTLR_S), gShellDriver1HiiHandle, L"restarted");
 544       break;
 545
 546     case EfiDriverConfigurationActionRestartPlatform:
 547       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_RESTART_S), gShellDriver1HiiHandle, L"platform");
 548       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_ENTER_S), gShellDriver1HiiHandle, L"restart platform");
 549       ShellPromptForResponse (ShellPromptResponseTypeEnterContinue, NULL, NULL);
 550
 551       gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
 552       break;
 553
 554     default:
 555       return (EFI_INVALID_PARAMETER);
 556   }
 557
 558   return EFI_SUCCESS;
 559 }
 560
 561 /**
 562   Do the configuration in an environment without HII.
 563
 564   @param[in] Language           The language code.
 565   @param[in] ForceDefaults      TRUE to force defaults, FALSE otherwise.
 566   @param[in] DefaultType        If ForceDefaults is TRUE, specifies the default type.
 567   @param[in] AllChildren        TRUE to configure all children, FALSE otherwise.
 568   @param[in] ValidateOptions    TRUE to validate existing options, FALSE otherwise.
 569   @param[in] SetOptions         TRUE to set options, FALSE otherwise.
 570   @param[in] DriverImageHandle  The handle for the driver to configure.
 571   @param[in] DeviceHandle       The handle of the device being managed by the Driver specified.
 572   @param[in] ChildHandle        The handle of a child device of the specified device.
 573
 574   @retval SHELL_NOT_FOUND           A specified handle could not be found.
 575   @retval SHELL_INVALID_PARAMETER   A parameter has a invalid value.
 576 **/
 577 SHELL_STATUS
 578 PreHiiDrvCfg (
 579   IN CONST CHAR8  *Language,
 580   IN BOOLEAN      ForceDefaults,
 581   IN UINT32       DefaultType,
 582   IN BOOLEAN      AllChildren,
 583   IN BOOLEAN      ValidateOptions,
 584   IN BOOLEAN      SetOptions,
 585   IN EFI_HANDLE   DriverImageHandle,
 586   IN EFI_HANDLE   DeviceHandle,
 587   IN EFI_HANDLE   ChildHandle
 588   )
 589 {
 590   EFI_STATUS                                Status;
 591   SHELL_STATUS                              ShellStatus;
 592   UINTN                                     OuterLoopCounter;
 593   CHAR8                                     *BestLanguage;
 594   UINTN                                     DriverImageHandleCount;
 595   EFI_HANDLE                                *DriverImageHandleBuffer;
 596   UINTN                                     HandleCount;
 597   EFI_HANDLE                                *HandleBuffer;
 598   UINTN                                     *HandleType;
 599   UINTN                                     LoopCounter;
 600   UINTN                                     ChildIndex;
 601   UINTN                                     ChildHandleCount;
 602   EFI_HANDLE                                *ChildHandleBuffer;
 603   UINTN                                     *ChildHandleType;
 604   EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED  ActionRequired;
 605   EFI_DRIVER_CONFIGURATION_PROTOCOL         *DriverConfiguration;
 606   BOOLEAN                                   Iso639Language;
 607   UINTN                                     HandleIndex1;
 608   UINTN                                     HandleIndex2;
 609   UINTN                                     HandleIndex3;
 610
 611   ShellStatus = SHELL_SUCCESS;
 612
 613   if ((ChildHandle == NULL) && AllChildren) {
 614     SetOptions = FALSE;
 615   }
 616
 617   if (ForceDefaults) {
 618     ShellPrintHiiEx (
 619       -1,
 620       -1,
 621       NULL,
 622       STRING_TOKEN (STR_DRVCFG_FORCE_D),
 623       gShellDriver1HiiHandle,
 624       DefaultType
 625       );
 626   } else if (ValidateOptions) {
 627     ShellPrintHiiEx (
 628       -1,
 629       -1,
 630       NULL,
 631       STRING_TOKEN (STR_DRVCFG_VALIDATE),
 632       gShellDriver1HiiHandle
 633       );
 634   } else if (SetOptions) {
 635     ShellPrintHiiEx (
 636       -1,
 637       -1,
 638       NULL,
 639       STRING_TOKEN (STR_DRVCFG_SET),
 640       gShellDriver1HiiHandle
 641       );
 642   }
 643
 644   if (DriverImageHandle == 0) {
 645     DriverImageHandleBuffer = GetHandleListByProtocolList (CfgGuidList);
 646     if (DriverImageHandleBuffer == NULL) {
 647       ShellStatus = SHELL_NOT_FOUND;
 648       goto Done;
 649     }
 650
 651     for (
 652          HandleBuffer = DriverImageHandleBuffer, DriverImageHandleCount = 0
 653          ; HandleBuffer != NULL && *HandleBuffer != NULL
 654          ; HandleBuffer++, DriverImageHandleCount++)
 655     {
 656     }
 657   } else {
 658     DriverImageHandleCount = 1;
 659     //
 660     // Allocate buffer to hold the image handle so as to
 661     // keep consistent with the above clause
 662     //
 663     DriverImageHandleBuffer = AllocatePool (sizeof (EFI_HANDLE));
 664     ASSERT (DriverImageHandleBuffer);
 665     DriverImageHandleBuffer[0] = DriverImageHandle;
 666   }
 667
 668   for (OuterLoopCounter = 0; OuterLoopCounter < DriverImageHandleCount; OuterLoopCounter++) {
 669     Iso639Language = FALSE;
 670     Status         = gBS->OpenProtocol (
 671                             DriverImageHandleBuffer[OuterLoopCounter],
 672                             &gEfiDriverConfiguration2ProtocolGuid,
 673                             (VOID **)&DriverConfiguration,
 674                             NULL,
 675                             NULL,
 676                             EFI_OPEN_PROTOCOL_GET_PROTOCOL
 677                             );
 678     if (EFI_ERROR (Status)) {
 679       Iso639Language = TRUE;
 680       Status         = gBS->OpenProtocol (
 681                               DriverImageHandleBuffer[OuterLoopCounter],
 682                               &gEfiDriverConfigurationProtocolGuid,
 683                               (VOID **)&DriverConfiguration,
 684                               NULL,
 685                               NULL,
 686                               EFI_OPEN_PROTOCOL_GET_PROTOCOL
 687                               );
 688     }
 689
 690     if (EFI_ERROR (Status)) {
 691       //      ShellPrintHiiEx(
 692       //        -1,
 693       //        -1,
 694       //        NULL,
 695       //        STRING_TOKEN (STR_DRVCFG_NOT_SUPPORT),
 696       //        gShellDriver1HiiHandle,
 697       //        ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter])
 698       //        );
 699       ShellStatus = SHELL_UNSUPPORTED;
 700       continue;
 701     }
 702
 703     BestLanguage = GetBestLanguage (
 704                      DriverConfiguration->SupportedLanguages,
 705                      Iso639Language,
 706                      Language != NULL ? Language : "",
 707                      DriverConfiguration->SupportedLanguages,
 708                      NULL
 709                      );
 710     if (BestLanguage == NULL) {
 711       ShellPrintHiiEx (
 712         -1,
 713         -1,
 714         NULL,
 715         STRING_TOKEN (STR_GEN_NO_VALUE),
 716         gShellDriver1HiiHandle,
 717         L"drvcfg",
 718         L"-l"
 719         );
 720       ShellStatus = SHELL_INVALID_PARAMETER;
 721       continue;
 722     }
 723
 724     Status = ParseHandleDatabaseByRelationshipWithType (
 725                DriverImageHandleBuffer[OuterLoopCounter],
 726                NULL,
 727                &HandleCount,
 728                &HandleBuffer,
 729                &HandleType
 730                );
 731     if (EFI_ERROR (Status)) {
 732       continue;
 733     }
 734
 735     if (SetOptions && (DeviceHandle == NULL)) {
 736       gST->ConOut->ClearScreen (gST->ConOut);
 737       Status = DriverConfiguration->SetOptions (
 738                                       DriverConfiguration,
 739                                       NULL,
 740                                       NULL,
 741                                       BestLanguage,
 742                                       &ActionRequired
 743                                       );
 744       gST->ConOut->ClearScreen (gST->ConOut);
 745
 746       ShellPrintHiiEx (
 747         -1,
 748         -1,
 749         NULL,
 750         STRING_TOKEN (STR_DRVCFG_ALL_LANG),
 751         gShellDriver1HiiHandle,
 752         ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]),
 753         DriverConfiguration->SupportedLanguages
 754         );
 755       if (!EFI_ERROR (Status)) {
 756         ShellPrintHiiEx (
 757           -1,
 758           -1,
 759           NULL,
 760           STRING_TOKEN (STR_DRVCFG_OPTIONS_SET),
 761           gShellDriver1HiiHandle
 762           );
 763         for (LoopCounter = 0; LoopCounter < HandleCount; LoopCounter++) {
 764           if ((HandleType[LoopCounter] & HR_CONTROLLER_HANDLE) == HR_CONTROLLER_HANDLE) {
 765             ShellCmdDriverConfigurationProcessActionRequired (
 766               DriverImageHandleBuffer[OuterLoopCounter],
 767               HandleBuffer[LoopCounter],
 768               NULL,
 769               ActionRequired
 770               );
 771           }
 772         }
 773       } else {
 774         ShellPrintHiiEx (
 775           -1,
 776           -1,
 777           NULL,
 778           STRING_TOKEN (STR_DRVCFG_NOT_SET),
 779           gShellDriver1HiiHandle,
 780           Status
 781           );
 782       }
 783
 784       continue;
 785     }
 786
 787     for (LoopCounter = 0; LoopCounter < HandleCount; LoopCounter++) {
 788       if ((HandleType[LoopCounter] & HR_CONTROLLER_HANDLE) != HR_CONTROLLER_HANDLE) {
 789         continue;
 790       }
 791
 792       if ((DeviceHandle != NULL) && (DeviceHandle != HandleBuffer[LoopCounter])) {
 793         continue;
 794       }
 795
 796       if (ChildHandle == NULL) {
 797         HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
 798         HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
 799         ShellPrintHiiEx (
 800           -1,
 801           -1,
 802           NULL,
 803           STRING_TOKEN (STR_DRVCFG_CTRL_LANG),
 804           gShellDriver1HiiHandle,
 805           HandleIndex1,
 806           HandleIndex2,
 807           DriverConfiguration->SupportedLanguages
 808           );
 809
 810         if (ForceDefaults) {
 811           Status = DriverConfiguration->ForceDefaults (
 812                                           DriverConfiguration,
 813                                           HandleBuffer[LoopCounter],
 814                                           NULL,
 815                                           DefaultType,
 816                                           &ActionRequired
 817                                           );
 818
 819           if (!EFI_ERROR (Status)) {
 820             ShellPrintHiiEx (
 821               -1,
 822               -1,
 823               NULL,
 824               STRING_TOKEN (STR_DRVCFG_DEF_FORCED),
 825               gShellDriver1HiiHandle
 826               );
 827             ShellCmdDriverConfigurationProcessActionRequired (
 828               DriverImageHandleBuffer[OuterLoopCounter],
 829               HandleBuffer[LoopCounter],
 830               NULL,
 831               ActionRequired
 832               );
 833           } else {
 834             ShellPrintHiiEx (
 835               -1,
 836               -1,
 837               NULL,
 838               STRING_TOKEN (STR_DRVCFG_FORCE_FAILED),
 839               gShellDriver1HiiHandle,
 840               Status
 841               );
 842             ShellStatus = SHELL_DEVICE_ERROR;
 843           }
 844         } else if (ValidateOptions) {
 845           Status = DriverConfiguration->OptionsValid (
 846                                           DriverConfiguration,
 847                                           HandleBuffer[LoopCounter],
 848                                           NULL
 849                                           );
 850
 851           if (!EFI_ERROR (Status)) {
 852             ShellPrintHiiEx (
 853               -1,
 854               -1,
 855               NULL,
 856               STRING_TOKEN (STR_DRVCFG_OPTIONS_VALID),
 857               gShellDriver1HiiHandle
 858               );
 859           } else {
 860             ShellPrintHiiEx (
 861               -1,
 862               -1,
 863               NULL,
 864               STRING_TOKEN (STR_DRVCFG_OPTIONS_INV),
 865               gShellDriver1HiiHandle,
 866               Status
 867               );
 868             ShellStatus = SHELL_DEVICE_ERROR;
 869           }
 870         } else if (SetOptions) {
 871           gST->ConOut->ClearScreen (gST->ConOut);
 872           Status = DriverConfiguration->SetOptions (
 873                                           DriverConfiguration,
 874                                           HandleBuffer[LoopCounter],
 875                                           NULL,
 876                                           BestLanguage,
 877                                           &ActionRequired
 878                                           );
 879           gST->ConOut->ClearScreen (gST->ConOut);
 880           HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
 881           HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
 882           ShellPrintHiiEx (
 883             -1,
 884             -1,
 885             NULL,
 886             STRING_TOKEN (STR_DRVCFG_CTRL_LANG),
 887             gShellDriver1HiiHandle,
 888             HandleIndex1,
 889             HandleIndex2,
 890             DriverConfiguration->SupportedLanguages
 891             );
 892           if (!EFI_ERROR (Status)) {
 893             ShellPrintHiiEx (
 894               -1,
 895               -1,
 896               NULL,
 897               STRING_TOKEN (STR_DRVCFG_OPTIONS_SET),
 898               gShellDriver1HiiHandle
 899               );
 900
 901             ShellCmdDriverConfigurationProcessActionRequired (
 902               DriverImageHandleBuffer[OuterLoopCounter],
 903               HandleBuffer[LoopCounter],
 904               NULL,
 905               ActionRequired
 906               );
 907           } else {
 908             ShellPrintHiiEx (
 909               -1,
 910               -1,
 911               NULL,
 912               STRING_TOKEN (STR_DRVCFG_NOT_SET),
 913               gShellDriver1HiiHandle,
 914               Status
 915               );
 916             ShellStatus = SHELL_DEVICE_ERROR;
 917           }
 918         } else {
 919           Print (L"\n");
 920         }
 921       }
 922
 923       if ((ChildHandle == NULL) && !AllChildren) {
 924         continue;
 925       }
 926
 927       Status = ParseHandleDatabaseByRelationshipWithType (
 928                  DriverImageHandleBuffer[OuterLoopCounter],
 929                  HandleBuffer[LoopCounter],
 930                  &ChildHandleCount,
 931                  &ChildHandleBuffer,
 932                  &ChildHandleType
 933                  );
 934       if (EFI_ERROR (Status)) {
 935         continue;
 936       }
 937
 938       for (ChildIndex = 0; ChildIndex < ChildHandleCount; ChildIndex++) {
 939         if ((ChildHandleType[ChildIndex] & HR_CHILD_HANDLE) != HR_CHILD_HANDLE) {
 940           continue;
 941         }
 942
 943         if ((ChildHandle != NULL) && (ChildHandle != ChildHandleBuffer[ChildIndex])) {
 944           continue;
 945         }
 946
 947         HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
 948         HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
 949         HandleIndex3 = ConvertHandleToHandleIndex (ChildHandleBuffer[ChildIndex]);
 950         ShellPrintHiiEx (
 951           -1,
 952           -1,
 953           NULL,
 954           STRING_TOKEN (STR_DRVCFG_CHILD_LANG),
 955           gShellDriver1HiiHandle,
 956           HandleIndex1,
 957           HandleIndex2,
 958           HandleIndex3,
 959           DriverConfiguration->SupportedLanguages
 960           );
 961
 962         if (ForceDefaults) {
 963           Status = DriverConfiguration->ForceDefaults (
 964                                           DriverConfiguration,
 965                                           HandleBuffer[LoopCounter],
 966                                           ChildHandleBuffer[ChildIndex],
 967                                           DefaultType,
 968                                           &ActionRequired
 969                                           );
 970
 971           if (!EFI_ERROR (Status)) {
 972             ShellPrintHiiEx (
 973               -1,
 974               -1,
 975               NULL,
 976               STRING_TOKEN (STR_DRVCFG_DEF_FORCED),
 977               gShellDriver1HiiHandle
 978               );
 979
 980             ShellCmdDriverConfigurationProcessActionRequired (
 981               DriverImageHandleBuffer[OuterLoopCounter],
 982               HandleBuffer[LoopCounter],
 983               ChildHandleBuffer[ChildIndex],
 984               ActionRequired
 985               );
 986           } else {
 987             ShellPrintHiiEx (
 988               -1,
 989               -1,
 990               NULL,
 991               STRING_TOKEN (STR_DRVCFG_FORCE_FAILED),
 992               gShellDriver1HiiHandle,
 993               Status
 994               );
 995             ShellStatus = SHELL_DEVICE_ERROR;
 996           }
 997         } else if (ValidateOptions) {
 998           Status = DriverConfiguration->OptionsValid (
 999                                           DriverConfiguration,
1000                                           HandleBuffer[LoopCounter],
1001                                           ChildHandleBuffer[ChildIndex]
1002                                           );
1003
1004           if (!EFI_ERROR (Status)) {
1005             ShellPrintHiiEx (
1006               -1,
1007               -1,
1008               NULL,
1009               STRING_TOKEN (STR_DRVCFG_OPTIONS_VALID),
1010               gShellDriver1HiiHandle
1011               );
1012           } else {
1013             ShellPrintHiiEx (
1014               -1,
1015               -1,
1016               NULL,
1017               STRING_TOKEN (STR_DRVCFG_OPTIONS_INV),
1018               gShellDriver1HiiHandle,
1019               Status
1020               );
1021             ShellStatus = SHELL_DEVICE_ERROR;
1022           }
1023         } else if (SetOptions) {
1024           gST->ConOut->ClearScreen (gST->ConOut);
1025           Status = DriverConfiguration->SetOptions (
1026                                           DriverConfiguration,
1027                                           HandleBuffer[LoopCounter],
1028                                           ChildHandleBuffer[ChildIndex],
1029                                           BestLanguage,
1030                                           &ActionRequired
1031                                           );
1032           gST->ConOut->ClearScreen (gST->ConOut);
1033           HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
1034           HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
1035           HandleIndex3 = ConvertHandleToHandleIndex (ChildHandleBuffer[ChildIndex]);
1036           ShellPrintHiiEx (
1037             -1,
1038             -1,
1039             NULL,
1040             STRING_TOKEN (STR_DRVCFG_CHILD_LANG),
1041             gShellDriver1HiiHandle,
1042             HandleIndex1,
1043             HandleIndex2,
1044             HandleIndex3,
1045             DriverConfiguration->SupportedLanguages
1046             );
1047           if (!EFI_ERROR (Status)) {
1048             ShellPrintHiiEx (
1049               -1,
1050               -1,
1051               NULL,
1052               STRING_TOKEN (STR_DRVCFG_OPTIONS_SET),
1053               gShellDriver1HiiHandle
1054               );
1055
1056             ShellCmdDriverConfigurationProcessActionRequired (
1057               DriverImageHandleBuffer[OuterLoopCounter],
1058               HandleBuffer[LoopCounter],
1059               ChildHandleBuffer[ChildIndex],
1060               ActionRequired
1061               );
1062           } else {
1063             ShellPrintHiiEx (
1064               -1,
1065               -1,
1066               NULL,
1067               STRING_TOKEN (STR_DRVCFG_NOT_SET),
1068               gShellDriver1HiiHandle,
1069               Status
1070               );
1071             ShellStatus = SHELL_DEVICE_ERROR;
1072           }
1073         } else {
1074           Print (L"\n");
1075         }
1076       }
1077
1078       FreePool (ChildHandleBuffer);
1079       FreePool (ChildHandleType);
1080     }
1081
1082     FreePool (BestLanguage);
1083     FreePool (HandleBuffer);
1084     FreePool (HandleType);
1085   }
1086
1087   if ((DriverImageHandle != NULL) && (DriverImageHandleCount != 0)) {
1088     FreePool (DriverImageHandleBuffer);
1089   }
1090
1091 Done:
1092   return ShellStatus;
1093 }
1094
1095 /**
1096   Function to print out configuration information on all configurable handles.
1097
1098   @param[in] ChildrenToo    TRUE to tewst for children.
1099   @param[in] Language       ASCII string for language code.
1100   @param[in] UseHii         TRUE to check for Hii and DPC, FALSE for DCP only.
1101
1102   @retval SHELL_SUCCESS     The operation was successful.
1103 **/
1104 SHELL_STATUS
1105 PrintConfigInfoOnAll (
1106   IN CONST BOOLEAN  ChildrenToo,
1107   IN CONST CHAR8    *Language,
1108   IN CONST BOOLEAN  UseHii
1109   )
1110 {
1111   EFI_HANDLE  *HandleList;
1112   EFI_HANDLE  *CurrentHandle;
1113   BOOLEAN     Found;
1114   UINTN       Index2;
1115
1116   Found         = FALSE;
1117   HandleList    = NULL;
1118   CurrentHandle = NULL;
1119
1120   if (UseHii) {
1121     //
1122     // HII method
1123     //
1124     HandleList = GetHandleListByProtocol (&gEfiHiiConfigAccessProtocolGuid);
1125     for (CurrentHandle = HandleList; CurrentHandle != NULL && *CurrentHandle != NULL; CurrentHandle++) {
1126       Found  = TRUE;
1127       Index2 = *CurrentHandle == NULL ? 0 : ConvertHandleToHandleIndex (*CurrentHandle);
1128       ShellPrintHiiEx (
1129         -1,
1130         -1,
1131         NULL,
1132         STRING_TOKEN (STR_DRVCFG_LINE_HII),
1133         gShellDriver1HiiHandle,
1134         Index2
1135         );
1136     }
1137
1138     SHELL_FREE_NON_NULL (HandleList);
1139   }
1140
1141   if (PreHiiDrvCfg (
1142         Language,
1143         FALSE,
1144         0,
1145         ChildrenToo,
1146         FALSE,
1147         FALSE,
1148         0,
1149         0,
1150         0
1151         ) == SHELL_SUCCESS)
1152   {
1153     Found = TRUE;
1154   }
1155
1156   if (!Found) {
1157     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_NONE_FOUND), gShellDriver1HiiHandle);
1158     return (SHELL_SUCCESS);
1159   }
1160
1161   return (SHELL_SUCCESS);
1162 }
1163
1164 STATIC CONST SHELL_PARAM_ITEM  ParamListHii[] = {
1165   { L"-s", TypeFlag  },
1166   { L"-l", TypeValue },
1167   { L"-f", TypeValue },
1168   { L"-o", TypeValue },
1169   { L"-i", TypeValue },
1170   { NULL,  TypeMax   }
1171 };
1172 STATIC CONST SHELL_PARAM_ITEM  ParamListPreHii[] = {
1173   { L"-c", TypeFlag  },
1174   { L"-s", TypeFlag  },
1175   { L"-v", TypeFlag  },
1176   { L"-l", TypeValue },
1177   { L"-f", TypeValue },
1178   { NULL,  TypeMax   }
1179 };
1180
1181 /**
1182   Function for 'drvcfg' command.
1183
1184   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
1185   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
1186 **/
1187 SHELL_STATUS
1188 EFIAPI
1189 ShellCommandRunDrvCfg (
1190   IN EFI_HANDLE        ImageHandle,
1191   IN EFI_SYSTEM_TABLE  *SystemTable
1192   )
1193 {
1194   EFI_STATUS    Status;
1195   LIST_ENTRY    *Package;
1196   CHAR16        *ProblemParam;
1197   SHELL_STATUS  ShellStatus;
1198   CHAR8         *Language;
1199   CONST CHAR16  *Lang;
1200   CONST CHAR16  *HandleIndex1;
1201   CONST CHAR16  *HandleIndex2;
1202   CONST CHAR16  *HandleIndex3;
1203   CONST CHAR16  *ForceTypeString;
1204   BOOLEAN       Force;
1205   BOOLEAN       Set;
1206   BOOLEAN       Validate;
1207   BOOLEAN       InFromFile;
1208   BOOLEAN       OutToFile;
1209   BOOLEAN       AllChildren;
1210   BOOLEAN       UseHii;
1211   UINT32        ForceType;
1212   UINT64        Intermediate;
1213   EFI_HANDLE    Handle1;
1214   EFI_HANDLE    Handle2;
1215   EFI_HANDLE    Handle3;
1216   CONST CHAR16  *FileName;
1217
1218   ShellStatus  = SHELL_SUCCESS;
1219   Status       = EFI_SUCCESS;
1220   Language     = NULL;
1221   UseHii       = TRUE;
1222   ProblemParam = NULL;
1223
1224   //
1225   // initialize the shell lib (we must be in non-auto-init...)
1226   //
1227   Status = ShellInitialize ();
1228   ASSERT_EFI_ERROR (Status);
1229
1230   Status = CommandInit ();
1231   ASSERT_EFI_ERROR (Status);
1232
1233   //
1234   // parse the command line
1235   //
1236   Status = ShellCommandLineParse (ParamListHii, &Package, &ProblemParam, TRUE);
1237   if (EFI_ERROR (Status) || (ShellCommandLineGetCount (Package) > 2)) {
1238     UseHii = FALSE;
1239     if (Package != NULL) {
1240       ShellCommandLineFreeVarList (Package);
1241     }
1242
1243     SHELL_FREE_NON_NULL (ProblemParam);
1244     Status = ShellCommandLineParse (ParamListPreHii, &Package, &ProblemParam, TRUE);
1245     if (EFI_ERROR (Status)) {
1246       if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {
1247         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"drvcfg", ProblemParam);
1248         FreePool (ProblemParam);
1249         ShellStatus = SHELL_INVALID_PARAMETER;
1250         goto Done;
1251       } else {
1252         ASSERT (FALSE);
1253       }
1254     }
1255   }
1256
1257   if (ShellStatus == SHELL_SUCCESS) {
1258     if (ShellCommandLineGetCount (Package) > 4) {
1259       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"drvcfg");
1260       ShellStatus = SHELL_INVALID_PARAMETER;
1261       goto Done;
1262     }
1263
1264     Lang = ShellCommandLineGetValue (Package, L"-l");
1265     if (Lang != NULL) {
1266       Language = AllocateZeroPool (StrSize (Lang));
1267       AsciiSPrint (Language, StrSize (Lang), "%S", Lang);
1268     } else if (ShellCommandLineGetFlag (Package, L"-l")) {
1269       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"drvcfg", L"-l");
1270       ShellStatus = SHELL_INVALID_PARAMETER;
1271       goto Done;
1272     }
1273
1274     Set             = ShellCommandLineGetFlag (Package, L"-s");
1275     Validate        = ShellCommandLineGetFlag (Package, L"-v");
1276     InFromFile      = ShellCommandLineGetFlag (Package, L"-i");
1277     OutToFile       = ShellCommandLineGetFlag (Package, L"-o");
1278     AllChildren     = ShellCommandLineGetFlag (Package, L"-c");
1279     Force           = ShellCommandLineGetFlag (Package, L"-f");
1280     ForceTypeString = ShellCommandLineGetValue (Package, L"-f");
1281
1282     if (OutToFile) {
1283       FileName = ShellCommandLineGetValue (Package, L"-o");
1284     } else if (InFromFile) {
1285       FileName = ShellCommandLineGetValue (Package, L"-i");
1286     } else {
1287       FileName = NULL;
1288     }
1289
1290     if (InFromFile && EFI_ERROR (ShellFileExists (FileName))) {
1291       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FIND_FAIL), gShellDriver1HiiHandle, L"drvcfg", FileName);
1292       ShellStatus = SHELL_INVALID_PARAMETER;
1293       goto Done;
1294     }
1295
1296     if (OutToFile && !EFI_ERROR (ShellFileExists (FileName))) {
1297       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_EXIST), gShellDriver1HiiHandle, L"drvcfg", FileName);
1298       ShellStatus = SHELL_INVALID_PARAMETER;
1299       goto Done;
1300     }
1301
1302     if (Force && (ForceTypeString == NULL)) {
1303       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"drvcfg", L"-f");
1304       ShellStatus = SHELL_INVALID_PARAMETER;
1305       goto Done;
1306     }
1307
1308     if (Force) {
1309       Status = ShellConvertStringToUint64 (ForceTypeString, &Intermediate, FALSE, FALSE);
1310       if (EFI_ERROR (Status)) {
1311         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM_VAL), gShellDriver1HiiHandle, L"drvcfg", ForceTypeString, L"-f");
1312         ShellStatus = SHELL_INVALID_PARAMETER;
1313         goto Done;
1314       }
1315
1316       ForceType = (UINT32)Intermediate;
1317     } else {
1318       ForceType = 0;
1319     }
1320
1321     HandleIndex1 = ShellCommandLineGetRawValue (Package, 1);
1322     Handle1      = NULL;
1323     if ((HandleIndex1 != NULL) && !EFI_ERROR (ShellConvertStringToUint64 (HandleIndex1, &Intermediate, TRUE, FALSE))) {
1324       Handle1 = ConvertHandleIndexToHandle ((UINTN)Intermediate);
1325       if ((Handle1 == NULL) || ((UINT64)(UINTN)Intermediate != Intermediate)) {
1326         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"drvcfg", HandleIndex1);
1327         ShellStatus = SHELL_INVALID_PARAMETER;
1328         goto Done;
1329       }
1330     }
1331
1332     HandleIndex2 = ShellCommandLineGetRawValue (Package, 2);
1333     Handle2      = NULL;
1334     if ((HandleIndex2 != NULL) && !EFI_ERROR (ShellConvertStringToUint64 (HandleIndex2, &Intermediate, TRUE, FALSE))) {
1335       Handle2 = ConvertHandleIndexToHandle ((UINTN)Intermediate);
1336       if ((Handle2 == NULL) || ((UINT64)(UINTN)Intermediate != Intermediate)) {
1337         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"drvcfg", HandleIndex2);
1338         ShellStatus = SHELL_INVALID_PARAMETER;
1339         goto Done;
1340       }
1341     }
1342
1343     HandleIndex3 = ShellCommandLineGetRawValue (Package, 3);
1344     Handle3      = NULL;
1345     if ((HandleIndex3 != NULL) && !EFI_ERROR (ShellConvertStringToUint64 (HandleIndex3, &Intermediate, TRUE, FALSE))) {
1346       Handle3 = ConvertHandleIndexToHandle ((UINTN)Intermediate);
1347       if ((Handle3 == NULL) || ((UINT64)(UINTN)Intermediate != Intermediate)) {
1348         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"drvcfg", HandleIndex3);
1349         ShellStatus = SHELL_INVALID_PARAMETER;
1350         goto Done;
1351       }
1352     }
1353
1354     if ((InFromFile || OutToFile) && (FileName == NULL)) {
1355       if (FileName == NULL) {
1356         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"drvcfg", InFromFile ? L"-i" : L"-o");
1357       } else {
1358         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_HANDLE_REQ), gShellDriver1HiiHandle, L"drvcfg");
1359       }
1360
1361       ShellStatus = SHELL_INVALID_PARAMETER;
1362       goto Done;
1363     }
1364
1365     if (!UseHii && (InFromFile || OutToFile)) {
1366       if (InFromFile) {
1367         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDriver1HiiHandle, L"drvcfg", L"-i");
1368         ShellStatus = SHELL_INVALID_PARAMETER;
1369         goto Done;
1370       }
1371
1372       if (OutToFile) {
1373         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDriver1HiiHandle, L"drvcfg", L"-o");
1374         ShellStatus = SHELL_INVALID_PARAMETER;
1375         goto Done;
1376       }
1377     }
1378
1379     if (Validate && Force) {
1380       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDriver1HiiHandle, L"drvcfg", L"-v", L"-f");
1381       ShellStatus = SHELL_INVALID_PARAMETER;
1382       goto Done;
1383     }
1384
1385     if (Validate && Set) {
1386       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDriver1HiiHandle, L"drvcfg", L"-v", L"-s");
1387       ShellStatus = SHELL_INVALID_PARAMETER;
1388       goto Done;
1389     }
1390
1391     if (Set && Force) {
1392       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDriver1HiiHandle, L"drvcfg", L"-s", L"-f");
1393       ShellStatus = SHELL_INVALID_PARAMETER;
1394       goto Done;
1395     }
1396
1397     if (OutToFile && InFromFile) {
1398       ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDriver1HiiHandle, L"drvcfg", L"-i", L"-o");
1399       ShellStatus = SHELL_INVALID_PARAMETER;
1400       goto Done;
1401     }
1402
1403     //
1404     // We do HII first.
1405     //
1406     if (UseHii) {
1407       if ((Handle1 != NULL) && EFI_ERROR (gBS->OpenProtocol (Handle1, &gEfiHiiConfigAccessProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
1408         //
1409         // no HII on this handle.
1410         //
1411         ShellStatus = SHELL_UNSUPPORTED;
1412       } else if (Validate) {
1413       } else if (Force) {
1414       } else if (Set) {
1415       } else if (InFromFile) {
1416         ShellStatus = ConfigFromFile (Handle1, FileName);
1417         if ((Handle1 != NULL) && (ShellStatus == SHELL_SUCCESS)) {
1418           goto Done;
1419         }
1420       } else if (OutToFile) {
1421         ShellStatus = ConfigToFile (Handle1, FileName);
1422         if ((Handle1 != NULL) && (ShellStatus == SHELL_SUCCESS)) {
1423           goto Done;
1424         }
1425       } else if (HandleIndex1 == NULL) {
1426         //
1427         // display all that are configurable
1428         //
1429         ShellStatus = PrintConfigInfoOnAll (AllChildren, Language, UseHii);
1430         goto Done;
1431       } else {
1432         if (!EFI_ERROR (gBS->OpenProtocol (Handle1, &gEfiHiiConfigAccessProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
1433           ShellPrintHiiEx (
1434             -1,
1435             -1,
1436             NULL,
1437             STRING_TOKEN (STR_DRVCFG_LINE_HII),
1438             gShellDriver1HiiHandle,
1439             ConvertHandleToHandleIndex (Handle1)
1440             );
1441           goto Done;
1442         }
1443       }
1444     }
1445
1446     //
1447     // We allways need to do this one since it does both by default.
1448     //
1449     if (!InFromFile && !OutToFile) {
1450       ShellStatus = PreHiiDrvCfg (
1451                       Language,
1452                       Force,
1453                       ForceType,
1454                       AllChildren,
1455                       Validate,
1456                       Set,
1457                       Handle1,
1458                       Handle2,
1459                       Handle3
1460                       );
1461     }
1462
1463     if (ShellStatus == SHELL_UNSUPPORTED) {
1464       ShellPrintHiiEx (
1465         -1,
1466         -1,
1467         NULL,
1468         STRING_TOKEN (STR_DRVCFG_NOT_SUPPORT),
1469         gShellDriver1HiiHandle,
1470         ConvertHandleToHandleIndex (Handle1)
1471         );
1472     }
1473   }
1474
1475 Done:
1476   ShellCommandLineFreeVarList (Package);
1477   SHELL_FREE_NON_NULL (Language);
1478   return (ShellStatus);
1479 }