SecurityPkg/Tcg/Opal/OpalPasswordDxe/OpalHii.c

   1 /** @file
   2   Implementation of the HII for the Opal UEFI Driver.
   3
   4 Copyright (c) 2016, 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 "OpalHii.h"
  16 #include "OpalDriver.h"
  17 #include "OpalHiiPrivate.h"
  18
  19 //
  20 // This is the generated IFR binary Data for each formset defined in VFR.
  21 // This Data array is ready to be used as input of HiiAddPackages() to
  22 // create a packagelist (which contains Form packages, String packages, etc).
  23 //
  24 extern UINT8  OpalPasswordFormBin[];
  25
  26 //
  27 // This is the generated String package Data for all .UNI files.
  28 // This Data array is ready to be used as input of HiiAddPackages() to
  29 // create a packagelist (which contains Form packages, String packages, etc).
  30 //
  31 extern UINT8  OpalPasswordDxeStrings[];
  32
  33 CHAR16  OpalPasswordStorageName[] = L"OpalHiiConfig";
  34
  35 EFI_HII_CONFIG_ACCESS_PROTOCOL gHiiConfigAccessProtocol;
  36
  37 //
  38 // Handle to the list of HII packages (forms and strings) for this driver
  39 //
  40 EFI_HII_HANDLE gHiiPackageListHandle = NULL;
  41
  42 //
  43 // Package List GUID containing all form and string packages
  44 //
  45 const EFI_GUID gHiiPackageListGuid = PACKAGE_LIST_GUID;
  46 const EFI_GUID gHiiSetupVariableGuid = SETUP_VARIABLE_GUID;
  47
  48 //
  49 // Structure that contains state of the HII
  50 // This structure is updated by Hii.cpp and its contents
  51 // is rendered in the HII.
  52 //
  53 OPAL_HII_CONFIGURATION gHiiConfiguration;
  54
  55 CHAR8 gHiiOldPassword[MAX_PASSWORD_CHARACTER_LENGTH] = {0};
  56 UINT32 gHiiOldPasswordLength = 0;
  57
  58 //
  59 // The device path containing the VENDOR_DEVICE_PATH and EFI_DEVICE_PATH_PROTOCOL
  60 //
  61 HII_VENDOR_DEVICE_PATH gHiiVendorDevicePath = {
  62     {
  63         {
  64             HARDWARE_DEVICE_PATH,
  65             HW_VENDOR_DP,
  66             {
  67                 (UINT8)(sizeof(VENDOR_DEVICE_PATH)),
  68                 (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8)
  69             }
  70         },
  71         OPAL_PASSWORD_CONFIG_GUID
  72     },
  73     {
  74         END_DEVICE_PATH_TYPE,
  75         END_ENTIRE_DEVICE_PATH_SUBTYPE,
  76         {
  77             (UINT8)(END_DEVICE_PATH_LENGTH),
  78             (UINT8)((END_DEVICE_PATH_LENGTH) >> 8)
  79         }
  80     }
  81 };
  82
  83
  84 /**
  85   Sets the current system state of global config variables.
  86
  87 **/
  88 VOID
  89 HiiSetCurrentConfiguration(
  90   VOID
  91   )
  92 {
  93   UINT32                                       PpStorageFlag;
  94   EFI_STRING                                   NewString;
  95
  96   gHiiConfiguration.NumDisks = GetDeviceCount();
  97
  98   //
  99   // Update the BlockSID status string.
 100   //
 101   PpStorageFlag = TcgPhysicalPresenceStorageLibReturnStorageFlags();
 102
 103   if ((PpStorageFlag & TCG_BIOS_STORAGE_MANAGEMENT_FLAG_ENABLE_BLOCK_SID) != 0) {
 104     NewString = HiiGetString (gHiiPackageListHandle, STRING_TOKEN(STR_ENABLED), NULL);
 105     if (NewString == NULL) {
 106       DEBUG ((DEBUG_INFO,  "HiiSetCurrentConfiguration: HiiGetString( ) failed\n"));
 107       return;
 108     }
 109   } else {
 110     NewString = HiiGetString (gHiiPackageListHandle, STRING_TOKEN(STR_DISABLED), NULL);
 111     if (NewString == NULL) {
 112       DEBUG ((DEBUG_INFO,  "HiiSetCurrentConfiguration: HiiGetString( ) failed\n"));
 113       return;
 114     }
 115   }
 116   HiiSetString(gHiiPackageListHandle, STRING_TOKEN(STR_BLOCKSID_STATUS1), NewString, NULL);
 117   FreePool (NewString);
 118
 119   if ((PpStorageFlag & TCG_BIOS_STORAGE_MANAGEMENT_FLAG_PP_REQUIRED_FOR_ENABLE_BLOCK_SID) != 0) {
 120     NewString = HiiGetString (gHiiPackageListHandle, STRING_TOKEN(STR_DISK_INFO_ENABLE_BLOCKSID_TRUE), NULL);
 121     if (NewString == NULL) {
 122       DEBUG ((DEBUG_INFO,  "HiiSetCurrentConfiguration: HiiGetString( ) failed\n"));
 123       return;
 124     }
 125   } else {
 126     NewString = HiiGetString (gHiiPackageListHandle, STRING_TOKEN(STR_DISK_INFO_ENABLE_BLOCKSID_FALSE), NULL);
 127     if (NewString == NULL) {
 128       DEBUG ((DEBUG_INFO,  "HiiSetCurrentConfiguration: HiiGetString( ) failed\n"));
 129       return;
 130     }
 131   }
 132   HiiSetString(gHiiPackageListHandle, STRING_TOKEN(STR_BLOCKSID_STATUS2), NewString, NULL);
 133   FreePool (NewString);
 134
 135   if ((PpStorageFlag & TCG_BIOS_STORAGE_MANAGEMENT_FLAG_PP_REQUIRED_FOR_DISABLE_BLOCK_SID) != 0) {
 136     NewString = HiiGetString (gHiiPackageListHandle, STRING_TOKEN(STR_DISK_INFO_DISABLE_BLOCKSID_TRUE), NULL);
 137     if (NewString == NULL) {
 138       DEBUG ((DEBUG_INFO,  "HiiSetCurrentConfiguration: HiiGetString( ) failed\n"));
 139       return;
 140     }
 141   } else {
 142     NewString = HiiGetString (gHiiPackageListHandle, STRING_TOKEN(STR_DISK_INFO_DISABLE_BLOCKSID_FALSE), NULL);
 143     if (NewString == NULL) {
 144       DEBUG ((DEBUG_INFO,  "HiiSetCurrentConfiguration: HiiGetString( ) failed\n"));
 145       return;
 146     }
 147   }
 148   HiiSetString(gHiiPackageListHandle, STRING_TOKEN(STR_BLOCKSID_STATUS3), NewString, NULL);
 149   FreePool (NewString);
 150 }
 151
 152 /**
 153   Install the HII related resources.
 154
 155   @retval  EFI_SUCCESS        Install all the resources success.
 156   @retval  other              Error occur when install the resources.
 157 **/
 158 EFI_STATUS
 159 HiiInstall(
 160   VOID
 161   )
 162 {
 163   EFI_STATUS                   Status;
 164   EFI_HANDLE                   DriverHandle;
 165
 166   //
 167   // Clear the global configuration.
 168   //
 169   ZeroMem(&gHiiConfiguration, sizeof(gHiiConfiguration));
 170
 171   //
 172   // Obtain the driver handle that the BIOS assigned us
 173   //
 174   DriverHandle = HiiGetDriverImageHandleCB();
 175
 176   //
 177   // Populate the config access protocol with the three functions we are publishing
 178   //
 179   gHiiConfigAccessProtocol.ExtractConfig = ExtractConfig;
 180   gHiiConfigAccessProtocol.RouteConfig = RouteConfig;
 181   gHiiConfigAccessProtocol.Callback = DriverCallback;
 182
 183   //
 184   // Associate the required protocols with our driver handle
 185   //
 186   Status = gBS->InstallMultipleProtocolInterfaces(
 187                &DriverHandle,
 188                &gEfiHiiConfigAccessProtocolGuid,
 189                &gHiiConfigAccessProtocol,      // HII callback
 190                &gEfiDevicePathProtocolGuid,
 191                &gHiiVendorDevicePath,        // required for HII callback allow all disks to be shown in same hii
 192                NULL
 193            );
 194
 195   if (EFI_ERROR(Status)) {
 196     return Status;
 197   }
 198
 199   return OpalHiiAddPackages();
 200 }
 201
 202 /**
 203   Install the HII form and string packages.
 204
 205   @retval  EFI_SUCCESS           Install all the resources success.
 206   @retval  EFI_OUT_OF_RESOURCES  Out of resource error.
 207 **/
 208 EFI_STATUS
 209 OpalHiiAddPackages(
 210   VOID
 211   )
 212 {
 213   EFI_HANDLE                   DriverHandle;
 214   CHAR16                       *NewString;
 215
 216   DriverHandle = HiiGetDriverImageHandleCB();
 217
 218   //
 219   // Publish the HII form and HII string packages
 220   //
 221   gHiiPackageListHandle = HiiAddPackages(
 222                                 &gHiiPackageListGuid,
 223                                 DriverHandle,
 224                                 OpalPasswordDxeStrings,
 225                                 OpalPasswordFormBin,
 226                                 (VOID*)NULL
 227                                 );
 228
 229   //
 230   // Make sure the packages installed successfully
 231   //
 232   if (gHiiPackageListHandle == NULL) {
 233     DEBUG ((DEBUG_INFO, "OpalHiiAddPackages failed\n"));
 234     return EFI_OUT_OF_RESOURCES;
 235   }
 236
 237   //
 238   // Update Version String in main window
 239   //
 240   NewString = HiiGetDriverNameCB ();
 241   if (HiiSetString(gHiiPackageListHandle, STRING_TOKEN(STR_MAIN_OPAL_VERSION), NewString, NULL) == 0) {
 242     DEBUG ((DEBUG_INFO,  "OpalHiiAddPackages: HiiSetString( ) failed\n"));
 243     return EFI_OUT_OF_RESOURCES;
 244   }
 245
 246   return EFI_SUCCESS;
 247 }
 248
 249 /**
 250   Uninstall the HII capability.
 251
 252   @retval  EFI_SUCCESS           Uninstall all the resources success.
 253   @retval  others                Other errors occur when unistall the hii resource.
 254 **/
 255 EFI_STATUS
 256 HiiUninstall(
 257   VOID
 258   )
 259 {
 260   EFI_STATUS                   Status;
 261
 262   //
 263   // Remove the packages we've provided to the BIOS
 264   //
 265   HiiRemovePackages(gHiiPackageListHandle);
 266
 267   //
 268   // Remove the protocols from our driver handle
 269   //
 270   Status = gBS->UninstallMultipleProtocolInterfaces(
 271                           HiiGetDriverImageHandleCB(),
 272                           &gEfiHiiConfigAccessProtocolGuid,
 273                           &gHiiConfigAccessProtocol,        // HII callback
 274                           &gEfiDevicePathProtocolGuid,
 275                           &gHiiVendorDevicePath,            // required for HII callback
 276                           NULL
 277                       );
 278   if (EFI_ERROR(Status)) {
 279     DEBUG ((DEBUG_INFO, "Cannot uninstall Hii Protocols: %r\n", Status));
 280   }
 281
 282   return Status;
 283 }
 284
 285 /**
 286   Updates the main menu form.
 287
 288   @retval  EFI_SUCCESS           update the main form success.
 289 **/
 290 EFI_STATUS
 291 HiiPopulateMainMenuForm (
 292   VOID
 293   )
 294 {
 295   UINT8         Index;
 296   CHAR8         *DiskName;
 297   EFI_STRING_ID DiskNameId;
 298   OPAL_DISK     *OpalDisk;
 299
 300   HiiSetCurrentConfiguration();
 301
 302   gHiiConfiguration.SupportedDisks = 0;
 303
 304   for (Index = 0; Index < gHiiConfiguration.NumDisks; Index++) {
 305     OpalDisk = HiiGetOpalDiskCB (Index);
 306     if ((OpalDisk != NULL) && OpalFeatureSupported (&OpalDisk->SupportedAttributes)) {
 307       gHiiConfiguration.SupportedDisks |= (1 << Index);
 308       DiskNameId = GetDiskNameStringId (Index);
 309       DiskName = HiiDiskGetNameCB (Index);
 310       if ((DiskName == NULL) || (DiskNameId == 0)) {
 311         return EFI_UNSUPPORTED;
 312       }
 313       HiiSetFormString(DiskNameId, DiskName);
 314     }
 315   }
 316
 317   OpalHiiSetBrowserData ();
 318   return EFI_SUCCESS;
 319 }
 320
 321 /**
 322   Update the disk action info.
 323
 324   @param     ActionString
 325   @param     SelectedAction
 326
 327   @retval  EFI_SUCCESS           Uninstall all the resources success.
 328 **/
 329 EFI_STATUS
 330 HiiSelectDiskAction (
 331   CHAR8           *ActionString,
 332   UINT8           SelectedAction
 333   )
 334 {
 335   OPAL_DISK                     *OpalDisk;
 336   OPAL_DISK_ACTIONS              AvailActions;
 337
 338   OpalHiiGetBrowserData ();
 339
 340   HiiSetFormString(STRING_TOKEN(STR_DISK_ACTION_LBL), ActionString);
 341   HiiSetFormString(STRING_TOKEN(STR_ACTION_STATUS), " ");
 342
 343   gHiiConfiguration.SelectedAction = SelectedAction;
 344   gHiiConfiguration.AvailableFields = 0;
 345
 346   OpalDisk = HiiGetOpalDiskCB(gHiiConfiguration.SelectedDiskIndex);
 347   if (OpalDisk == NULL) {
 348     return EFI_INVALID_PARAMETER;
 349   }
 350
 351   if (OpalSupportGetAvailableActions (&OpalDisk->SupportedAttributes, &OpalDisk->LockingFeature, OpalDisk->Owner, &AvailActions) != TcgResultSuccess) {
 352     return EFI_DEVICE_ERROR;
 353   }
 354
 355   switch (SelectedAction) {
 356     case HII_KEY_ID_GOTO_LOCK:
 357     case HII_KEY_ID_GOTO_UNLOCK:
 358     case HII_KEY_ID_GOTO_SET_ADMIN_PWD:
 359     case HII_KEY_ID_GOTO_SET_USER_PWD:
 360     case HII_KEY_ID_GOTO_SECURE_ERASE:
 361     case HII_KEY_ID_GOTO_DISABLE_USER:
 362     case HII_KEY_ID_GOTO_ENABLE_FEATURE:   // User is required to enter Password to enable Feature
 363       gHiiConfiguration.AvailableFields |= HII_FIELD_PASSWORD;
 364       break;
 365
 366     case HII_KEY_ID_GOTO_PSID_REVERT:
 367       gHiiConfiguration.AvailableFields |= HII_FIELD_PSID;
 368       break;
 369
 370     case HII_KEY_ID_GOTO_REVERT:
 371       gHiiConfiguration.AvailableFields |= HII_FIELD_PASSWORD;
 372       gHiiConfiguration.AvailableFields |= HII_FIELD_KEEP_USER_DATA;
 373       if (AvailActions.RevertKeepDataForced) {
 374         gHiiConfiguration.AvailableFields |= HII_FIELD_KEEP_USER_DATA_FORCED;
 375       }
 376       break;
 377   }
 378
 379   OpalHiiSetBrowserData ();
 380
 381   return EFI_SUCCESS;
 382 }
 383
 384 /**
 385   Get disk name string id.
 386
 387   @param   DiskIndex             The input disk index info.
 388
 389   @retval  The disk name string id.
 390
 391 **/
 392 EFI_STRING_ID
 393 GetDiskNameStringId(
 394   UINT8 DiskIndex
 395   )
 396 {
 397   switch (DiskIndex) {
 398     case 0: return STRING_TOKEN(STR_MAIN_GOTO_DISK_INFO_0);
 399     case 1: return STRING_TOKEN(STR_MAIN_GOTO_DISK_INFO_1);
 400     case 2: return STRING_TOKEN(STR_MAIN_GOTO_DISK_INFO_2);
 401     case 3: return STRING_TOKEN(STR_MAIN_GOTO_DISK_INFO_3);
 402     case 4: return STRING_TOKEN(STR_MAIN_GOTO_DISK_INFO_4);
 403     case 5: return STRING_TOKEN(STR_MAIN_GOTO_DISK_INFO_5);
 404   }
 405   return 0;
 406 }
 407
 408 /**
 409   This function processes the results of changes in configuration.
 410
 411   @param  This                   Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 412   @param  Action                 Specifies the type of action taken by the browser.
 413   @param  QuestionId             A unique value which is sent to the original
 414                                  exporting driver so that it can identify the type
 415                                  of data to expect.
 416   @param  Type                   The type of value for the question.
 417   @param  Value                  A pointer to the data being sent to the original
 418                                  exporting driver.
 419   @param  ActionRequest          On return, points to the action requested by the
 420                                  callback function.
 421
 422   @retval EFI_SUCCESS            The callback successfully handled the action.
 423   @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the
 424                                  variable and its data.
 425   @retval EFI_DEVICE_ERROR       The variable could not be saved.
 426   @retval EFI_UNSUPPORTED        The specified Action is not supported by the
 427                                  callback.
 428
 429 **/
 430 EFI_STATUS
 431 EFIAPI
 432 DriverCallback(
 433   CONST EFI_HII_CONFIG_ACCESS_PROTOCOL    *This,
 434   EFI_BROWSER_ACTION                      Action,
 435   EFI_QUESTION_ID                         QuestionId,
 436   UINT8                                   Type,
 437   EFI_IFR_TYPE_VALUE                      *Value,
 438   EFI_BROWSER_ACTION_REQUEST              *ActionRequest
 439   )
 440 {
 441   HII_KEY    HiiKey;
 442   UINT8      HiiKeyId;
 443   UINT32     PpRequest;
 444
 445   if (ActionRequest != NULL) {
 446     *ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
 447   } else {
 448     return EFI_INVALID_PARAMETER;
 449   }
 450
 451   //
 452   // If QuestionId is an auto-generated key (label, empty line, etc.), ignore it.
 453   //
 454   if ((QuestionId & HII_KEY_FLAG) == 0) {
 455     return EFI_SUCCESS;
 456   }
 457
 458   HiiKey.Raw = QuestionId;
 459   HiiKeyId   = (UINT8) HiiKey.KeyBits.Id;
 460
 461   if (Action == EFI_BROWSER_ACTION_FORM_OPEN) {
 462     switch (HiiKeyId) {
 463       case HII_KEY_ID_VAR_SUPPORTED_DISKS:
 464         DEBUG ((DEBUG_INFO,  "HII_KEY_ID_VAR_SUPPORTED_DISKS\n"));
 465         return HiiPopulateMainMenuForm ();
 466
 467       case HII_KEY_ID_VAR_SELECTED_DISK_AVAILABLE_ACTIONS:
 468         return HiiPopulateDiskInfoForm();
 469     }
 470   } else if (Action == EFI_BROWSER_ACTION_CHANGING) {
 471     switch (HiiKeyId) {
 472       case HII_KEY_ID_GOTO_DISK_INFO:
 473         return HiiSelectDisk((UINT8)HiiKey.KeyBits.Index);
 474
 475       case HII_KEY_ID_GOTO_LOCK:
 476         return HiiSelectDiskAction("Action: Lock", HiiKeyId);
 477
 478       case HII_KEY_ID_GOTO_UNLOCK:
 479         return HiiSelectDiskAction("Action: Unlock", HiiKeyId);
 480
 481       case HII_KEY_ID_GOTO_SET_ADMIN_PWD:
 482         return HiiSelectDiskAction("Action: Set Administrator Password", HiiKeyId);
 483
 484       case HII_KEY_ID_GOTO_SET_USER_PWD:
 485         return HiiSelectDiskAction("Action: Set User Password", HiiKeyId);
 486
 487       case HII_KEY_ID_GOTO_SECURE_ERASE:
 488         return HiiSelectDiskAction("Action: Secure Erase", HiiKeyId);
 489
 490       case HII_KEY_ID_GOTO_PSID_REVERT:
 491         return HiiSelectDiskAction("Action: Revert to Factory Defaults with PSID", HiiKeyId);
 492
 493       case HII_KEY_ID_GOTO_REVERT:
 494         return HiiSelectDiskAction("Action: Revert to Factory Defaults", HiiKeyId);
 495
 496       case HII_KEY_ID_GOTO_DISABLE_USER:
 497         return HiiSelectDiskAction("Action: Disable User", HiiKeyId);
 498
 499       case HII_KEY_ID_GOTO_ENABLE_FEATURE:
 500         return HiiSelectDiskAction("Action: Enable Feature", HiiKeyId);
 501
 502       case HII_KEY_ID_ENTER_PASSWORD:
 503         return HiiPasswordEntered(Value->string);
 504     }
 505   } else if (Action == EFI_BROWSER_ACTION_CHANGED) {
 506     switch (HiiKeyId) {
 507       case HII_KEY_ID_ENTER_PSID:
 508         HiiPsidRevert();
 509         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;
 510         return EFI_SUCCESS;
 511
 512       case HII_KEY_ID_BLOCKSID:
 513         switch (Value->u8) {
 514           case 0:
 515             PpRequest = TCG2_PHYSICAL_PRESENCE_NO_ACTION;
 516             break;
 517
 518           case 1:
 519             PpRequest = TCG2_PHYSICAL_PRESENCE_ENABLE_BLOCK_SID;
 520             break;
 521
 522           case 2:
 523             PpRequest = TCG2_PHYSICAL_PRESENCE_DISABLE_BLOCK_SID;
 524             break;
 525
 526           case 3:
 527             PpRequest = TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_TRUE;
 528             break;
 529
 530           case 4:
 531             PpRequest = TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_FALSE;
 532             break;
 533
 534           case 5:
 535             PpRequest = TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_TRUE;
 536             break;
 537
 538           case 6:
 539             PpRequest = TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_FALSE;
 540             break;
 541
 542           default:
 543             PpRequest = TCG2_PHYSICAL_PRESENCE_NO_ACTION;
 544             DEBUG ((DEBUG_ERROR, "Invalid value input!\n"));
 545             break;
 546         }
 547         HiiSetBlockSidAction(PpRequest);
 548
 549         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;
 550         return EFI_SUCCESS;
 551
 552       default:
 553         break;
 554     }
 555   }
 556
 557   return EFI_UNSUPPORTED;
 558 }
 559
 560 /**
 561   Update the global Disk index info.
 562
 563   @param   Index             The input disk index info.
 564
 565   @retval  EFI_SUCCESS       Update the disk index info success.
 566
 567 **/
 568 EFI_STATUS
 569 HiiSelectDisk(
 570   UINT8 Index
 571   )
 572 {
 573   OpalHiiGetBrowserData();
 574   gHiiConfiguration.SelectedDiskIndex = Index;
 575   OpalHiiSetBrowserData ();
 576
 577   return EFI_SUCCESS;
 578 }
 579
 580 /**
 581   Draws the disk info form.
 582
 583   @retval  EFI_SUCCESS       Draw the disk info success.
 584
 585 **/
 586 EFI_STATUS
 587 HiiPopulateDiskInfoForm(
 588   VOID
 589   )
 590 {
 591   OPAL_DISK*                    OpalDisk;
 592   OPAL_DISK_ACTIONS             AvailActions;
 593   TCG_RESULT                    Ret;
 594   CHAR8                         *DiskName;
 595
 596   OpalHiiGetBrowserData();
 597
 598   DiskName = HiiDiskGetNameCB (gHiiConfiguration.SelectedDiskIndex);
 599   if (DiskName == NULL) {
 600     return EFI_UNSUPPORTED;
 601   }
 602   HiiSetFormString(STRING_TOKEN(STR_DISK_INFO_SELECTED_DISK_NAME), DiskName);
 603
 604   ZeroMem(gHiiConfiguration.Psid, sizeof(gHiiConfiguration.Psid));
 605
 606   gHiiConfiguration.SelectedDiskAvailableActions = HII_ACTION_NONE;
 607
 608   OpalDisk = HiiGetOpalDiskCB(gHiiConfiguration.SelectedDiskIndex);
 609
 610   if (OpalDisk != NULL) {
 611     OpalDiskUpdateStatus (OpalDisk);
 612     Ret = OpalSupportGetAvailableActions(&OpalDisk->SupportedAttributes, &OpalDisk->LockingFeature, OpalDisk->Owner, &AvailActions);
 613     if (Ret == TcgResultSuccess) {
 614       //
 615       // Update actions, always allow PSID Revert
 616       //
 617       gHiiConfiguration.SelectedDiskAvailableActions |= (AvailActions.PsidRevert == 1) ? HII_ACTION_PSID_REVERT : HII_ACTION_NONE;
 618
 619       //
 620       // Always allow unlock to handle device migration
 621       //
 622       gHiiConfiguration.SelectedDiskAvailableActions |= (AvailActions.Unlock == 1) ? HII_ACTION_UNLOCK : HII_ACTION_NONE;
 623
 624       if (!OpalFeatureEnabled (&OpalDisk->SupportedAttributes, &OpalDisk->LockingFeature)) {
 625         if (OpalDisk->Owner == OpalOwnershipNobody) {
 626           gHiiConfiguration.SelectedDiskAvailableActions |= HII_ACTION_ENABLE_FEATURE;
 627
 628           //
 629           // Update strings
 630           //
 631           HiiSetFormString( STRING_TOKEN(STR_DISK_INFO_PSID_REVERT), "PSID Revert to factory default");
 632         } else {
 633           DEBUG ((DEBUG_INFO, "Feature disabled but ownership != nobody\n"));
 634         }
 635       } else {
 636         gHiiConfiguration.SelectedDiskAvailableActions |= (AvailActions.Revert == 1) ? HII_ACTION_REVERT : HII_ACTION_NONE;
 637         gHiiConfiguration.SelectedDiskAvailableActions |= (AvailActions.AdminPass == 1) ? HII_ACTION_SET_ADMIN_PWD : HII_ACTION_NONE;
 638         gHiiConfiguration.SelectedDiskAvailableActions |= (AvailActions.UserPass == 1) ? HII_ACTION_SET_USER_PWD : HII_ACTION_NONE;
 639         gHiiConfiguration.SelectedDiskAvailableActions |= (AvailActions.SecureErase == 1) ? HII_ACTION_SECURE_ERASE : HII_ACTION_NONE;
 640         gHiiConfiguration.SelectedDiskAvailableActions |= (AvailActions.DisableUser == 1) ? HII_ACTION_DISABLE_USER : HII_ACTION_NONE;
 641
 642         HiiSetFormString (STRING_TOKEN(STR_DISK_INFO_PSID_REVERT), "PSID Revert to factory default and Disable");
 643
 644         //
 645         // Determine revert options for disk
 646         // Default initialize keep user Data to be true
 647         //
 648         gHiiConfiguration.KeepUserData = 1;
 649       }
 650     }
 651   }
 652
 653   //
 654   // Pass the current configuration to the BIOS
 655   //
 656   OpalHiiSetBrowserData ();
 657
 658   return EFI_SUCCESS;
 659 }
 660
 661 /**
 662   Reverts the Opal disk to factory default.
 663
 664   @retval  EFI_SUCCESS       Do the required action success.
 665
 666 **/
 667 EFI_STATUS
 668 HiiPsidRevert(
 669   VOID
 670   )
 671 {
 672   CHAR8                         Response[DEFAULT_RESPONSE_SIZE];
 673   TCG_PSID                      Psid;
 674   OPAL_DISK                     *OpalDisk;
 675   TCG_RESULT                    Ret;
 676   OPAL_SESSION                  Session;
 677   UINT8                         TmpBuf[PSID_CHARACTER_STRING_END_LENGTH];
 678
 679   Ret = TcgResultFailure;
 680
 681   OpalHiiGetBrowserData();
 682
 683   ZeroMem (TmpBuf, sizeof (TmpBuf));
 684   UnicodeStrToAsciiStrS (gHiiConfiguration.Psid, (CHAR8*)TmpBuf, PSID_CHARACTER_STRING_END_LENGTH);
 685   CopyMem (Psid.Psid, TmpBuf, PSID_CHARACTER_LENGTH);
 686
 687   OpalDisk = HiiGetOpalDiskCB (gHiiConfiguration.SelectedDiskIndex);
 688   if (OpalDisk != NULL) {
 689     ZeroMem(&Session, sizeof(Session));
 690     Session.Sscp = OpalDisk->Sscp;
 691     Session.MediaId = OpalDisk->MediaId;
 692     Session.OpalBaseComId = OpalDisk->OpalBaseComId;
 693
 694     Ret = OpalSupportPsidRevert(&Session, Psid.Psid, (UINT32)sizeof(Psid.Psid), OpalDisk->OpalDevicePath);
 695   }
 696
 697   if (Ret == TcgResultSuccess) {
 698     AsciiSPrint( Response, DEFAULT_RESPONSE_SIZE, "%a", "PSID Revert: Success" );
 699   } else {
 700     AsciiSPrint( Response, DEFAULT_RESPONSE_SIZE, "%a", "PSID Revert: Failure" );
 701   }
 702
 703   HiiSetFormString(STRING_TOKEN(STR_ACTION_STATUS), Response);
 704
 705   return EFI_SUCCESS;
 706 }
 707
 708 /**
 709   Set password for the disk.
 710
 711   @param      OpalDisk       The disk need to set the password.
 712   @param      Password       The input password.
 713   @param      PassLength     The input password length.
 714
 715   @retval  EFI_SUCCESS       Do the required action success.
 716
 717 **/
 718 EFI_STATUS
 719 HiiSetPassword(
 720   OPAL_DISK          *OpalDisk,
 721   VOID               *Password,
 722   UINT32             PassLength
 723   )
 724 {
 725   CHAR8                         Response[DEFAULT_RESPONSE_SIZE];
 726   TCG_RESULT                    Ret;
 727   BOOLEAN                       ExistingPassword;
 728   OPAL_SESSION                  Session;
 729
 730   ExistingPassword = FALSE;
 731
 732   //
 733   // PassLength = 0 means check whether exist old password.
 734   //
 735   if (PassLength == 0) {
 736     ZeroMem(gHiiOldPassword, sizeof(gHiiOldPassword));
 737     gHiiOldPasswordLength = 0;
 738
 739     if (gHiiConfiguration.SelectedAction == HII_KEY_ID_GOTO_ENABLE_FEATURE) {
 740       ExistingPassword = FALSE;
 741     } else if (gHiiConfiguration.SelectedAction == HII_KEY_ID_GOTO_SET_ADMIN_PWD) {
 742       ExistingPassword = OpalUtilAdminPasswordExists(OpalDisk->Owner, &OpalDisk->LockingFeature);
 743     } else if (gHiiConfiguration.SelectedAction == HII_KEY_ID_GOTO_SET_USER_PWD) {
 744       //
 745       // Set user Password option shall only be shown if an Admin Password exists
 746       // so a Password is always required (Admin or Existing User Password)
 747       //
 748       ExistingPassword = TRUE;
 749     }
 750
 751     //
 752     // Return error if there is a previous Password
 753     // see UEFI 2.4 errata B, Figure 121. Password Flowchart
 754     //
 755     return ExistingPassword ? EFI_DEVICE_ERROR : EFI_SUCCESS;
 756   }
 757
 758   ZeroMem(&Session, sizeof(Session));
 759   Session.Sscp = OpalDisk->Sscp;
 760   Session.MediaId = OpalDisk->MediaId;
 761   Session.OpalBaseComId = OpalDisk->OpalBaseComId;
 762
 763   AsciiSPrint(Response, DEFAULT_RESPONSE_SIZE, "%a", "Set Password: Failure");
 764   //
 765   // Password entered.
 766   // No current Owner, so set new Password, must be admin Password
 767   //
 768   if (OpalDisk->Owner == OpalOwnershipNobody) {
 769     Ret = OpalSupportEnableOpalFeature (&Session, OpalDisk->Msid, OpalDisk->MsidLength,Password, PassLength, OpalDisk->OpalDevicePath);
 770     if (Ret == TcgResultSuccess) {
 771       AsciiSPrint(Response, DEFAULT_RESPONSE_SIZE, "%a", "Set Password: Success");
 772     }
 773
 774     HiiSetFormString(STRING_TOKEN(STR_ACTION_STATUS), Response);
 775     return EFI_SUCCESS;
 776   }
 777
 778   //
 779   // 1st Password entered
 780   //
 781   if (OpalDisk->Owner == OpalOwnershipUnknown && gHiiOldPasswordLength == 0) {
 782
 783     //
 784     // Unknown ownership - prompt for old Password, then new
 785     // old Password is not set yet - first time through
 786     // assume authority provided is admin1, overwritten if user1 authority works below
 787     //
 788     if (gHiiConfiguration.SelectedAction == HII_KEY_ID_GOTO_SET_USER_PWD) {
 789       //
 790       // First try to login as USER1 to Locking SP to see if we're simply updating its Password
 791       //
 792       Ret =  OpalUtilVerifyPassword (&Session, Password, PassLength, OPAL_LOCKING_SP_USER1_AUTHORITY);
 793       if (Ret == TcgResultSuccess) {
 794         //
 795         // User1 worked so authority 1 means user 1
 796         //
 797         CopyMem(gHiiOldPassword, Password, PassLength);
 798         gHiiOldPasswordLength = PassLength;
 799
 800         return EFI_SUCCESS;
 801       }
 802     }
 803
 804     //
 805     // Else try admin1 below
 806     //
 807     Ret =  OpalUtilVerifyPassword (&Session, Password, PassLength, OPAL_LOCKING_SP_ADMIN1_AUTHORITY);
 808     if (Ret == TcgResultSuccess) {
 809       CopyMem(gHiiOldPassword, Password, PassLength);
 810       gHiiOldPasswordLength = PassLength;
 811
 812       return EFI_SUCCESS;
 813     } else {
 814       DEBUG ((DEBUG_INFO, "start session with old PW failed - return EFI_NOT_READY - mistyped old PW\n"));
 815       HiiSetFormString(STRING_TOKEN(STR_ACTION_STATUS), "Authentication Failure");
 816
 817       ZeroMem(gHiiOldPassword, sizeof(gHiiOldPassword));
 818       gHiiOldPasswordLength = 0;
 819
 820       return EFI_NOT_READY;
 821     }
 822   }
 823
 824   //
 825   // New Password entered
 826   //
 827   if (gHiiConfiguration.SelectedAction == HII_KEY_ID_GOTO_SET_USER_PWD) {
 828     Ret = OpalSupportSetPassword(
 829                             &Session,
 830                             gHiiOldPassword,
 831                             gHiiOldPasswordLength,
 832                             Password,
 833                             PassLength,
 834                             OpalDisk->OpalDevicePath,
 835                             FALSE
 836                             );
 837   } else {
 838     Ret = OpalSupportSetPassword(
 839                             &Session,
 840                             gHiiOldPassword,
 841                             gHiiOldPasswordLength,
 842                             Password,
 843                             PassLength,
 844                             OpalDisk->OpalDevicePath,
 845                             TRUE
 846                             );
 847   }
 848
 849   if (Ret == TcgResultSuccess) {
 850     AsciiSPrint(Response, DEFAULT_RESPONSE_SIZE, "%a", "Set Password: Success");
 851   }
 852
 853   //
 854   // Reset old Password storage
 855   //
 856   ZeroMem(gHiiOldPassword, sizeof(gHiiOldPassword));
 857   gHiiOldPasswordLength = 0;
 858
 859   HiiSetFormString(STRING_TOKEN(STR_ACTION_STATUS), Response);
 860   return Ret == TcgResultSuccess ? EFI_SUCCESS : EFI_NOT_READY;
 861 }
 862
 863 /**
 864   Secure Erases Opal Disk.
 865
 866   @param      OpalDisk       The disk need to erase data.
 867   @param      Password       The input password.
 868   @param      PassLength     The input password length.
 869
 870   @retval  EFI_SUCCESS       Do the required action success.
 871
 872 **/
 873 EFI_STATUS
 874 HiiSecureErase(
 875   OPAL_DISK       *OpalDisk,
 876   const VOID      *Password,
 877   UINT32          PassLength
 878   )
 879 {
 880   CHAR8                        Response[DEFAULT_RESPONSE_SIZE];
 881   BOOLEAN                      PasswordFailed;
 882   TCG_RESULT                   Ret;
 883   OPAL_SESSION                 AdminSpSession;
 884
 885   if (PassLength == 0) {
 886     return EFI_DEVICE_ERROR; // return error to indicate there is an existing Password
 887   }
 888
 889   ZeroMem(&AdminSpSession, sizeof(AdminSpSession));
 890   AdminSpSession.Sscp = OpalDisk->Sscp;
 891   AdminSpSession.MediaId = OpalDisk->MediaId;
 892   AdminSpSession.OpalBaseComId = OpalDisk->OpalBaseComId;
 893
 894   Ret = OpalUtilSecureErase(&AdminSpSession, Password, PassLength, &PasswordFailed);
 895   if (Ret == TcgResultSuccess) {
 896     AsciiSPrint( Response, DEFAULT_RESPONSE_SIZE, "%a", "Secure Erase: Success" );
 897   } else {
 898     AsciiSPrint( Response, DEFAULT_RESPONSE_SIZE, "%a", "Secure Erase: Failure" );
 899   }
 900   HiiSetFormString(STRING_TOKEN(STR_ACTION_STATUS), Response);
 901
 902   //
 903   // If Password failed, return invalid passowrd
 904   //
 905   if (PasswordFailed) {
 906     DEBUG ((DEBUG_INFO, "returning EFI_NOT_READY to indicate Password was not correct\n"));
 907     return EFI_NOT_READY;
 908   }
 909
 910   //
 911   // Indicates Password was valid and is not changing to UEFI
 912   // Response string will indicate action error
 913   //
 914   return EFI_DEVICE_ERROR;
 915 }
 916
 917
 918 /**
 919   Disables User for Opal Disk.
 920
 921   @param      OpalDisk       The disk need to the action.
 922   @param      Password       The input password.
 923   @param      PassLength     The input password length.
 924
 925   @retval  EFI_SUCCESS       Do the required action success.
 926
 927 **/
 928 EFI_STATUS
 929 HiiDisableUser(
 930   OPAL_DISK      *OpalDisk,
 931   VOID           *Password,
 932   UINT32         PassLength
 933   )
 934 {
 935   CHAR8                        Response[ DEFAULT_RESPONSE_SIZE ];
 936   BOOLEAN                      PasswordFailed;
 937   TCG_RESULT                   Ret;
 938   OPAL_SESSION                 Session;
 939
 940   if (PassLength == 0) {
 941     return EFI_DEVICE_ERROR; // return error to indicate there is an existing Password
 942   }
 943
 944   ZeroMem(&Session, sizeof(Session));
 945   Session.Sscp = OpalDisk->Sscp;
 946   Session.MediaId = OpalDisk->MediaId;
 947   Session.OpalBaseComId = OpalDisk->OpalBaseComId;
 948
 949   Ret = OpalSupportDisableUser(&Session, Password, PassLength, &PasswordFailed, OpalDisk->OpalDevicePath);
 950   if (Ret == TcgResultSuccess) {
 951     AsciiSPrint( Response, DEFAULT_RESPONSE_SIZE, "%a", "Disable User: Success" );
 952   } else {
 953     AsciiSPrint( Response, DEFAULT_RESPONSE_SIZE, "%a", "Disable User: Failure" );
 954   }
 955   HiiSetFormString (STRING_TOKEN(STR_ACTION_STATUS), Response);
 956
 957   //
 958   // If Password failed, return invalid passowrd
 959   //
 960   if (PasswordFailed) {
 961     DEBUG ((DEBUG_INFO, "returning EFI_NOT_READY to indicate Password was not correct\n"));
 962     return EFI_NOT_READY;
 963   }
 964
 965   //
 966   // Indicates Password was valid and is not changing to UEFI
 967   // Response string will indicate action error
 968   //
 969   return EFI_DEVICE_ERROR;
 970 }
 971
 972 /**
 973   Revert Opal Disk as Admin1.
 974
 975   @param      OpalDisk       The disk need to the action.
 976   @param      Password       The input password.
 977   @param      PassLength     The input password length.
 978   @param      KeepUserData   Whether need to keey user data.
 979
 980   @retval  EFI_SUCCESS       Do the required action success.
 981
 982 **/
 983 EFI_STATUS
 984 HiiRevert(
 985   OPAL_DISK       *OpalDisk,
 986   VOID            *Password,
 987   UINT32          PassLength,
 988   BOOLEAN         KeepUserData
 989   )
 990 {
 991   CHAR8                         Response[ DEFAULT_RESPONSE_SIZE ];
 992   BOOLEAN                      PasswordFailed;
 993   TCG_RESULT                    Ret;
 994   OPAL_SESSION                  Session;
 995
 996   if (PassLength == 0) {
 997     DEBUG ((DEBUG_INFO, "Returning error to indicate there is an existing Password\n"));
 998     // return error to indicate there is an existing Password
 999     return EFI_DEVICE_ERROR;
1000   }
1001
1002   ZeroMem(&Session, sizeof(Session));
1003   Session.Sscp = OpalDisk->Sscp;
1004   Session.MediaId = OpalDisk->MediaId;
1005   Session.OpalBaseComId = OpalDisk->OpalBaseComId;
1006
1007   Ret = OpalSupportRevert(
1008                       &Session,
1009                       KeepUserData,
1010                       Password,
1011                       PassLength,
1012                       OpalDisk->Msid,
1013                       OpalDisk->MsidLength,
1014                       &PasswordFailed,
1015                       OpalDisk->OpalDevicePath
1016                       );
1017   if (Ret == TcgResultSuccess) {
1018     AsciiSPrint( Response, DEFAULT_RESPONSE_SIZE, "%a", "Revert: Success" );
1019   } else {
1020     AsciiSPrint( Response, DEFAULT_RESPONSE_SIZE, "%a", "Revert: Failure" );
1021   }
1022   HiiSetFormString(STRING_TOKEN(STR_ACTION_STATUS), Response);
1023
1024   //
1025   // If Password failed, return invalid passowrd
1026   //
1027   if (PasswordFailed) {
1028     DEBUG ((DEBUG_INFO, "returning EFI_NOT_READY to indicate Password was not correct\n"));
1029     return EFI_NOT_READY;
1030   }
1031
1032   //
1033   // Indicates Password was valid and is not changing to UEFI
1034   // Response string will indicate action error
1035   //
1036   return EFI_DEVICE_ERROR;
1037 }
1038
1039 /**
1040   Unlocks Opal Disk.
1041
1042   @param      OpalDisk       The disk need to the action.
1043   @param      Password       The input password.
1044   @param      PassLength     The input password length.
1045
1046   @retval  EFI_SUCCESS       Do the required action success.
1047
1048 **/
1049 EFI_STATUS
1050 HiiUnlock(
1051   OPAL_DISK         *OpalDisk,
1052   VOID              *Password,
1053   UINT32            PassLength
1054   )
1055 {
1056   CHAR8                         Response[DEFAULT_RESPONSE_SIZE];
1057   TCG_RESULT                    Ret;
1058   OPAL_SESSION                  Session;
1059
1060   if (PassLength == 0) {
1061     DEBUG ((DEBUG_INFO, "Returning error to indicate there is an existing Password\n"));
1062     return EFI_DEVICE_ERROR; // return error to indicate there is an existing Password
1063   }
1064
1065   ZeroMem(&Session, sizeof(Session));
1066   Session.Sscp = OpalDisk->Sscp;
1067   Session.MediaId = OpalDisk->MediaId;
1068   Session.OpalBaseComId = OpalDisk->OpalBaseComId;
1069
1070   Ret = OpalSupportUnlock(&Session, Password, PassLength, OpalDisk->OpalDevicePath);
1071   if (Ret == TcgResultSuccess) {
1072     AsciiSPrint( Response, DEFAULT_RESPONSE_SIZE, "%a", "Unlock: Success" );
1073   } else {
1074     AsciiSPrint( Response, DEFAULT_RESPONSE_SIZE, "%a", "Unlock: Failure" );
1075   }
1076
1077   HiiSetFormString(STRING_TOKEN(STR_ACTION_STATUS), Response);
1078
1079   if (Ret == TcgResultSuccess) {
1080     DEBUG ((DEBUG_INFO, "returning error to indicate Password was correct but is not changing\n"));
1081     return EFI_DEVICE_ERROR;
1082   } else {
1083     DEBUG ((DEBUG_INFO, "returning EFI_NOT_READY to indicate Password was not correct\n"));
1084     return EFI_NOT_READY;
1085   }
1086 }
1087
1088 /**
1089   Use the input password to do the specified action.
1090
1091   @param      Str            The input password saved in.
1092
1093   @retval  EFI_SUCCESS       Do the required action success.
1094   @retval  Others            Other error occur.
1095
1096 **/
1097 EFI_STATUS
1098 HiiPasswordEntered(
1099   EFI_STRING_ID            Str
1100   )
1101 {
1102   OPAL_DISK*                    OpalDisk;
1103   CHAR8                         Password[MAX_PASSWORD_CHARACTER_LENGTH + 1];
1104   CHAR16*                      UniStr;
1105   UINT32                       PassLength;
1106   EFI_STATUS                   Status;
1107
1108   OpalHiiGetBrowserData();
1109
1110   OpalDisk = HiiGetOpalDiskCB(gHiiConfiguration.SelectedDiskIndex);
1111   if (OpalDisk == NULL) {
1112     DEBUG ((DEBUG_INFO, "ERROR: disk %u not found\n", gHiiConfiguration.SelectedDiskIndex));
1113     return EFI_NOT_FOUND;
1114   }
1115
1116   if (Str == 0) {
1117     DEBUG ((DEBUG_INFO, "ERROR: str=NULL\n"));
1118     return EFI_INVALID_PARAMETER;
1119   }
1120
1121   ZeroMem(Password, sizeof(Password));
1122
1123   UniStr = HiiGetString(gHiiPackageListHandle, Str, NULL);
1124   if (UniStr == NULL) {
1125     return EFI_NOT_FOUND;
1126   }
1127   PassLength = (UINT32) StrLen (UniStr);
1128   if (PassLength >= sizeof(Password)) {
1129     HiiSetFormString(STRING_TOKEN(STR_ACTION_STATUS), "Password too long");
1130     gBS->FreePool(UniStr);
1131     return EFI_BUFFER_TOO_SMALL;
1132   }
1133
1134   UnicodeStrToAsciiStrS (UniStr, Password, sizeof (Password));
1135   gBS->FreePool(UniStr);
1136
1137   if (gHiiConfiguration.SelectedAction == HII_KEY_ID_GOTO_UNLOCK) {
1138     Status = HiiUnlock (OpalDisk, Password, PassLength);
1139   } else if (gHiiConfiguration.SelectedAction == HII_KEY_ID_GOTO_SECURE_ERASE) {
1140     Status = HiiSecureErase (OpalDisk, Password, PassLength);
1141   } else if (gHiiConfiguration.SelectedAction == HII_KEY_ID_GOTO_DISABLE_USER) {
1142     Status = HiiDisableUser (OpalDisk, Password, PassLength);
1143   } else if (gHiiConfiguration.SelectedAction == HII_KEY_ID_GOTO_REVERT) {
1144     if (OpalDisk->SupportedAttributes.PyriteSsc == 1 && OpalDisk->LockingFeature.MediaEncryption == 0) {
1145       //
1146       // For pyrite type device which also not supports media encryption, it not accept "Keep User Data" parameter.
1147       // So here hardcode a FALSE for this case.
1148       //
1149       Status = HiiRevert(OpalDisk, Password, PassLength, FALSE);
1150     } else {
1151       Status = HiiRevert(OpalDisk, Password, PassLength, gHiiConfiguration.KeepUserData);
1152     }
1153   } else {
1154     Status = HiiSetPassword(OpalDisk, Password, PassLength);
1155   }
1156
1157   OpalHiiSetBrowserData ();
1158
1159   return Status;
1160 }
1161
1162 /**
1163   Update block sid info.
1164
1165   @param      Enable         Enable/disable BlockSid.
1166
1167   @retval  EFI_SUCCESS       Do the required action success.
1168   @retval  Others            Other error occur.
1169
1170 **/
1171 EFI_STATUS
1172 HiiSetBlockSidAction (
1173   IN UINT32          PpRequest
1174   )
1175 {
1176   UINT32                           ReturnCode;
1177   EFI_STATUS                       Status;
1178
1179   //
1180   // Process TCG Physical Presence request just after trusted console is ready
1181   // Platform can connect trusted consoles and then call the below function.
1182   //
1183   ReturnCode = TcgPhysicalPresenceStorageLibSubmitRequestToPreOSFunction (PpRequest, 0);
1184   if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_SUCCESS) {
1185     Status = EFI_SUCCESS;
1186   } else if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_GENERAL_FAILURE) {
1187     Status = EFI_OUT_OF_RESOURCES;
1188   } else if (ReturnCode == TCG_PP_SUBMIT_REQUEST_TO_PREOS_NOT_IMPLEMENTED) {
1189     Status = EFI_UNSUPPORTED;
1190   } else {
1191     Status = EFI_DEVICE_ERROR;
1192   }
1193
1194   return Status;
1195 }
1196
1197 /**
1198   This function processes the results of changes in configuration.
1199
1200   @param  This                   Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1201   @param  Configuration          A null-terminated Unicode string in <ConfigResp>
1202                                  format.
1203   @param  Progress               A pointer to a string filled in with the offset of
1204                                  the most recent '&' before the first failing
1205                                  name/value pair (or the beginning of the string if
1206                                  the failure is in the first name/value pair) or
1207                                  the terminating NULL if all was successful.
1208
1209   @retval EFI_SUCCESS            The Results is processed successfully.
1210   @retval EFI_INVALID_PARAMETER  Configuration is NULL.
1211   @retval EFI_NOT_FOUND          Routing data doesn't match any storage in this
1212                                  driver.
1213
1214 **/
1215 EFI_STATUS
1216 EFIAPI
1217 RouteConfig(
1218   CONST EFI_HII_CONFIG_ACCESS_PROTOCOL    *This,
1219   CONST EFI_STRING                        Configuration,
1220   EFI_STRING                              *Progress
1221   )
1222 {
1223   if (Configuration == NULL || Progress == NULL) {
1224     return (EFI_INVALID_PARAMETER);
1225   }
1226
1227   *Progress = Configuration;
1228   if (!HiiIsConfigHdrMatch (Configuration, &gHiiSetupVariableGuid, OpalPasswordStorageName)) {
1229     return EFI_NOT_FOUND;
1230   }
1231
1232   *Progress = Configuration + StrLen (Configuration);
1233
1234   return EFI_SUCCESS;
1235 }
1236
1237 /**
1238   This function allows a caller to extract the current configuration for one
1239   or more named elements from the target driver.
1240
1241   @param  This                   Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1242   @param  Request                A null-terminated Unicode string in
1243                                  <ConfigRequest> format.
1244   @param  Progress               On return, points to a character in the Request
1245                                  string. Points to the string's null terminator if
1246                                  request was successful. Points to the most recent
1247                                  '&' before the first failing name/value pair (or
1248                                  the beginning of the string if the failure is in
1249                                  the first name/value pair) if the request was not
1250                                  successful.
1251   @param  Results                A null-terminated Unicode string in
1252                                  <ConfigAltResp> format which has all values filled
1253                                  in for the names in the Request string. String to
1254                                  be allocated by the called function.
1255
1256   @retval EFI_SUCCESS            The Results is filled with the requested values.
1257   @retval EFI_OUT_OF_RESOURCES   Not enough memory to store the results.
1258   @retval EFI_INVALID_PARAMETER  Request is illegal syntax, or unknown name.
1259   @retval EFI_NOT_FOUND          Routing data doesn't match any storage in this
1260                                  driver.
1261
1262 **/
1263 EFI_STATUS
1264 EFIAPI
1265 ExtractConfig(
1266   CONST EFI_HII_CONFIG_ACCESS_PROTOCOL    *This,
1267   CONST EFI_STRING                        Request,
1268   EFI_STRING                              *Progress,
1269   EFI_STRING                              *Results
1270   )
1271 {
1272   EFI_STATUS                              Status;
1273
1274   //
1275   // Check for valid parameters
1276   //
1277   if (Progress == NULL || Results == NULL) {
1278     return (EFI_INVALID_PARAMETER);
1279   }
1280
1281   *Progress = Request;
1282   if ((Request != NULL) &&
1283     !HiiIsConfigHdrMatch (Request, &gHiiSetupVariableGuid, OpalPasswordStorageName)) {
1284     return EFI_NOT_FOUND;
1285   }
1286
1287   //
1288   // Convert Buffer Data to <ConfigResp> by helper function BlockToConfig( )
1289   //
1290   Status = gHiiConfigRouting->BlockToConfig(
1291                gHiiConfigRouting,
1292                Request,
1293                (UINT8*)&gHiiConfiguration,
1294                sizeof(OPAL_HII_CONFIGURATION),
1295                Results,
1296                Progress
1297            );
1298
1299   return (Status);
1300 }
1301
1302
1303 /**
1304
1305   Pass the current system state to the bios via the hii_G_Configuration.
1306
1307 **/
1308 VOID
1309 OpalHiiSetBrowserData (
1310   VOID
1311   )
1312 {
1313   HiiSetBrowserData(
1314       &gHiiSetupVariableGuid,
1315       (CHAR16*)L"OpalHiiConfig",
1316       sizeof(gHiiConfiguration),
1317       (UINT8*)&gHiiConfiguration,
1318       NULL
1319   );
1320 }
1321
1322
1323 /**
1324
1325   Populate the hii_g_Configuraton with the browser Data.
1326
1327 **/
1328 VOID
1329 OpalHiiGetBrowserData (
1330   VOID
1331   )
1332 {
1333   HiiGetBrowserData(
1334       &gHiiSetupVariableGuid,
1335       (CHAR16*)L"OpalHiiConfig",
1336       sizeof(gHiiConfiguration),
1337       (UINT8*)&gHiiConfiguration
1338   );
1339 }
1340
1341 /**
1342   Set a string Value in a form.
1343
1344   @param      DestStringId   The stringid which need to update.
1345   @param      SrcAsciiStr    The string nned to update.
1346
1347   @retval  EFI_SUCCESS       Do the required action success.
1348   @retval  Others            Other error occur.
1349
1350 **/
1351 EFI_STATUS
1352 HiiSetFormString(
1353   EFI_STRING_ID       DestStringId,
1354   CHAR8               *SrcAsciiStr
1355   )
1356 {
1357   UINT32                    Len;
1358   UINT32                    UniSize;
1359   CHAR16*                   UniStr;
1360
1361   //
1362   // Determine the Length of the sting
1363   //
1364   Len = ( UINT32 )AsciiStrLen( SrcAsciiStr );
1365
1366   //
1367   // Allocate space for the unicode string, including terminator
1368   //
1369   UniSize = (Len + 1) * sizeof(CHAR16);
1370   UniStr = (CHAR16*)AllocateZeroPool(UniSize);
1371
1372   //
1373   // Copy into unicode string, then copy into string id
1374   //
1375   AsciiStrToUnicodeStrS ( SrcAsciiStr, UniStr, Len + 1);
1376
1377   //
1378   // Update the string in the form
1379   //
1380   if (HiiSetString(gHiiPackageListHandle, DestStringId, UniStr, NULL) == 0) {
1381     DEBUG ((DEBUG_INFO,  "HiiSetFormString( ) failed\n"));
1382     FreePool(UniStr);
1383     return (EFI_OUT_OF_RESOURCES);
1384   }
1385
1386   //
1387   // Free the memory
1388   //
1389   FreePool(UniStr);
1390
1391   return (EFI_SUCCESS);
1392 }
1393
1394 /**
1395   Initialize the Opal disk base on the hardware info get from device.
1396
1397   @param Dev                  The Opal device.
1398
1399   @retval EFI_SUCESS          Initialize the device success.
1400   @retval EFI_DEVICE_ERROR    Get info from device failed.
1401
1402 **/
1403 EFI_STATUS
1404 OpalDiskInitialize (
1405   IN OPAL_DRIVER_DEVICE          *Dev
1406   )
1407 {
1408   TCG_RESULT                  TcgResult;
1409   OPAL_SESSION                Session;
1410
1411   ZeroMem(&Dev->OpalDisk, sizeof(OPAL_DISK));
1412   Dev->OpalDisk.Sscp = Dev->Sscp;
1413   Dev->OpalDisk.MediaId = Dev->MediaId;
1414   Dev->OpalDisk.OpalDevicePath = Dev->OpalDevicePath;
1415
1416   ZeroMem(&Session, sizeof(Session));
1417   Session.Sscp = Dev->Sscp;
1418   Session.MediaId = Dev->MediaId;
1419
1420   TcgResult = OpalGetSupportedAttributesInfo (&Session, &Dev->OpalDisk.SupportedAttributes, &Dev->OpalDisk.OpalBaseComId);
1421   if (TcgResult != TcgResultSuccess) {
1422     return EFI_DEVICE_ERROR;
1423   }
1424   Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;
1425
1426   TcgResult = OpalUtilGetMsid (&Session, Dev->OpalDisk.Msid, OPAL_MSID_LENGHT, &Dev->OpalDisk.MsidLength);
1427   if (TcgResult != TcgResultSuccess) {
1428     return EFI_DEVICE_ERROR;
1429   }
1430
1431   return OpalDiskUpdateStatus (&Dev->OpalDisk);
1432 }
1433
1434 /**
1435   Update the device info.
1436
1437   @param OpalDisk                The Opal device.
1438
1439   @retval EFI_SUCESS             Initialize the device success.
1440   @retval EFI_DEVICE_ERROR       Get info from device failed.
1441   @retval EFI_INVALID_PARAMETER  Not get Msid info before get ownership info.
1442
1443 **/
1444 EFI_STATUS
1445 OpalDiskUpdateStatus (
1446   OPAL_DISK        *OpalDisk
1447   )
1448 {
1449   TCG_RESULT                  TcgResult;
1450   OPAL_SESSION                Session;
1451
1452   ZeroMem(&Session, sizeof(Session));
1453   Session.Sscp = OpalDisk->Sscp;
1454   Session.MediaId = OpalDisk->MediaId;
1455   Session.OpalBaseComId = OpalDisk->OpalBaseComId;
1456
1457   TcgResult = OpalGetLockingInfo(&Session, &OpalDisk->LockingFeature);
1458   if (TcgResult != TcgResultSuccess) {
1459     return EFI_DEVICE_ERROR;
1460   }
1461
1462   if (OpalDisk->MsidLength == 0) {
1463     return EFI_INVALID_PARAMETER;
1464   } else {
1465     //
1466     // Base on the Msid info to get the ownership, so Msid info must get first.
1467     //
1468     OpalDisk->Owner = OpalUtilDetermineOwnership(&Session, OpalDisk->Msid, OpalDisk->MsidLength);
1469   }
1470
1471   return EFI_SUCCESS;
1472 }
1473