ShellPkg/Library/UefiShellDriver1CommandsLib/DrvCfg.c

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