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 /**
 461   Present a requested action to the user.
 462
 463   @param[in] DriverImageHandle  The handle for the driver to configure.
 464   @param[in] ControllerHandle   The handle of the device being managed by the Driver specified.
 465   @param[in] ChildHandle        The handle of a child device of the specified device.
 466   @param[in] ActionRequired     The required HII action.
 467
 468   @retval SHELL_INVALID_PARAMETER   A parameter has a invalid value.
 469 **/
 470 EFI_STATUS
 471 EFIAPI
 472 ShellCmdDriverConfigurationProcessActionRequired (
 473   EFI_HANDLE                                DriverImageHandle,
 474   EFI_HANDLE                                ControllerHandle,
 475   EFI_HANDLE                                ChildHandle,
 476   EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED  ActionRequired
 477   )
 478 {
 479   EFI_HANDLE  ConnectControllerContextOverride[2];
 480
 481   switch (ActionRequired) {
 482   case EfiDriverConfigurationActionNone:
 483     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_DRVCFG_NONE), gShellDriver1HiiHandle);
 484     break;
 485
 486   case EfiDriverConfigurationActionStopController:
 487     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_DRVCFG_STOP), gShellDriver1HiiHandle);
 488     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_DRVCFG_ENTER_S), gShellDriver1HiiHandle, L"stop controller");
 489     ShellPromptForResponse(ShellPromptResponseTypeEnterContinue, NULL, NULL);
 490
 491     gBS->DisconnectController (ControllerHandle, DriverImageHandle, ChildHandle);
 492     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_DRVCFG_CTLR_S), gShellDriver1HiiHandle, L"stopped");
 493     break;
 494
 495   case EfiDriverConfigurationActionRestartController:
 496     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_DRVCFG_RESTART_S), gShellDriver1HiiHandle, L"controller");
 497     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_DRVCFG_ENTER_S), gShellDriver1HiiHandle, L"restart controller");
 498     ShellPromptForResponse(ShellPromptResponseTypeEnterContinue, NULL, NULL);
 499
 500     gBS->DisconnectController (ControllerHandle, DriverImageHandle, ChildHandle);
 501     ConnectControllerContextOverride[0]  = DriverImageHandle;
 502     ConnectControllerContextOverride[1]  = NULL;
 503     gBS->ConnectController (ControllerHandle, ConnectControllerContextOverride, NULL, TRUE);
 504     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_DRVCFG_CTLR_S), gShellDriver1HiiHandle, L"restarted");
 505     break;
 506
 507   case EfiDriverConfigurationActionRestartPlatform:
 508     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_DRVCFG_RESTART_S), gShellDriver1HiiHandle, L"platform");
 509     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_DRVCFG_ENTER_S), gShellDriver1HiiHandle, L"restart platform");
 510     ShellPromptForResponse(ShellPromptResponseTypeEnterContinue, NULL, NULL);
 511
 512     gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
 513     break;
 514
 515   default:
 516     return (EFI_INVALID_PARAMETER);
 517     break;
 518   }
 519
 520   return EFI_SUCCESS;
 521 }
 522
 523 /**
 524   Do the configuration in an environment without HII.
 525
 526   @param[in] Language           The language code.
 527   @param[in] ForceDefaults      TRUE to force defaults, FALSE otherwise.
 528   @param[in] DefaultType        If ForceDefaults is TRUE, specifies the default type.
 529   @param[in] AllChildren        TRUE to configure all children, FALSE otherwise.
 530   @param[in] ValidateOptions    TRUE to validate existing options, FALSE otherwise.
 531   @param[in] SetOptions         TRUE to set options, FALSE otherwise.
 532   @param[in] DriverImageHandle  The handle for the driver to configure.
 533   @param[in] DeviceHandle       The handle of the device being managed by the Driver specified.
 534   @param[in] ChildHandle        The handle of a child device of the specified device.
 535
 536   @retval SHELL_NOT_FOUND           A specified handle could not be found.
 537   @retval SHELL_INVALID_PARAMETER   A parameter has a invalid value.
 538 **/
 539 SHELL_STATUS
 540 EFIAPI
 541 PreHiiDrvCfg (
 542   IN CONST CHAR8    *Language,
 543   IN BOOLEAN        ForceDefaults,
 544   IN UINT32         DefaultType,
 545   IN BOOLEAN        AllChildren,
 546   IN BOOLEAN        ValidateOptions,
 547   IN BOOLEAN        SetOptions,
 548   IN EFI_HANDLE     DriverImageHandle,
 549   IN EFI_HANDLE     DeviceHandle,
 550   IN EFI_HANDLE     ChildHandle
 551   )
 552 {
 553   EFI_STATUS                                Status;
 554   SHELL_STATUS                              ShellStatus;
 555   UINTN                                     OuterLoopCounter;
 556   CHAR8                                     *BestLanguage;
 557   UINTN                                     DriverImageHandleCount;
 558   EFI_HANDLE                                *DriverImageHandleBuffer;
 559   UINTN                                     HandleCount;
 560   EFI_HANDLE                                *HandleBuffer;
 561   UINTN                                     *HandleType;
 562   UINTN                                     LoopCounter;
 563   UINTN                                     ChildIndex;
 564   UINTN                                     ChildHandleCount;
 565   EFI_HANDLE                                *ChildHandleBuffer;
 566   UINTN                                     *ChildHandleType;
 567   EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED  ActionRequired;
 568   EFI_DRIVER_CONFIGURATION_PROTOCOL         *DriverConfiguration;
 569   BOOLEAN                                   Iso639Language;
 570   UINTN                                     HandleIndex1;
 571   UINTN                                     HandleIndex2;
 572   UINTN                                     HandleIndex3;
 573
 574   ShellStatus = SHELL_SUCCESS;
 575
 576   if (ChildHandle == NULL && AllChildren) {
 577     SetOptions = FALSE;
 578   }
 579
 580   if (ForceDefaults) {
 581     ShellPrintHiiEx(
 582       -1,
 583       -1,
 584       NULL,
 585       STRING_TOKEN (STR_DRVCFG_FORCE_D),
 586       gShellDriver1HiiHandle,
 587       DefaultType);
 588   } else if (ValidateOptions) {
 589     ShellPrintHiiEx(
 590       -1,
 591       -1,
 592       NULL,
 593       STRING_TOKEN (STR_DRVCFG_VALIDATE),
 594       gShellDriver1HiiHandle);
 595   } else if (SetOptions) {
 596     ShellPrintHiiEx(
 597       -1,
 598       -1,
 599       NULL,
 600       STRING_TOKEN (STR_DRVCFG_SET),
 601       gShellDriver1HiiHandle);
 602   }
 603
 604   if (DriverImageHandle == 0) {
 605     DriverImageHandleBuffer = GetHandleListByProtocolList(CfgGuidList);
 606     if (DriverImageHandleBuffer == NULL) {
 607       ShellStatus = SHELL_NOT_FOUND;
 608       goto Done;
 609     }
 610     for (
 611       HandleBuffer = DriverImageHandleBuffer, DriverImageHandleCount = 0
 612       ; HandleBuffer != NULL && *HandleBuffer != NULL
 613       ; HandleBuffer++,DriverImageHandleCount++);
 614   } else {
 615     DriverImageHandleCount = 1;
 616     //
 617     // Allocate buffer to hold the image handle so as to
 618     // keep consistent with the above clause
 619     //
 620     DriverImageHandleBuffer = AllocatePool (sizeof (EFI_HANDLE));
 621     ASSERT (DriverImageHandleBuffer);
 622     DriverImageHandleBuffer[0] = DriverImageHandle;
 623   }
 624
 625   for (OuterLoopCounter = 0; OuterLoopCounter < DriverImageHandleCount; OuterLoopCounter++) {
 626     Iso639Language = FALSE;
 627     Status = gBS->OpenProtocol (
 628                   DriverImageHandleBuffer[OuterLoopCounter],
 629                   &gEfiDriverConfiguration2ProtocolGuid,
 630                   (VOID **) &DriverConfiguration,
 631                   NULL,
 632                   NULL,
 633                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 634                   );
 635     if (EFI_ERROR (Status)) {
 636       Iso639Language = TRUE;
 637       Status = gBS->OpenProtocol (
 638                     DriverImageHandleBuffer[OuterLoopCounter],
 639                     &gEfiDriverConfigurationProtocolGuid,
 640                     (VOID **) &DriverConfiguration,
 641                     NULL,
 642                     NULL,
 643                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 644                     );
 645     }
 646     if (EFI_ERROR (Status)) {
 647 //      ShellPrintHiiEx(
 648 //        -1,
 649 //        -1,
 650 //        NULL,
 651 //        STRING_TOKEN (STR_DRVCFG_NOT_SUPPORT),
 652 //        gShellDriver1HiiHandle,
 653 //        ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter])
 654 //        );
 655       ShellStatus = SHELL_UNSUPPORTED;
 656       continue;
 657     }
 658
 659     BestLanguage = GetBestLanguage (
 660                           DriverConfiguration->SupportedLanguages,
 661                           Iso639Language,
 662                           Language!=NULL?Language:"",
 663                           DriverConfiguration->SupportedLanguages,
 664                           NULL
 665                           );
 666     if (BestLanguage == NULL) {
 667       ShellPrintHiiEx(
 668         -1,
 669         -1,
 670         NULL,
 671         STRING_TOKEN (STR_GEN_PROBLEM_VAL),
 672         gShellDriver1HiiHandle,
 673         L"-l"
 674         );
 675       ShellStatus = SHELL_INVALID_PARAMETER;
 676       continue;
 677     }
 678
 679     Status = ParseHandleDatabaseByRelationshipWithType (
 680               DriverImageHandleBuffer[OuterLoopCounter],
 681               NULL,
 682               &HandleCount,
 683               &HandleBuffer,
 684               &HandleType
 685               );
 686     if (EFI_ERROR (Status)) {
 687       continue;
 688     }
 689
 690     if (SetOptions && DeviceHandle == NULL) {
 691
 692       gST->ConOut->ClearScreen (gST->ConOut);
 693       Status = DriverConfiguration->SetOptions (
 694                                       DriverConfiguration,
 695                                       NULL,
 696                                       NULL,
 697                                       BestLanguage,
 698                                       &ActionRequired
 699                                       );
 700       gST->ConOut->ClearScreen (gST->ConOut);
 701
 702       ShellPrintHiiEx(
 703         -1,
 704         -1,
 705         NULL,
 706         STRING_TOKEN (STR_DRVCFG_ALL_LANG),
 707         gShellDriver1HiiHandle,
 708         ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]),
 709         DriverConfiguration->SupportedLanguages
 710         );
 711       if (!EFI_ERROR (Status)) {
 712         ShellPrintHiiEx(
 713           -1,
 714           -1,
 715           NULL,
 716           STRING_TOKEN (STR_DRVCFG_OPTIONS_SET),
 717           gShellDriver1HiiHandle);
 718         for (LoopCounter = 0; LoopCounter < HandleCount; LoopCounter++) {
 719           if ((HandleType[LoopCounter] & HR_CONTROLLER_HANDLE) == HR_CONTROLLER_HANDLE) {
 720             ShellCmdDriverConfigurationProcessActionRequired (
 721               DriverImageHandleBuffer[OuterLoopCounter],
 722               HandleBuffer[LoopCounter],
 723               NULL,
 724               ActionRequired
 725               );
 726           }
 727         }
 728       } else {
 729         ShellPrintHiiEx(
 730           -1,
 731           -1,
 732           NULL,
 733           STRING_TOKEN (STR_DRVCFG_NOT_SET),
 734           gShellDriver1HiiHandle,
 735           Status);
 736       }
 737       continue;
 738     }
 739
 740     for (LoopCounter = 0; LoopCounter < HandleCount; LoopCounter++) {
 741       if ((HandleType[LoopCounter] & HR_CONTROLLER_HANDLE) != HR_CONTROLLER_HANDLE) {
 742         continue;
 743       }
 744       if (DeviceHandle != NULL && DeviceHandle != HandleBuffer[LoopCounter]) {
 745         continue;
 746       }
 747       if (ChildHandle == NULL) {
 748         HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
 749         HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
 750         ShellPrintHiiEx(
 751           -1,
 752           -1,
 753           NULL,
 754           STRING_TOKEN (STR_DRVCFG_CTRL_LANG),
 755           gShellDriver1HiiHandle,
 756           HandleIndex1,
 757           HandleIndex2,
 758           DriverConfiguration->SupportedLanguages
 759           );
 760
 761         if (ForceDefaults) {
 762           Status = DriverConfiguration->ForceDefaults (
 763                                           DriverConfiguration,
 764                                           HandleBuffer[LoopCounter],
 765                                           NULL,
 766                                           DefaultType,
 767                                           &ActionRequired
 768                                           );
 769
 770           if (!EFI_ERROR (Status)) {
 771             ShellPrintHiiEx(
 772               -1,
 773               -1,
 774               NULL,
 775               STRING_TOKEN (STR_DRVCFG_DEF_FORCED),
 776               gShellDriver1HiiHandle);
 777             ShellCmdDriverConfigurationProcessActionRequired (
 778               DriverImageHandleBuffer[OuterLoopCounter],
 779               HandleBuffer[LoopCounter],
 780               NULL,
 781               ActionRequired
 782               );
 783           } else {
 784             ShellPrintHiiEx(
 785               -1,
 786               -1,
 787               NULL,
 788               STRING_TOKEN (STR_DRVCFG_FORCE_FAILED),
 789               gShellDriver1HiiHandle,
 790               Status);
 791            ShellStatus = SHELL_DEVICE_ERROR;
 792          }
 793         } else if (ValidateOptions) {
 794           Status = DriverConfiguration->OptionsValid (
 795                                           DriverConfiguration,
 796                                           HandleBuffer[LoopCounter],
 797                                           NULL
 798                                           );
 799
 800           if (!EFI_ERROR (Status)) {
 801             ShellPrintHiiEx(
 802               -1,
 803               -1,
 804               NULL,
 805               STRING_TOKEN (STR_DRVCFG_OPTIONS_VALID),
 806               gShellDriver1HiiHandle);
 807           } else {
 808             ShellPrintHiiEx(
 809               -1,
 810               -1,
 811               NULL,
 812               STRING_TOKEN (STR_DRVCFG_OPTIONS_INV),
 813               gShellDriver1HiiHandle,
 814               Status);
 815             ShellStatus = SHELL_DEVICE_ERROR;
 816           }
 817         } else if (SetOptions) {
 818           gST->ConOut->ClearScreen (gST->ConOut);
 819           Status = DriverConfiguration->SetOptions (
 820                                           DriverConfiguration,
 821                                           HandleBuffer[LoopCounter],
 822                                           NULL,
 823                                           BestLanguage,
 824                                           &ActionRequired
 825                                           );
 826           gST->ConOut->ClearScreen (gST->ConOut);
 827           HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
 828           HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
 829           ShellPrintHiiEx(
 830             -1,
 831             -1,
 832             NULL,
 833             STRING_TOKEN (STR_DRVCFG_CTRL_LANG),
 834             gShellDriver1HiiHandle,
 835             HandleIndex1,
 836             HandleIndex2,
 837             DriverConfiguration->SupportedLanguages
 838             );
 839           if (!EFI_ERROR (Status)) {
 840             ShellPrintHiiEx(
 841               -1,
 842               -1,
 843               NULL,
 844               STRING_TOKEN (STR_DRVCFG_OPTIONS_SET),
 845               gShellDriver1HiiHandle);
 846
 847             ShellCmdDriverConfigurationProcessActionRequired (
 848               DriverImageHandleBuffer[OuterLoopCounter],
 849               HandleBuffer[LoopCounter],
 850               NULL,
 851               ActionRequired
 852               );
 853
 854           } else {
 855             ShellPrintHiiEx(
 856               -1,
 857               -1,
 858               NULL,
 859               STRING_TOKEN (STR_DRVCFG_NOT_SET),
 860               gShellDriver1HiiHandle,
 861               Status);
 862             ShellStatus = SHELL_DEVICE_ERROR;
 863           }
 864         } else {
 865           Print (L"\n");
 866         }
 867       }
 868
 869       if (ChildHandle == NULL && !AllChildren) {
 870         continue;
 871       }
 872
 873       Status = ParseHandleDatabaseByRelationshipWithType (
 874                 DriverImageHandleBuffer[OuterLoopCounter],
 875                 HandleBuffer[LoopCounter],
 876                 &ChildHandleCount,
 877                 &ChildHandleBuffer,
 878                 &ChildHandleType
 879                 );
 880       if (EFI_ERROR (Status)) {
 881         continue;
 882       }
 883
 884       for (ChildIndex = 0; ChildIndex < ChildHandleCount; ChildIndex++) {
 885
 886         if ((ChildHandleType[ChildIndex] & HR_CHILD_HANDLE) != HR_CHILD_HANDLE) {
 887           continue;
 888         }
 889
 890         if (ChildHandle != NULL && ChildHandle != ChildHandleBuffer[ChildIndex]) {
 891           continue;
 892         }
 893
 894         HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
 895         HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
 896         HandleIndex3 = ConvertHandleToHandleIndex (ChildHandleBuffer[ChildIndex]);
 897         ShellPrintHiiEx(
 898           -1,
 899           -1,
 900           NULL,
 901           STRING_TOKEN (STR_DRVCFG_CHILD_LANG),
 902           gShellDriver1HiiHandle,
 903           HandleIndex1,
 904           HandleIndex2,
 905           HandleIndex3,
 906           DriverConfiguration->SupportedLanguages);
 907
 908         if (ForceDefaults) {
 909           Status = DriverConfiguration->ForceDefaults (
 910                                           DriverConfiguration,
 911                                           HandleBuffer[LoopCounter],
 912                                           ChildHandleBuffer[ChildIndex],
 913                                           DefaultType,
 914                                           &ActionRequired
 915                                           );
 916
 917           if (!EFI_ERROR (Status)) {
 918             ShellPrintHiiEx(
 919               -1,
 920               -1,
 921               NULL,
 922               STRING_TOKEN (STR_DRVCFG_DEF_FORCED),
 923               gShellDriver1HiiHandle);
 924
 925             ShellCmdDriverConfigurationProcessActionRequired (
 926               DriverImageHandleBuffer[OuterLoopCounter],
 927               HandleBuffer[LoopCounter],
 928               ChildHandleBuffer[ChildIndex],
 929               ActionRequired
 930               );
 931
 932           } else {
 933             ShellPrintHiiEx(
 934               -1,
 935               -1,
 936               NULL,
 937               STRING_TOKEN (STR_DRVCFG_FORCE_FAILED),
 938               gShellDriver1HiiHandle,
 939               Status);
 940             ShellStatus = SHELL_DEVICE_ERROR;
 941           }
 942         } else if (ValidateOptions) {
 943           Status = DriverConfiguration->OptionsValid (
 944                                           DriverConfiguration,
 945                                           HandleBuffer[LoopCounter],
 946                                           ChildHandleBuffer[ChildIndex]
 947                                           );
 948
 949           if (!EFI_ERROR (Status)) {
 950             ShellPrintHiiEx(
 951               -1,
 952               -1,
 953               NULL,
 954               STRING_TOKEN (STR_DRVCFG_OPTIONS_VALID),
 955               gShellDriver1HiiHandle);
 956           } else {
 957             ShellPrintHiiEx(
 958               -1,
 959               -1,
 960               NULL,
 961               STRING_TOKEN (STR_DRVCFG_OPTIONS_INV),
 962               gShellDriver1HiiHandle,
 963               Status);
 964             ShellStatus = SHELL_DEVICE_ERROR;
 965           }
 966         } else if (SetOptions) {
 967           gST->ConOut->ClearScreen (gST->ConOut);
 968           Status = DriverConfiguration->SetOptions (
 969                                           DriverConfiguration,
 970                                           HandleBuffer[LoopCounter],
 971                                           ChildHandleBuffer[ChildIndex],
 972                                           BestLanguage,
 973                                           &ActionRequired
 974                                           );
 975           gST->ConOut->ClearScreen (gST->ConOut);
 976           HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
 977           HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
 978           HandleIndex3 = ConvertHandleToHandleIndex (ChildHandleBuffer[ChildIndex]);
 979           ShellPrintHiiEx(
 980             -1,
 981             -1,
 982             NULL,
 983             STRING_TOKEN (STR_DRVCFG_CHILD_LANG),
 984             gShellDriver1HiiHandle,
 985             HandleIndex1,
 986             HandleIndex2,
 987             HandleIndex3,
 988             DriverConfiguration->SupportedLanguages
 989             );
 990           if (!EFI_ERROR (Status)) {
 991             ShellPrintHiiEx(
 992               -1,
 993               -1,
 994               NULL,
 995               STRING_TOKEN (STR_DRVCFG_OPTIONS_SET),
 996               gShellDriver1HiiHandle);
 997
 998             ShellCmdDriverConfigurationProcessActionRequired (
 999               DriverImageHandleBuffer[OuterLoopCounter],
1000               HandleBuffer[LoopCounter],
1001               ChildHandleBuffer[ChildIndex],
1002               ActionRequired
1003               );
1004
1005           } else {
1006             ShellPrintHiiEx(
1007               -1,
1008               -1,
1009               NULL,
1010               STRING_TOKEN (STR_DRVCFG_NOT_SET),
1011               gShellDriver1HiiHandle,
1012               Status);
1013             ShellStatus = SHELL_DEVICE_ERROR;
1014           }
1015         } else {
1016           Print (L"\n");
1017         }
1018       }
1019
1020       FreePool (ChildHandleBuffer);
1021       FreePool (ChildHandleType);
1022     }
1023
1024     FreePool (BestLanguage);
1025     FreePool (HandleBuffer);
1026     FreePool (HandleType);
1027   }
1028
1029   if (DriverImageHandle != NULL && DriverImageHandleCount != 0) {
1030     FreePool (DriverImageHandleBuffer);
1031   }
1032
1033 Done:
1034   return ShellStatus;
1035 }
1036
1037 /**
1038   Function to print out configuration information on all configurable handles.
1039
1040   @param[in] ChildrenToo    TRUE to tewst for children.
1041   @param[in] Language       ASCII string for language code.
1042   @param[in] UseHii         TRUE to check for Hii and DPC, FALSE for DCP only.
1043
1044   @retval SHELL_SUCCESS     The operation was successful.
1045 **/
1046 SHELL_STATUS
1047 EFIAPI
1048 PrintConfigInfoOnAll(
1049   IN CONST BOOLEAN ChildrenToo,
1050   IN CONST CHAR8   *Language,
1051   IN CONST BOOLEAN UseHii
1052   )
1053 {
1054   EFI_HANDLE        *HandleList;
1055   EFI_HANDLE        *CurrentHandle;
1056   BOOLEAN           Found;
1057   UINTN             Index2;
1058
1059
1060   Found             = FALSE;
1061   HandleList        = NULL;
1062   CurrentHandle     = NULL;
1063
1064   if (UseHii) {
1065     //
1066     // HII method
1067     //
1068     HandleList = GetHandleListByProtocol(&gEfiHiiConfigAccessProtocolGuid);
1069     for (CurrentHandle = HandleList ; CurrentHandle != NULL && *CurrentHandle != NULL; CurrentHandle++){
1070       Found = TRUE;
1071       Index2 = *CurrentHandle == NULL ? 0 : ConvertHandleToHandleIndex(*CurrentHandle);
1072       ShellPrintHiiEx(
1073         -1,
1074         -1,
1075         NULL,
1076         STRING_TOKEN (STR_DRVCFG_LINE_HII),
1077         gShellDriver1HiiHandle,
1078         Index2
1079         );
1080     }
1081     SHELL_FREE_NON_NULL(HandleList);
1082   }
1083
1084   if (PreHiiDrvCfg (
1085     Language,
1086     FALSE,
1087     0,
1088     ChildrenToo,
1089     FALSE,
1090     FALSE,
1091     0,
1092     0,
1093     0) == SHELL_SUCCESS) {
1094       Found = TRUE;
1095   }
1096
1097   if (!Found) {
1098     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_NONE), gShellDriver1HiiHandle);
1099     return (SHELL_SUCCESS);
1100   }
1101
1102   return (SHELL_SUCCESS);
1103 }
1104
1105 STATIC CONST SHELL_PARAM_ITEM ParamListHii[] = {
1106   {L"-s", TypeFlag},
1107   {L"-l", TypeValue},
1108   {L"-f", TypeValue},
1109   {L"-o", TypeValue},
1110   {L"-i", TypeValue},
1111   {NULL, TypeMax}
1112   };
1113 STATIC CONST SHELL_PARAM_ITEM ParamListPreHii[] = {
1114   {L"-c", TypeFlag},
1115   {L"-s", TypeFlag},
1116   {L"-v", TypeFlag},
1117   {L"-l", TypeValue},
1118   {L"-f", TypeValue},
1119   {NULL, TypeMax}
1120   };
1121
1122 /**
1123   Function for 'drvcfg' command.
1124
1125   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
1126   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
1127 **/
1128 SHELL_STATUS
1129 EFIAPI
1130 ShellCommandRunDrvCfg (
1131   IN EFI_HANDLE        ImageHandle,
1132   IN EFI_SYSTEM_TABLE  *SystemTable
1133   )
1134 {
1135   EFI_STATUS          Status;
1136   LIST_ENTRY          *Package;
1137   CHAR16              *ProblemParam;
1138   SHELL_STATUS        ShellStatus;
1139   CHAR8               *Language;
1140   CONST CHAR16        *Lang;
1141   CONST CHAR16        *HandleIndex1;
1142   CONST CHAR16        *HandleIndex2;
1143   CONST CHAR16        *HandleIndex3;
1144   CONST CHAR16        *ForceTypeString;
1145   BOOLEAN             Force;
1146   BOOLEAN             Set;
1147   BOOLEAN             Validate;
1148   BOOLEAN             InFromFile;
1149   BOOLEAN             OutToFile;
1150   BOOLEAN             AllChildren;
1151   BOOLEAN             UseHii;
1152   UINT32              ForceType;
1153   UINT64              Intermediate;
1154   EFI_HANDLE          Handle1;
1155   EFI_HANDLE          Handle2;
1156   EFI_HANDLE          Handle3;
1157   CONST CHAR16        *FileName;
1158
1159   ShellStatus         = SHELL_SUCCESS;
1160   Status              = EFI_SUCCESS;
1161   Language            = NULL;
1162   UseHii              = TRUE;
1163
1164   //
1165   // initialize the shell lib (we must be in non-auto-init...)
1166   //
1167   Status = ShellInitialize();
1168   ASSERT_EFI_ERROR(Status);
1169
1170   Status = CommandInit();
1171   ASSERT_EFI_ERROR(Status);
1172
1173   //
1174   // parse the command line
1175   //
1176   Status = ShellCommandLineParse (ParamListHii, &Package, &ProblemParam, TRUE);
1177   if (EFI_ERROR(Status) || ShellCommandLineGetCount(Package) > 2) {
1178     UseHii = FALSE;
1179     if (Package != NULL) {
1180       ShellCommandLineFreeVarList (Package);
1181     }
1182     SHELL_FREE_NON_NULL(ProblemParam);
1183     Status = ShellCommandLineParse (ParamListPreHii, &Package, &ProblemParam, TRUE);
1184     if (EFI_ERROR(Status)) {
1185       if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
1186         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);
1187         FreePool(ProblemParam);
1188         ShellStatus = SHELL_INVALID_PARAMETER;
1189         goto Done;
1190       } else {
1191         ASSERT(FALSE);
1192       }
1193     }
1194   }
1195   if (ShellStatus == SHELL_SUCCESS) {
1196     Lang = ShellCommandLineGetValue(Package, L"-l");
1197     if (Lang != NULL) {
1198       Language = AllocateZeroPool(StrSize(Lang));
1199       AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
1200     } else if (ShellCommandLineGetFlag(Package, L"-l")){
1201       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");
1202       ShellStatus = SHELL_INVALID_PARAMETER;
1203       goto Done;
1204     }
1205     Set                 = ShellCommandLineGetFlag (Package, L"-s");
1206     Validate            = ShellCommandLineGetFlag (Package, L"-v");
1207     InFromFile          = ShellCommandLineGetFlag (Package, L"-i");
1208     OutToFile           = ShellCommandLineGetFlag (Package, L"-o");
1209     AllChildren         = ShellCommandLineGetFlag (Package, L"-c");
1210     Force               = ShellCommandLineGetFlag (Package, L"-f");
1211     ForceTypeString     = ShellCommandLineGetValue(Package, L"-f");
1212
1213     if (OutToFile) {
1214       FileName = ShellCommandLineGetValue(Package, L"-o");
1215     } else if (InFromFile) {
1216       FileName = ShellCommandLineGetValue(Package, L"-i");
1217     } else {
1218       FileName = NULL;
1219     }
1220
1221     if (InFromFile && EFI_ERROR(ShellFileExists(FileName))) {
1222       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FIND_FAIL), gShellDriver1HiiHandle, FileName);
1223       ShellStatus = SHELL_INVALID_PARAMETER;
1224       goto Done;
1225     }
1226     if (OutToFile && !EFI_ERROR(ShellFileExists(FileName))) {
1227       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_EXIST), gShellDriver1HiiHandle, FileName);
1228       ShellStatus = SHELL_INVALID_PARAMETER;
1229       goto Done;
1230     }
1231     if (Force && ForceTypeString == NULL) {
1232       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-f");
1233       ShellStatus = SHELL_INVALID_PARAMETER;
1234       goto Done;
1235     }
1236     if (Force) {
1237       Status = ShellConvertStringToUint64(ForceTypeString, &Intermediate, FALSE, FALSE);
1238       if (EFI_ERROR(Status)) {
1239         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM_VAL), gShellDriver1HiiHandle, L"-f");
1240         ShellStatus = SHELL_INVALID_PARAMETER;
1241         goto Done;
1242       }
1243       ForceType = (UINT32)Intermediate;
1244     } else {
1245       ForceType = 0;
1246     }
1247     HandleIndex1        = ShellCommandLineGetRawValue(Package, 1);
1248     Handle1             = NULL;
1249     if (HandleIndex1 != NULL && !EFI_ERROR(ShellConvertStringToUint64(HandleIndex1, &Intermediate, TRUE, FALSE))) {
1250       Handle1 = ConvertHandleIndexToHandle((UINTN)Intermediate);
1251       if (Handle1 == NULL || (UINT64)(UINTN)Intermediate != Intermediate) {
1252         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, HandleIndex1);
1253         ShellStatus = SHELL_INVALID_PARAMETER;
1254         goto Done;
1255       }
1256     }
1257     HandleIndex2        = ShellCommandLineGetRawValue(Package, 2);
1258     Handle2             = NULL;
1259     if (HandleIndex2 != NULL && !EFI_ERROR(ShellConvertStringToUint64(HandleIndex2, &Intermediate, TRUE, FALSE))) {
1260       Handle2 = ConvertHandleIndexToHandle((UINTN)Intermediate);
1261       if (Handle2 == NULL || (UINT64)(UINTN)Intermediate != Intermediate) {
1262         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, HandleIndex2);
1263         ShellStatus = SHELL_INVALID_PARAMETER;
1264         goto Done;
1265       }
1266     }
1267     HandleIndex3        = ShellCommandLineGetRawValue(Package, 3);
1268     Handle3             = NULL;
1269     if (HandleIndex3 != NULL && !EFI_ERROR(ShellConvertStringToUint64(HandleIndex3, &Intermediate, TRUE, FALSE))) {
1270       Handle3 = ConvertHandleIndexToHandle((UINTN)Intermediate);
1271       if (Handle3 == NULL || (UINT64)(UINTN)Intermediate != Intermediate) {
1272         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, HandleIndex3);
1273         ShellStatus = SHELL_INVALID_PARAMETER;
1274         goto Done;
1275       }
1276     }
1277
1278     if ((InFromFile || OutToFile) && (FileName == NULL)) {
1279       if (FileName == NULL) {
1280         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, InFromFile?L"-i":L"-o");
1281       } else {
1282         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_HANDLE_REQ), gShellDriver1HiiHandle);
1283       }
1284       ShellStatus = SHELL_INVALID_PARAMETER;
1285       goto Done;
1286     }
1287     if (!UseHii && (InFromFile || OutToFile)) {
1288       if (InFromFile) {
1289         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"-i");
1290         ShellStatus = SHELL_INVALID_PARAMETER;
1291         goto Done;
1292       }
1293       if (OutToFile) {
1294         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"-o");
1295         ShellStatus = SHELL_INVALID_PARAMETER;
1296         goto Done;
1297       }
1298     }
1299     if (Validate && Force) {
1300       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONF), gShellDriver1HiiHandle, L"-v", L"-f");
1301       ShellStatus = SHELL_INVALID_PARAMETER;
1302       goto Done;
1303     }
1304     if (Validate && Set) {
1305       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONF), gShellDriver1HiiHandle, L"-v", L"-s");
1306       ShellStatus = SHELL_INVALID_PARAMETER;
1307       goto Done;
1308     }
1309     if (Set && Force) {
1310       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONF), gShellDriver1HiiHandle, L"-s", L"-f");
1311       ShellStatus = SHELL_INVALID_PARAMETER;
1312       goto Done;
1313     }
1314     if (OutToFile && InFromFile) {
1315       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONF), gShellDriver1HiiHandle, L"-i", L"-o");
1316       ShellStatus = SHELL_INVALID_PARAMETER;
1317       goto Done;
1318     }
1319
1320     //
1321     // We do HII first.
1322     //
1323     if (UseHii) {
1324       if (Handle1 != NULL && EFI_ERROR(gBS->OpenProtocol(Handle1, &gEfiHiiConfigAccessProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
1325         //
1326         // no HII on this handle.
1327         //
1328         ShellStatus = SHELL_UNSUPPORTED;
1329       } else if (Validate) {
1330       } else if (Force) {
1331       } else if (Set) {
1332       } else if (InFromFile) {
1333         ShellStatus = ConfigFromFile(Handle1, FileName);
1334         if (Handle1 != NULL && ShellStatus == SHELL_SUCCESS) {
1335           goto Done;
1336         }
1337       } else if (OutToFile) {
1338         ShellStatus = ConfigToFile(Handle1, FileName);
1339         if (Handle1 != NULL && ShellStatus == SHELL_SUCCESS) {
1340           goto Done;
1341         }
1342       } else if (HandleIndex1 == NULL) {
1343         //
1344         // display all that are configurable
1345         //
1346         ShellStatus = PrintConfigInfoOnAll(AllChildren, Language, UseHii);
1347         goto Done;
1348       } else {
1349         if (!EFI_ERROR(gBS->OpenProtocol(Handle1, &gEfiHiiConfigAccessProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
1350           ShellPrintHiiEx(
1351             -1,
1352             -1,
1353             NULL,
1354             STRING_TOKEN (STR_DRVCFG_LINE_HII),
1355             gShellDriver1HiiHandle,
1356             ConvertHandleToHandleIndex(Handle1)
1357             );
1358           goto Done;
1359         }
1360       }
1361     }
1362
1363     //
1364     // We allways need to do this one since it does both by default.
1365     //
1366     if (!InFromFile && !OutToFile) {
1367       ShellStatus = PreHiiDrvCfg (
1368         Language,
1369         Force,
1370         ForceType,
1371         AllChildren,
1372         Validate,
1373         Set,
1374         Handle1,
1375         Handle2,
1376         Handle3);
1377     }
1378
1379     if (ShellStatus == SHELL_UNSUPPORTED) {
1380       ShellPrintHiiEx(
1381         -1,
1382         -1,
1383         NULL,
1384         STRING_TOKEN (STR_DRVCFG_NOT_SUPPORT),
1385         gShellDriver1HiiHandle,
1386         ConvertHandleToHandleIndex(Handle1)
1387         );
1388     }
1389   }
1390
1391 Done:
1392   ShellCommandLineFreeVarList (Package);
1393   SHELL_FREE_NON_NULL(Language);
1394   return (ShellStatus);
1395 }