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