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