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