SecurityPkg/TcgStorageOpalLib: Return AUTHORITY_LOCKED_OUT error.

[mirror_edk2.git] / SecurityPkg / Tcg / Opal / OpalPassword / OpalDriver.c

/** @file\r
  Entrypoint of Opal UEFI Driver and contains all the logic to\r
  register for new Opal device instances.\r
\r
Copyright (c) 2016 - 2018, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
// This UEFI driver consumes EFI_STORAGE_SECURITY_PROTOCOL instances and installs an\r
// HII GUI to manage Opal features if the device is Opal capable\r
// If the Opal device is being managed by the UEFI Driver, it shall provide a popup\r
// window during boot requesting a user password\r
\r
#include "OpalDriver.h"\r
#include "OpalHii.h"\r
\r
EFI_GUID mOpalDeviceAtaGuid = OPAL_DEVICE_ATA_GUID;\r
EFI_GUID mOpalDeviceNvmeGuid = OPAL_DEVICE_NVME_GUID;\r
\r
BOOLEAN                 mOpalEndOfDxe = FALSE;\r
OPAL_REQUEST_VARIABLE   *mOpalRequestVariable = NULL;\r
UINTN                   mOpalRequestVariableSize = 0;\r
CHAR16                  mPopUpString[100];\r
\r
typedef struct {\r
  UINT32                   Address;\r
  S3_BOOT_SCRIPT_LIB_WIDTH Width;\r
} OPAL_HC_PCI_REGISTER_SAVE;\r
\r
//\r
// To unlock the Intel SATA controller at S3 Resume, restored the following registers.\r
//\r
const OPAL_HC_PCI_REGISTER_SAVE mSataHcRegisterSaveTemplate[] = {\r
  {0x9,  S3BootScriptWidthUint8},\r
  {0x10, S3BootScriptWidthUint32},\r
  {0x14, S3BootScriptWidthUint32},\r
  {0x18, S3BootScriptWidthUint32},\r
  {0x1C, S3BootScriptWidthUint32},\r
  {0x20, S3BootScriptWidthUint32},\r
  {0x24, S3BootScriptWidthUint32},\r
  {0x3c, S3BootScriptWidthUint8},\r
  {0x3d, S3BootScriptWidthUint8},\r
  {0x40, S3BootScriptWidthUint16},\r
  {0x42, S3BootScriptWidthUint16},\r
  {0x92, S3BootScriptWidthUint16},\r
  {0x94, S3BootScriptWidthUint32},\r
  {0x9C, S3BootScriptWidthUint32},\r
  {0x4,  S3BootScriptWidthUint16},\r
};\r
\r
OPAL_DRIVER mOpalDriver;\r
\r
//\r
// Globals\r
//\r
EFI_DRIVER_BINDING_PROTOCOL gOpalDriverBinding = {\r
  OpalEfiDriverBindingSupported,\r
  OpalEfiDriverBindingStart,\r
  OpalEfiDriverBindingStop,\r
  0x1b,\r
  NULL,\r
  NULL\r
};\r
\r
/**\r
\r
  The function determines the available actions for the OPAL_DISK provided.\r
\r
  @param[in]   SupportedAttributes   The supported attributes for the device.\r
  @param[in]   LockingFeature        The locking status for the device.\r
  @param[in]   OwnerShip             The ownership for the device.\r
  @param[out]  AvalDiskActions       Pointer to fill-out with appropriate disk actions.\r
\r
**/\r
TCG_RESULT\r
EFIAPI\r
OpalSupportGetAvailableActions(\r
  IN  OPAL_DISK_SUPPORT_ATTRIBUTE      *SupportedAttributes,\r
  IN  TCG_LOCKING_FEATURE_DESCRIPTOR   *LockingFeature,\r
  IN  UINT16                           OwnerShip,\r
  OUT OPAL_DISK_ACTIONS                *AvalDiskActions\r
  )\r
{\r
  BOOLEAN ExistingPassword;\r
\r
  NULL_CHECK(AvalDiskActions);\r
\r
  AvalDiskActions->AdminPass = 1;\r
  AvalDiskActions->UserPass = 0;\r
  AvalDiskActions->DisableUser = 0;\r
  AvalDiskActions->Unlock = 0;\r
\r
  //\r
  // Revert is performed on locking sp, so only allow if locking sp is enabled\r
  //\r
  if (LockingFeature->LockingEnabled) {\r
    AvalDiskActions->Revert = 1;\r
  }\r
\r
  //\r
  // Psid revert is available for any device with media encryption support or pyrite 2.0 type support.\r
  //\r
  if (SupportedAttributes->PyriteSscV2 || SupportedAttributes->MediaEncryption) {\r
\r
    //\r
    // Only allow psid revert if media encryption is enabled or pyrite 2.0 type support..\r
    // Otherwise, someone who steals a disk can psid revert the disk and the user Data is still\r
    // intact and accessible\r
    //\r
    AvalDiskActions->PsidRevert = 1;\r
    AvalDiskActions->RevertKeepDataForced = 0;\r
\r
    //\r
    // Secure erase is performed by generating a new encryption key\r
    // this is only available if encryption is supported\r
    //\r
    AvalDiskActions->SecureErase = 1;\r
  } else {\r
    AvalDiskActions->PsidRevert = 0;\r
    AvalDiskActions->SecureErase = 0;\r
\r
    //\r
    // If no media encryption is supported, then a revert (using password) will not\r
    // erase the Data (since you can't generate a new encryption key)\r
    //\r
    AvalDiskActions->RevertKeepDataForced = 1;\r
  }\r
\r
  if (LockingFeature->Locked) {\r
    AvalDiskActions->Unlock = 1;\r
  } else {\r
    AvalDiskActions->Unlock = 0;\r
  }\r
\r
  //\r
  // Only allow user to set password if an admin password exists\r
  //\r
  ExistingPassword = OpalUtilAdminPasswordExists(OwnerShip, LockingFeature);\r
  AvalDiskActions->UserPass = ExistingPassword;\r
\r
  //\r
  // This will still show up even if there isn't a user, which is fine\r
  //\r
  AvalDiskActions->DisableUser = ExistingPassword;\r
\r
  return TcgResultSuccess;\r
}\r
\r
/**\r
  Enable Opal Feature for the input device.\r
\r
  @param[in]      Session            The opal session for the opal device.\r
  @param[in]      Msid               Msid\r
  @param[in]      MsidLength         Msid Length\r
  @param[in]      Password           Admin password\r
  @param[in]      PassLength         Length of password in bytes\r
\r
**/\r
TCG_RESULT\r
EFIAPI\r
OpalSupportEnableOpalFeature (\r
  IN OPAL_SESSION              *Session,\r
  IN VOID                      *Msid,\r
  IN UINT32                    MsidLength,\r
  IN VOID                      *Password,\r
  IN UINT32                    PassLength\r
  )\r
{\r
  TCG_RESULT   Ret;\r
\r
  NULL_CHECK(Session);\r
  NULL_CHECK(Msid);\r
  NULL_CHECK(Password);\r
\r
  Ret = OpalUtilSetAdminPasswordAsSid(\r
                          Session,\r
                          Msid,\r
                          MsidLength,\r
                          Password,\r
                          PassLength\r
                          );\r
  if (Ret == TcgResultSuccess) {\r
    //\r
    // Enable global locking range\r
    //\r
    Ret = OpalUtilSetOpalLockingRange(\r
                              Session,\r
                              Password,\r
                              PassLength,\r
                              OPAL_LOCKING_SP_LOCKING_GLOBALRANGE,\r
                              0,\r
                              0,\r
                              TRUE,\r
                              TRUE,\r
                              FALSE,\r
                              FALSE\r
                              );\r
  }\r
\r
  return Ret;\r
}\r
\r
/**\r
  Update password for the Opal disk.\r
\r
  @param[in, out] OpalDisk          The disk to update password.\r
  @param[in]      Password          The input password.\r
  @param[in]      PasswordLength    The input password length.\r
\r
**/\r
VOID\r
OpalSupportUpdatePassword (\r
  IN OUT OPAL_DISK      *OpalDisk,\r
  IN VOID               *Password,\r
  IN UINT32             PasswordLength\r
  )\r
{\r
  CopyMem (OpalDisk->Password, Password, PasswordLength);\r
  OpalDisk->PasswordLength = (UINT8) PasswordLength;\r
}\r
\r
/**\r
  Extract device info from the device path.\r
\r
  @param[in]  DevicePath        Device path info for the device.\r
  @param[out] DevInfoLength     Device information length needed.\r
  @param[out] DevInfo           Device information extracted.\r
\r
  @return Device type.\r
\r
**/\r
UINT8\r
ExtractDeviceInfoFromDevicePath (\r
  IN  EFI_DEVICE_PATH_PROTOCOL  *DevicePath,\r
  OUT UINT16                    *DevInfoLength,\r
  OUT OPAL_DEVICE_COMMON        *DevInfo OPTIONAL\r
  )\r
{\r
  EFI_DEVICE_PATH_PROTOCOL      *TmpDevPath;\r
  EFI_DEVICE_PATH_PROTOCOL      *TmpDevPath2;\r
  PCI_DEVICE_PATH               *PciDevPath;\r
  UINT8                         DeviceType;\r
  UINT8                         BusNum;\r
  OPAL_PCI_DEVICE               *PciDevice;\r
  OPAL_DEVICE_ATA               *DevInfoAta;\r
  OPAL_DEVICE_NVME              *DevInfoNvme;\r
  SATA_DEVICE_PATH              *SataDevPath;\r
  NVME_NAMESPACE_DEVICE_PATH    *NvmeDevPath;\r
\r
  ASSERT (DevicePath != NULL);\r
  ASSERT (DevInfoLength != NULL);\r
\r
  DeviceType = OPAL_DEVICE_TYPE_UNKNOWN;\r
  *DevInfoLength = 0;\r
\r
  TmpDevPath = DevicePath;\r
\r
  //\r
  // Get device type.\r
  //\r
  while (!IsDevicePathEnd (TmpDevPath)) {\r
    if (TmpDevPath->Type == MESSAGING_DEVICE_PATH && TmpDevPath->SubType == MSG_SATA_DP) {\r
      //\r
      // SATA\r
      //\r
      if (DevInfo != NULL) {\r
        SataDevPath = (SATA_DEVICE_PATH *) TmpDevPath;\r
        DevInfoAta = (OPAL_DEVICE_ATA *) DevInfo;\r
        DevInfoAta->Port = SataDevPath->HBAPortNumber;\r
        DevInfoAta->PortMultiplierPort = SataDevPath->PortMultiplierPortNumber;\r
      }\r
      DeviceType = OPAL_DEVICE_TYPE_ATA;\r
      *DevInfoLength = sizeof (OPAL_DEVICE_ATA);\r
      break;\r
    } else if (TmpDevPath->Type == MESSAGING_DEVICE_PATH && TmpDevPath->SubType == MSG_NVME_NAMESPACE_DP) {\r
      //\r
      // NVMe\r
      //\r
      if (DevInfo != NULL) {\r
        NvmeDevPath = (NVME_NAMESPACE_DEVICE_PATH *) TmpDevPath;\r
        DevInfoNvme = (OPAL_DEVICE_NVME *) DevInfo;\r
        DevInfoNvme->NvmeNamespaceId = NvmeDevPath->NamespaceId;\r
      }\r
      DeviceType = OPAL_DEVICE_TYPE_NVME;\r
      *DevInfoLength = sizeof (OPAL_DEVICE_NVME);\r
      break;\r
    }\r
    TmpDevPath = NextDevicePathNode (TmpDevPath);\r
  }\r
\r
  //\r
  // Get device info.\r
  //\r
  BusNum = 0;\r
  TmpDevPath = DevicePath;\r
  TmpDevPath2 = NextDevicePathNode (DevicePath);\r
  while (!IsDevicePathEnd (TmpDevPath2)) {\r
    if (TmpDevPath->Type == HARDWARE_DEVICE_PATH && TmpDevPath->SubType == HW_PCI_DP) {\r
      PciDevPath = (PCI_DEVICE_PATH *) TmpDevPath;\r
      if ((TmpDevPath2->Type == MESSAGING_DEVICE_PATH && TmpDevPath2->SubType == MSG_NVME_NAMESPACE_DP)||\r
          (TmpDevPath2->Type == MESSAGING_DEVICE_PATH && TmpDevPath2->SubType == MSG_SATA_DP)) {\r
        if (DevInfo != NULL) {\r
          PciDevice = &DevInfo->Device;\r
          PciDevice->Segment = 0;\r
          PciDevice->Bus = BusNum;\r
          PciDevice->Device = PciDevPath->Device;\r
          PciDevice->Function = PciDevPath->Function;\r
        }\r
      } else {\r
        if (DevInfo != NULL) {\r
          PciDevice = (OPAL_PCI_DEVICE *) ((UINTN) DevInfo + *DevInfoLength);\r
          PciDevice->Segment = 0;\r
          PciDevice->Bus = BusNum;\r
          PciDevice->Device = PciDevPath->Device;\r
          PciDevice->Function = PciDevPath->Function;\r
        }\r
        *DevInfoLength += sizeof (OPAL_PCI_DEVICE);\r
        if (TmpDevPath2->Type == HARDWARE_DEVICE_PATH && TmpDevPath2->SubType == HW_PCI_DP) {\r
          BusNum = PciRead8 (PCI_LIB_ADDRESS (BusNum, PciDevPath->Device, PciDevPath->Function, PCI_BRIDGE_SECONDARY_BUS_REGISTER_OFFSET));\r
        }\r
      }\r
    }\r
\r
    TmpDevPath  = NextDevicePathNode (TmpDevPath);\r
    TmpDevPath2 = NextDevicePathNode (TmpDevPath2);\r
  }\r
\r
  ASSERT (DeviceType != OPAL_DEVICE_TYPE_UNKNOWN);\r
  return DeviceType;\r
}\r
\r
/**\r
  Save boot script for ATA OPAL device.\r
\r
  @param[in] DevInfo    Pointer to ATA Opal device information.\r
\r
 **/\r
VOID\r
OpalDeviceAtaSaveBootScript (\r
  IN OPAL_DEVICE_ATA    *DevInfo\r
  )\r
{\r
  UINTN                         Bus;\r
  UINTN                         Device;\r
  UINTN                         Function;\r
  UINTN                         Index;\r
  EFI_STATUS                    Status;\r
  UINTN                         Offset;\r
  UINT64                        Address;\r
  S3_BOOT_SCRIPT_LIB_WIDTH      Width;\r
  UINT32                        Data;\r
  OPAL_HC_PCI_REGISTER_SAVE     *HcRegisterSaveListPtr;\r
  UINTN                         Count;\r
\r
  Data = 0;\r
\r
  Bus        = DevInfo->Device.Bus;\r
  Device     = DevInfo->Device.Device;\r
  Function   = DevInfo->Device.Function;\r
\r
  HcRegisterSaveListPtr = (OPAL_HC_PCI_REGISTER_SAVE *) mSataHcRegisterSaveTemplate;\r
  Count = sizeof (mSataHcRegisterSaveTemplate) / sizeof (OPAL_HC_PCI_REGISTER_SAVE);\r
\r
  for (Index = 0; Index < Count; Index++) {\r
    Offset  = HcRegisterSaveListPtr[Index].Address;\r
    Width   = HcRegisterSaveListPtr[Index].Width;\r
\r
    switch (Width) {\r
      case S3BootScriptWidthUint8:\r
        Data = (UINT32)PciRead8 (PCI_LIB_ADDRESS(Bus,Device,Function,Offset));\r
        break;\r
      case S3BootScriptWidthUint16:\r
        Data = (UINT32)PciRead16 (PCI_LIB_ADDRESS(Bus,Device,Function,Offset));\r
        break;\r
      case S3BootScriptWidthUint32:\r
        Data = PciRead32 (PCI_LIB_ADDRESS(Bus,Device,Function,Offset));\r
        break;\r
      default:\r
        ASSERT (FALSE);\r
        break;\r
    }\r
\r
    Address = S3_BOOT_SCRIPT_LIB_PCI_ADDRESS (Bus, Device, Function, Offset);\r
    Status  = S3BootScriptSavePciCfgWrite (Width, Address, 1, &Data);\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
}\r
\r
/**\r
  Build ATA OPAL device info and save them to LockBox.\r
\r
  @param[in] BarAddr    Bar address allocated.\r
\r
 **/\r
VOID\r
BuildOpalDeviceInfoAta (\r
  IN UINT32     BarAddr\r
  )\r
{\r
  EFI_STATUS            Status;\r
  UINT8                 DeviceType;\r
  OPAL_DEVICE_ATA       *DevInfoAta;\r
  OPAL_DEVICE_ATA       *TempDevInfoAta;\r
  UINTN                 DevInfoLengthAta;\r
  UINT16                DevInfoLength;\r
  OPAL_DRIVER_DEVICE    *TmpDev;\r
\r
  //\r
  // Build ATA OPAL device info and save them to LockBox.\r
  //\r
  DevInfoLengthAta = 0;\r
  TmpDev = mOpalDriver.DeviceList;\r
  while (TmpDev != NULL) {\r
    DeviceType = ExtractDeviceInfoFromDevicePath (\r
                   TmpDev->OpalDisk.OpalDevicePath,\r
                   &DevInfoLength,\r
                   NULL\r
                   );\r
    if (DeviceType == OPAL_DEVICE_TYPE_ATA) {\r
      DevInfoLengthAta += DevInfoLength;\r
    }\r
\r
    TmpDev = TmpDev->Next;\r
  }\r
\r
  if (DevInfoLengthAta == 0) {\r
    return;\r
  }\r
\r
  DevInfoAta = AllocateZeroPool (DevInfoLengthAta);\r
  ASSERT (DevInfoAta != NULL);\r
\r
  TempDevInfoAta = DevInfoAta;\r
  TmpDev = mOpalDriver.DeviceList;\r
  while (TmpDev != NULL) {\r
    DeviceType = ExtractDeviceInfoFromDevicePath (\r
                   TmpDev->OpalDisk.OpalDevicePath,\r
                   &DevInfoLength,\r
                   NULL\r
                   );\r
    if (DeviceType == OPAL_DEVICE_TYPE_ATA) {\r
      ExtractDeviceInfoFromDevicePath (\r
        TmpDev->OpalDisk.OpalDevicePath,\r
        &DevInfoLength,\r
        (OPAL_DEVICE_COMMON *) TempDevInfoAta\r
        );\r
      TempDevInfoAta->Length = DevInfoLength;\r
      TempDevInfoAta->OpalBaseComId = TmpDev->OpalDisk.OpalBaseComId;\r
      TempDevInfoAta->BarAddr = BarAddr;\r
      CopyMem (\r
        TempDevInfoAta->Password,\r
        TmpDev->OpalDisk.Password,\r
        TmpDev->OpalDisk.PasswordLength\r
        );\r
      TempDevInfoAta->PasswordLength = TmpDev->OpalDisk.PasswordLength;\r
      OpalDeviceAtaSaveBootScript (TempDevInfoAta);\r
      TempDevInfoAta = (OPAL_DEVICE_ATA *) ((UINTN) TempDevInfoAta + DevInfoLength);\r
    }\r
\r
    TmpDev = TmpDev->Next;\r
  }\r
\r
  Status = SaveLockBox (\r
             &mOpalDeviceAtaGuid,\r
             DevInfoAta,\r
             DevInfoLengthAta\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = SetLockBoxAttributes (\r
             &mOpalDeviceAtaGuid,\r
             LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  ZeroMem (DevInfoAta, DevInfoLengthAta);\r
  FreePool (DevInfoAta);\r
}\r
\r
/**\r
  Build NVMe OPAL device info and save them to LockBox.\r
\r
  @param[in] BarAddr    Bar address allocated.\r
\r
 **/\r
VOID\r
BuildOpalDeviceInfoNvme (\r
  IN UINT32     BarAddr\r
  )\r
{\r
  EFI_STATUS            Status;\r
  UINT8                 DeviceType;\r
  OPAL_DEVICE_NVME      *DevInfoNvme;\r
  OPAL_DEVICE_NVME      *TempDevInfoNvme;\r
  UINTN                 DevInfoLengthNvme;\r
  UINT16                DevInfoLength;\r
  OPAL_DRIVER_DEVICE    *TmpDev;\r
\r
  //\r
  // Build NVMe OPAL device info and save them to LockBox.\r
  //\r
  DevInfoLengthNvme = 0;\r
  TmpDev = mOpalDriver.DeviceList;\r
  while (TmpDev != NULL) {\r
    DeviceType = ExtractDeviceInfoFromDevicePath (\r
                   TmpDev->OpalDisk.OpalDevicePath,\r
                   &DevInfoLength,\r
                   NULL\r
                   );\r
    if (DeviceType == OPAL_DEVICE_TYPE_NVME) {\r
      DevInfoLengthNvme += DevInfoLength;\r
    }\r
\r
    TmpDev = TmpDev->Next;\r
  }\r
\r
  if (DevInfoLengthNvme == 0) {\r
    return;\r
  }\r
\r
  DevInfoNvme = AllocateZeroPool (DevInfoLengthNvme);\r
  ASSERT (DevInfoNvme != NULL);\r
\r
  TempDevInfoNvme = DevInfoNvme;\r
  TmpDev = mOpalDriver.DeviceList;\r
  while (TmpDev != NULL) {\r
    DeviceType = ExtractDeviceInfoFromDevicePath (\r
                   TmpDev->OpalDisk.OpalDevicePath,\r
                   &DevInfoLength,\r
                   NULL\r
                   );\r
    if (DeviceType == OPAL_DEVICE_TYPE_NVME) {\r
      ExtractDeviceInfoFromDevicePath (\r
        TmpDev->OpalDisk.OpalDevicePath,\r
        &DevInfoLength,\r
        (OPAL_DEVICE_COMMON *) TempDevInfoNvme\r
        );\r
      TempDevInfoNvme->Length = DevInfoLength;\r
      TempDevInfoNvme->OpalBaseComId = TmpDev->OpalDisk.OpalBaseComId;\r
      TempDevInfoNvme->BarAddr = BarAddr;\r
      CopyMem (\r
        TempDevInfoNvme->Password,\r
        TmpDev->OpalDisk.Password,\r
        TmpDev->OpalDisk.PasswordLength\r
        );\r
      TempDevInfoNvme->PasswordLength = TmpDev->OpalDisk.PasswordLength;\r
      TempDevInfoNvme = (OPAL_DEVICE_NVME *) ((UINTN) TempDevInfoNvme + DevInfoLength);\r
    }\r
\r
    TmpDev = TmpDev->Next;\r
  }\r
\r
  Status = SaveLockBox (\r
             &mOpalDeviceNvmeGuid,\r
             DevInfoNvme,\r
             DevInfoLengthNvme\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = SetLockBoxAttributes (\r
             &mOpalDeviceNvmeGuid,\r
             LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  ZeroMem (DevInfoNvme, DevInfoLengthNvme);\r
  FreePool (DevInfoNvme);\r
}\r
\r
/**\r
  Notification function of EFI_END_OF_DXE_EVENT_GROUP_GUID event group.\r
\r
  This is a notification function registered on EFI_END_OF_DXE_EVENT_GROUP_GUID event group.\r
\r
  @param  Event        Event whose notification function is being invoked.\r
  @param  Context      Pointer to the notification function's context.\r
\r
**/\r
VOID\r
EFIAPI\r
OpalEndOfDxeEventNotify (\r
  EFI_EVENT                               Event,\r
  VOID                                    *Context\r
  )\r
{\r
  EFI_STATUS            Status;\r
  EFI_PHYSICAL_ADDRESS  Address;\r
  UINT64                Length;\r
  OPAL_DRIVER_DEVICE    *TmpDev;\r
\r
  DEBUG ((DEBUG_INFO, "%a() - enter\n", __FUNCTION__));\r
\r
  mOpalEndOfDxe = TRUE;\r
\r
  if (mOpalRequestVariable != NULL) {\r
    //\r
    // Free the OPAL request variable buffer here\r
    // as the OPAL requests should have been processed.\r
    //\r
    FreePool (mOpalRequestVariable);\r
    mOpalRequestVariable = NULL;\r
    mOpalRequestVariableSize = 0;\r
  }\r
\r
  //\r
  // If no any device, return directly.\r
  //\r
  if (mOpalDriver.DeviceList == NULL) {\r
    gBS->CloseEvent (Event);\r
    return;\r
  }\r
\r
  //\r
  // Assume 64K size and alignment are enough.\r
  //\r
  Length = 0x10000;\r
  Address = 0xFFFFFFFF;\r
  Status = gDS->AllocateMemorySpace (\r
                  EfiGcdAllocateMaxAddressSearchBottomUp,\r
                  EfiGcdMemoryTypeMemoryMappedIo,\r
                  16,                             // 2^16: 64K Alignment\r
                  Length,\r
                  &Address,\r
                  gImageHandle,\r
                  NULL\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  BuildOpalDeviceInfoAta ((UINT32) Address);\r
  BuildOpalDeviceInfoNvme ((UINT32) Address);\r
\r
  //\r
  // Zero passsword.\r
  //\r
  TmpDev = mOpalDriver.DeviceList;\r
  while (TmpDev != NULL) {\r
    ZeroMem (TmpDev->OpalDisk.Password, TmpDev->OpalDisk.PasswordLength);\r
    TmpDev = TmpDev->Next;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "%a() - exit\n", __FUNCTION__));\r
\r
  gBS->CloseEvent (Event);\r
}\r
\r
/**\r
  Get Psid input from the popup window.\r
\r
  @param[in]  Dev           The device which need Psid to process Psid Revert\r
                            OPAL request.\r
  @param[in]  PopUpString   Pop up string.\r
  @param[in]  PopUpString2  Pop up string in line 2.\r
\r
  @param[out] PressEsc      Whether user escape function through Press ESC.\r
\r
  @retval Psid string if success. NULL if failed.\r
\r
**/\r
CHAR8 *\r
OpalDriverPopUpPsidInput (\r
  IN OPAL_DRIVER_DEVICE     *Dev,\r
  IN CHAR16                 *PopUpString,\r
  IN CHAR16                 *PopUpString2,\r
  OUT BOOLEAN               *PressEsc\r
  )\r
{\r
  EFI_INPUT_KEY             InputKey;\r
  UINTN                     InputLength;\r
  CHAR16                    Mask[PSID_CHARACTER_LENGTH + 1];\r
  CHAR16                    Unicode[PSID_CHARACTER_LENGTH + 1];\r
  CHAR8                     *Ascii;\r
\r
  ZeroMem(Unicode, sizeof(Unicode));\r
  ZeroMem(Mask, sizeof(Mask));\r
\r
  *PressEsc = FALSE;\r
\r
  gST->ConOut->ClearScreen(gST->ConOut);\r
\r
  InputLength = 0;\r
  while (TRUE) {\r
    Mask[InputLength] = L'_';\r
    if (PopUpString2 == NULL) {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &InputKey,\r
        PopUpString,\r
        L"---------------------",\r
        Mask,\r
        NULL\r
      );\r
    } else {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &InputKey,\r
        PopUpString,\r
        PopUpString2,\r
        L"---------------------",\r
        Mask,\r
        NULL\r
      );\r
    }\r
\r
    //\r
    // Check key.\r
    //\r
    if (InputKey.ScanCode == SCAN_NULL) {\r
      //\r
      // password finished\r
      //\r
      if (InputKey.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
        //\r
        // Add the null terminator.\r
        //\r
        Unicode[InputLength] = 0;\r
        Mask[InputLength] = 0;\r
        break;\r
      } else if ((InputKey.UnicodeChar == CHAR_NULL) ||\r
                 (InputKey.UnicodeChar == CHAR_TAB) ||\r
                 (InputKey.UnicodeChar == CHAR_LINEFEED)\r
                ) {\r
        continue;\r
      } else {\r
        //\r
        // delete last key entered\r
        //\r
        if (InputKey.UnicodeChar == CHAR_BACKSPACE) {\r
          if (InputLength > 0) {\r
            Unicode[InputLength] = 0;\r
            Mask[InputLength] = 0;\r
            InputLength--;\r
          }\r
        } else {\r
          //\r
          // add Next key entry\r
          //\r
          Unicode[InputLength] = InputKey.UnicodeChar;\r
          Mask[InputLength] = InputKey.UnicodeChar;\r
          InputLength++;\r
          if (InputLength == PSID_CHARACTER_LENGTH) {\r
            //\r
            // Add the null terminator.\r
            //\r
            Unicode[InputLength] = 0;\r
            Mask[InputLength] = 0;\r
            break;\r
          }\r
        }\r
      }\r
    }\r
\r
    //\r
    // exit on ESC\r
    //\r
    if (InputKey.ScanCode == SCAN_ESC) {\r
      *PressEsc = TRUE;\r
      break;\r
    }\r
  }\r
\r
  gST->ConOut->ClearScreen(gST->ConOut);\r
\r
  if (InputLength == 0 || InputKey.ScanCode == SCAN_ESC) {\r
    ZeroMem (Unicode, sizeof (Unicode));\r
    ZeroMem (Mask, sizeof (Mask));\r
    return NULL;\r
  }\r
\r
  Ascii = AllocateZeroPool (PSID_CHARACTER_LENGTH + 1);\r
  if (Ascii == NULL) {\r
    ZeroMem (Unicode, sizeof (Unicode));\r
    ZeroMem (Mask, sizeof (Mask));\r
    return NULL;\r
  }\r
\r
  UnicodeStrToAsciiStrS (Unicode, Ascii, PSID_CHARACTER_LENGTH + 1);\r
  ZeroMem (Unicode, sizeof (Unicode));\r
  ZeroMem (Mask, sizeof (Mask));\r
\r
  return Ascii;\r
}\r
\r
\r
/**\r
  Get password input from the popup window.\r
\r
  @param[in]  Dev           The device which need password to unlock or\r
                            process OPAL request.\r
  @param[in]  PopUpString1  Pop up string 1.\r
  @param[in]  PopUpString2  Pop up string 2.\r
  @param[out] PressEsc      Whether user escape function through Press ESC.\r
\r
  @retval Password string if success. NULL if failed.\r
\r
**/\r
CHAR8 *\r
OpalDriverPopUpPasswordInput (\r
  IN OPAL_DRIVER_DEVICE     *Dev,\r
  IN CHAR16                 *PopUpString1,\r
  IN CHAR16                 *PopUpString2,\r
  OUT BOOLEAN               *PressEsc\r
  )\r
{\r
  EFI_INPUT_KEY             InputKey;\r
  UINTN                     InputLength;\r
  CHAR16                    Mask[OPAL_MAX_PASSWORD_SIZE + 1];\r
  CHAR16                    Unicode[OPAL_MAX_PASSWORD_SIZE + 1];\r
  CHAR8                     *Ascii;\r
\r
  ZeroMem(Unicode, sizeof(Unicode));\r
  ZeroMem(Mask, sizeof(Mask));\r
\r
  *PressEsc = FALSE;\r
\r
  gST->ConOut->ClearScreen(gST->ConOut);\r
\r
  InputLength = 0;\r
  while (TRUE) {\r
    Mask[InputLength] = L'_';\r
    if (PopUpString2 == NULL) {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &InputKey,\r
        PopUpString1,\r
        L"---------------------",\r
        Mask,\r
        NULL\r
      );\r
    } else {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &InputKey,\r
        PopUpString1,\r
        PopUpString2,\r
        L"---------------------",\r
        Mask,\r
        NULL\r
      );\r
    }\r
\r
    //\r
    // Check key.\r
    //\r
    if (InputKey.ScanCode == SCAN_NULL) {\r
      //\r
      // password finished\r
      //\r
      if (InputKey.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
        //\r
        // Add the null terminator.\r
        //\r
        Unicode[InputLength] = 0;\r
        Mask[InputLength] = 0;\r
        break;\r
      } else if ((InputKey.UnicodeChar == CHAR_NULL) ||\r
                 (InputKey.UnicodeChar == CHAR_TAB) ||\r
                 (InputKey.UnicodeChar == CHAR_LINEFEED)\r
                ) {\r
        continue;\r
      } else {\r
        //\r
        // delete last key entered\r
        //\r
        if (InputKey.UnicodeChar == CHAR_BACKSPACE) {\r
          if (InputLength > 0) {\r
            Unicode[InputLength] = 0;\r
            Mask[InputLength] = 0;\r
            InputLength--;\r
          }\r
        } else {\r
          //\r
          // add Next key entry\r
          //\r
          Unicode[InputLength] = InputKey.UnicodeChar;\r
          Mask[InputLength] = L'*';\r
          InputLength++;\r
          if (InputLength == OPAL_MAX_PASSWORD_SIZE) {\r
            //\r
            // Add the null terminator.\r
            //\r
            Unicode[InputLength] = 0;\r
            Mask[InputLength] = 0;\r
            break;\r
          }\r
        }\r
      }\r
    }\r
\r
    //\r
    // exit on ESC\r
    //\r
    if (InputKey.ScanCode == SCAN_ESC) {\r
      *PressEsc = TRUE;\r
      break;\r
    }\r
  }\r
\r
  gST->ConOut->ClearScreen(gST->ConOut);\r
\r
  if (InputLength == 0 || InputKey.ScanCode == SCAN_ESC) {\r
    ZeroMem (Unicode, sizeof (Unicode));\r
    return NULL;\r
  }\r
\r
  Ascii = AllocateZeroPool (OPAL_MAX_PASSWORD_SIZE + 1);\r
  if (Ascii == NULL) {\r
    ZeroMem (Unicode, sizeof (Unicode));\r
    return NULL;\r
  }\r
\r
  UnicodeStrToAsciiStrS (Unicode, Ascii, OPAL_MAX_PASSWORD_SIZE + 1);\r
  ZeroMem (Unicode, sizeof (Unicode));\r
\r
  return Ascii;\r
}\r
\r
/**\r
  Get pop up string.\r
\r
  @param[in] Dev            The OPAL device.\r
  @param[in] RequestString  Request string.\r
\r
  @return Pop up string.\r
\r
**/\r
CHAR16 *\r
OpalGetPopUpString (\r
  IN OPAL_DRIVER_DEVICE *Dev,\r
  IN CHAR16             *RequestString\r
  )\r
{\r
  if (Dev->Name16 == NULL) {\r
    UnicodeSPrint (mPopUpString, sizeof (mPopUpString), L"%s Disk", RequestString);\r
  } else {\r
    UnicodeSPrint (mPopUpString, sizeof (mPopUpString), L"%s %s", RequestString, Dev->Name16);\r
  }\r
\r
  return mPopUpString;\r
}\r
\r
/**\r
  Check if disk is locked, show popup window and ask for password if it is.\r
\r
  @param[in] Dev            The device which need to be unlocked.\r
  @param[in] RequestString  Request string.\r
\r
**/\r
VOID\r
OpalDriverRequestPassword (\r
  IN OPAL_DRIVER_DEVICE *Dev,\r
  IN CHAR16             *RequestString\r
  )\r
{\r
  UINT8                 Count;\r
  BOOLEAN               IsEnabled;\r
  BOOLEAN               IsLocked;\r
  CHAR8                 *Password;\r
  UINT32                PasswordLen;\r
  OPAL_SESSION          Session;\r
  BOOLEAN               PressEsc;\r
  EFI_INPUT_KEY         Key;\r
  TCG_RESULT            Ret;\r
  CHAR16                *PopUpString;\r
\r
  if (Dev == NULL) {\r
    return;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__));\r
\r
  PopUpString = OpalGetPopUpString (Dev, RequestString);\r
\r
  Count = 0;\r
\r
  IsEnabled = OpalFeatureEnabled (&Dev->OpalDisk.SupportedAttributes, &Dev->OpalDisk.LockingFeature);\r
  if (IsEnabled) {\r
    ZeroMem(&Session, sizeof(Session));\r
    Session.Sscp = Dev->OpalDisk.Sscp;\r
    Session.MediaId = Dev->OpalDisk.MediaId;\r
    Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
\r
    IsLocked = OpalDeviceLocked (&Dev->OpalDisk.SupportedAttributes, &Dev->OpalDisk.LockingFeature);\r
\r
    while (Count < MAX_PASSWORD_TRY_COUNT) {\r
      Password = OpalDriverPopUpPasswordInput (Dev, PopUpString, NULL, &PressEsc);\r
      if (PressEsc) {\r
        if (IsLocked) {\r
          //\r
          // Current device in the lock status and\r
          // User not input password and press ESC,\r
          // keep device in lock status and continue boot.\r
          //\r
          do {\r
            CreatePopUp (\r
              EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
              &Key,\r
              L"Press ENTER to skip the request and continue boot,",\r
              L"Press ESC to input password again",\r
              NULL\r
              );\r
          } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));\r
\r
          if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
            gST->ConOut->ClearScreen(gST->ConOut);\r
            //\r
            // Keep lock and continue boot.\r
            //\r
            return;\r
          } else {\r
            //\r
            // Let user input password again.\r
            //\r
            continue;\r
          }\r
        } else {\r
          //\r
          // Current device in the unlock status and\r
          // User not input password and press ESC,\r
          // Shutdown the device.\r
          //\r
          do {\r
            CreatePopUp (\r
              EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
              &Key,\r
              L"Press ENTER to shutdown, Press ESC to input password again",\r
              NULL\r
              );\r
          } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));\r
\r
          if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
            gRT->ResetSystem (EfiResetShutdown, EFI_SUCCESS, 0, NULL);\r
          } else {\r
            //\r
            // Let user input password again.\r
            //\r
            continue;\r
          }\r
        }\r
      }\r
\r
      if (Password == NULL) {\r
        Count ++;\r
        continue;\r
      }\r
      PasswordLen = (UINT32) AsciiStrLen(Password);\r
\r
      if (IsLocked) {\r
        Ret = OpalUtilUpdateGlobalLockingRange(&Session, Password, PasswordLen, FALSE, FALSE);\r
      } else {\r
        Ret = OpalUtilUpdateGlobalLockingRange(&Session, Password, PasswordLen, TRUE, TRUE);\r
        if (Ret == TcgResultSuccess) {\r
          Ret = OpalUtilUpdateGlobalLockingRange(&Session, Password, PasswordLen, FALSE, FALSE);\r
        }\r
      }\r
\r
      if (Ret == TcgResultSuccess) {\r
        OpalSupportUpdatePassword (&Dev->OpalDisk, Password, PasswordLen);\r
        DEBUG ((DEBUG_INFO, "%s Success\n", RequestString));\r
      } else {\r
        DEBUG ((DEBUG_INFO, "%s Failure\n", RequestString));\r
      }\r
\r
      if (Password != NULL) {\r
        ZeroMem (Password, PasswordLen);\r
        FreePool (Password);\r
      }\r
\r
      if (Ret == TcgResultSuccess) {\r
        break;\r
      }\r
\r
      Count++;\r
\r
      do {\r
        CreatePopUp (\r
          EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
          &Key,\r
          L"Invalid password.",\r
          L"Press ENTER to retry",\r
          NULL\r
          );\r
      } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
    }\r
\r
    if (Count >= MAX_PASSWORD_TRY_COUNT) {\r
      do {\r
        CreatePopUp (\r
          EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
          &Key,\r
          L"Opal password retry count exceeds the limit. Must shutdown!",\r
          L"Press ENTER to shutdown",\r
          NULL\r
          );\r
      } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
\r
      gRT->ResetSystem (EfiResetShutdown, EFI_SUCCESS, 0, NULL);\r
    }\r
  }\r
}\r
\r
/**\r
  Process Enable Feature OPAL request.\r
\r
  @param[in] Dev            The device which has Enable Feature OPAL request.\r
  @param[in] RequestString  Request string.\r
\r
**/\r
VOID\r
ProcessOpalRequestEnableFeature (\r
  IN OPAL_DRIVER_DEVICE *Dev,\r
  IN CHAR16             *RequestString\r
  )\r
{\r
  UINT8                 Count;\r
  CHAR8                 *Password;\r
  UINT32                PasswordLen;\r
  CHAR8                 *PasswordConfirm;\r
  UINT32                PasswordLenConfirm;\r
  OPAL_SESSION          Session;\r
  BOOLEAN               PressEsc;\r
  EFI_INPUT_KEY         Key;\r
  TCG_RESULT            Ret;\r
  CHAR16                *PopUpString;\r
\r
  if (Dev == NULL) {\r
    return;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__));\r
\r
  PopUpString = OpalGetPopUpString (Dev, RequestString);\r
\r
  Count = 0;\r
\r
  ZeroMem(&Session, sizeof(Session));\r
  Session.Sscp = Dev->OpalDisk.Sscp;\r
  Session.MediaId = Dev->OpalDisk.MediaId;\r
  Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
\r
  while (Count < MAX_PASSWORD_TRY_COUNT) {\r
    Password = OpalDriverPopUpPasswordInput (Dev, PopUpString, L"Please type in your new password", &PressEsc);\r
    if (PressEsc) {\r
        do {\r
          CreatePopUp (\r
            EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
            &Key,\r
            L"Press ENTER to skip the request and continue boot,",\r
            L"Press ESC to input password again",\r
            NULL\r
            );\r
        } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));\r
\r
        if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
          gST->ConOut->ClearScreen(gST->ConOut);\r
          return;\r
        } else {\r
          //\r
          // Let user input password again.\r
          //\r
          continue;\r
        }\r
    }\r
\r
    if (Password == NULL) {\r
      Count ++;\r
      continue;\r
    }\r
    PasswordLen = (UINT32) AsciiStrLen(Password);\r
\r
    PasswordConfirm = OpalDriverPopUpPasswordInput (Dev, PopUpString, L"Please confirm your new password", &PressEsc);\r
    if (PasswordConfirm == NULL) {\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
      Count ++;\r
      continue;\r
    }\r
    PasswordLenConfirm = (UINT32) AsciiStrLen(PasswordConfirm);\r
    if ((PasswordLen != PasswordLenConfirm) ||\r
        (CompareMem (Password, PasswordConfirm, PasswordLen) != 0)) {\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
      ZeroMem (PasswordConfirm, PasswordLenConfirm);\r
      FreePool (PasswordConfirm);\r
      do {\r
        CreatePopUp (\r
          EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
          &Key,\r
          L"Passwords are not the same.",\r
          L"Press ENTER to retry",\r
          NULL\r
          );\r
      } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
      Count ++;\r
      continue;\r
    }\r
\r
    if (PasswordConfirm != NULL) {\r
      ZeroMem (PasswordConfirm, PasswordLenConfirm);\r
      FreePool (PasswordConfirm);\r
    }\r
\r
    Ret = OpalSupportEnableOpalFeature (&Session, Dev->OpalDisk.Msid,  Dev->OpalDisk.MsidLength, Password, PasswordLen);\r
    if (Ret == TcgResultSuccess) {\r
      OpalSupportUpdatePassword (&Dev->OpalDisk, Password, PasswordLen);\r
      DEBUG ((DEBUG_INFO, "%s Success\n", RequestString));\r
    } else {\r
      DEBUG ((DEBUG_INFO, "%s Failure\n", RequestString));\r
    }\r
\r
    if (Password != NULL) {\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
    }\r
\r
    if (Ret == TcgResultSuccess) {\r
      break;\r
    }\r
\r
    Count++;\r
\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Request failed.",\r
        L"Press ENTER to retry",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
  }\r
\r
  if (Count >= MAX_PASSWORD_TRY_COUNT) {\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Opal password retry count exceeds the limit.",\r
        L"Press ENTER to skip the request and continue boot",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
    gST->ConOut->ClearScreen(gST->ConOut);\r
  }\r
}\r
\r
/**\r
  Process Disable User OPAL request.\r
\r
  @param[in] Dev            The device which has Disable User OPAL request.\r
  @param[in] RequestString  Request string.\r
\r
**/\r
VOID\r
ProcessOpalRequestDisableUser (\r
  IN OPAL_DRIVER_DEVICE *Dev,\r
  IN CHAR16             *RequestString\r
  )\r
{\r
  UINT8                 Count;\r
  CHAR8                 *Password;\r
  UINT32                PasswordLen;\r
  OPAL_SESSION          Session;\r
  BOOLEAN               PressEsc;\r
  EFI_INPUT_KEY         Key;\r
  TCG_RESULT            Ret;\r
  BOOLEAN               PasswordFailed;\r
  CHAR16                *PopUpString;\r
\r
  if (Dev == NULL) {\r
    return;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__));\r
\r
  PopUpString = OpalGetPopUpString (Dev, RequestString);\r
\r
  Count = 0;\r
\r
  ZeroMem(&Session, sizeof(Session));\r
  Session.Sscp = Dev->OpalDisk.Sscp;\r
  Session.MediaId = Dev->OpalDisk.MediaId;\r
  Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
\r
  while (Count < MAX_PASSWORD_TRY_COUNT) {\r
    Password = OpalDriverPopUpPasswordInput (Dev, PopUpString, NULL, &PressEsc);\r
    if (PressEsc) {\r
        do {\r
          CreatePopUp (\r
            EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
            &Key,\r
            L"Press ENTER to skip the request and continue boot,",\r
            L"Press ESC to input password again",\r
            NULL\r
            );\r
        } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));\r
\r
        if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
          gST->ConOut->ClearScreen(gST->ConOut);\r
          return;\r
        } else {\r
          //\r
          // Let user input password again.\r
          //\r
          continue;\r
        }\r
    }\r
\r
    if (Password == NULL) {\r
      Count ++;\r
      continue;\r
    }\r
    PasswordLen = (UINT32) AsciiStrLen(Password);\r
\r
    Ret = OpalUtilDisableUser(&Session, Password, PasswordLen, &PasswordFailed);\r
    if (Ret == TcgResultSuccess) {\r
      OpalSupportUpdatePassword (&Dev->OpalDisk, Password, PasswordLen);\r
      DEBUG ((DEBUG_INFO, "%s Success\n", RequestString));\r
    } else {\r
      DEBUG ((DEBUG_INFO, "%s Failure\n", RequestString));\r
    }\r
\r
    if (Password != NULL) {\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
    }\r
\r
    if (Ret == TcgResultSuccess) {\r
      break;\r
    }\r
\r
    Count++;\r
\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Invalid password, request failed.",\r
        L"Press ENTER to retry",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
  }\r
\r
  if (Count >= MAX_PASSWORD_TRY_COUNT) {\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Opal password retry count exceeds the limit.",\r
        L"Press ENTER to skip the request and continue boot",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
    gST->ConOut->ClearScreen(gST->ConOut);\r
  }\r
}\r
\r
/**\r
  Process Psid Revert OPAL request.\r
\r
  @param[in] Dev            The device which has Psid Revert OPAL request.\r
  @param[in] RequestString  Request string.\r
\r
**/\r
VOID\r
ProcessOpalRequestPsidRevert (\r
  IN OPAL_DRIVER_DEVICE *Dev,\r
  IN CHAR16             *RequestString\r
  )\r
{\r
  UINT8                 Count;\r
  CHAR8                 *Psid;\r
  UINT32                PsidLen;\r
  OPAL_SESSION          Session;\r
  BOOLEAN               PressEsc;\r
  EFI_INPUT_KEY         Key;\r
  TCG_RESULT            Ret;\r
  CHAR16                *PopUpString;\r
  CHAR16                *PopUpString2;\r
  UINTN                 BufferSize;\r
\r
  if (Dev == NULL) {\r
    return;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__));\r
\r
  PopUpString = OpalGetPopUpString (Dev, RequestString);\r
\r
  if (Dev->OpalDisk.EstimateTimeCost > MAX_ACCEPTABLE_REVERTING_TIME) {\r
    BufferSize = StrSize (L"Warning: Revert action will take about ####### seconds, DO NOT power off system during the revert action!");\r
    PopUpString2 = AllocateZeroPool (BufferSize);\r
    ASSERT (PopUpString2 != NULL);\r
    UnicodeSPrint (\r
        PopUpString2,\r
        BufferSize,\r
        L"WARNING: Revert action will take about %d seconds, DO NOT power off system during the revert action!",\r
        Dev->OpalDisk.EstimateTimeCost\r
      );\r
  } else {\r
    PopUpString2 = NULL;\r
  }\r
\r
  Count = 0;\r
\r
  ZeroMem(&Session, sizeof(Session));\r
  Session.Sscp = Dev->OpalDisk.Sscp;\r
  Session.MediaId = Dev->OpalDisk.MediaId;\r
  Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
\r
  while (Count < MAX_PSID_TRY_COUNT) {\r
    Psid = OpalDriverPopUpPsidInput (Dev, PopUpString, PopUpString2, &PressEsc);\r
    if (PressEsc) {\r
        do {\r
          CreatePopUp (\r
            EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
            &Key,\r
            L"Press ENTER to skip the request and continue boot,",\r
            L"Press ESC to input Psid again",\r
            NULL\r
            );\r
        } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));\r
\r
        if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
          gST->ConOut->ClearScreen(gST->ConOut);\r
          goto Done;\r
        } else {\r
          //\r
          // Let user input Psid again.\r
          //\r
          continue;\r
        }\r
    }\r
\r
    if (Psid == NULL) {\r
      Count ++;\r
      continue;\r
    }\r
    PsidLen = (UINT32) AsciiStrLen(Psid);\r
\r
    Ret = OpalUtilPsidRevert(&Session, Psid, PsidLen);\r
    if (Ret == TcgResultSuccess) {\r
      DEBUG ((DEBUG_INFO, "%s Success\n", RequestString));\r
    } else {\r
      DEBUG ((DEBUG_INFO, "%s Failure\n", RequestString));\r
    }\r
\r
    if (Psid != NULL) {\r
      ZeroMem (Psid, PsidLen);\r
      FreePool (Psid);\r
    }\r
\r
    if (Ret == TcgResultSuccess) {\r
      break;\r
    }\r
\r
    Count++;\r
\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Invalid Psid, request failed.",\r
        L"Press ENTER to retry",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
  }\r
\r
  if (Count >= MAX_PSID_TRY_COUNT) {\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Opal Psid retry count exceeds the limit.",\r
        L"Press ENTER to skip the request and continue boot",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
    gST->ConOut->ClearScreen(gST->ConOut);\r
  }\r
\r
Done:\r
  if (PopUpString2 != NULL) {\r
    FreePool (PopUpString2);\r
  }\r
}\r
\r
/**\r
  Process Admin Revert OPAL request.\r
\r
  @param[in] Dev            The device which has Revert OPAL request.\r
  @param[in] KeepUserData   Whether to keep user data or not.\r
  @param[in] RequestString  Request string.\r
\r
**/\r
VOID\r
ProcessOpalRequestRevert (\r
  IN OPAL_DRIVER_DEVICE *Dev,\r
  IN BOOLEAN            KeepUserData,\r
  IN CHAR16             *RequestString\r
  )\r
{\r
  UINT8                 Count;\r
  CHAR8                 *Password;\r
  UINT32                PasswordLen;\r
  OPAL_SESSION          Session;\r
  BOOLEAN               PressEsc;\r
  EFI_INPUT_KEY         Key;\r
  TCG_RESULT            Ret;\r
  BOOLEAN               PasswordFailed;\r
  CHAR16                *PopUpString;\r
  CHAR16                *PopUpString2;\r
  UINTN                 BufferSize;\r
\r
  if (Dev == NULL) {\r
    return;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__));\r
\r
  PopUpString = OpalGetPopUpString (Dev, RequestString);\r
\r
  if (Dev->OpalDisk.EstimateTimeCost > MAX_ACCEPTABLE_REVERTING_TIME) {\r
    BufferSize = StrSize (L"Warning: Revert action will take about ####### seconds, DO NOT power off system during the revert action!");\r
    PopUpString2 = AllocateZeroPool (BufferSize);\r
    ASSERT (PopUpString2 != NULL);\r
    UnicodeSPrint (\r
        PopUpString2,\r
        BufferSize,\r
        L"WARNING: Revert action will take about %d seconds, DO NOT power off system during the revert action!",\r
        Dev->OpalDisk.EstimateTimeCost\r
      );\r
  } else {\r
    PopUpString2 = NULL;\r
  }\r
\r
  Count = 0;\r
\r
  ZeroMem(&Session, sizeof(Session));\r
  Session.Sscp = Dev->OpalDisk.Sscp;\r
  Session.MediaId = Dev->OpalDisk.MediaId;\r
  Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
\r
  while (Count < MAX_PASSWORD_TRY_COUNT) {\r
    Password = OpalDriverPopUpPasswordInput (Dev, PopUpString, PopUpString2, &PressEsc);\r
    if (PressEsc) {\r
        do {\r
          CreatePopUp (\r
            EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
            &Key,\r
            L"Press ENTER to skip the request and continue boot,",\r
            L"Press ESC to input password again",\r
            NULL\r
            );\r
        } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));\r
\r
        if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
          gST->ConOut->ClearScreen(gST->ConOut);\r
          goto Done;\r
        } else {\r
          //\r
          // Let user input password again.\r
          //\r
          continue;\r
        }\r
    }\r
\r
    if (Password == NULL) {\r
      Count ++;\r
      continue;\r
    }\r
    PasswordLen = (UINT32) AsciiStrLen(Password);\r
\r
    if ((Dev->OpalDisk.SupportedAttributes.PyriteSsc == 1) &&\r
        (Dev->OpalDisk.LockingFeature.MediaEncryption == 0)) {\r
      //\r
      // For pyrite type device which does not support media encryption,\r
      // it does not accept "Keep User Data" parameter.\r
      // So here hardcode a FALSE for this case.\r
      //\r
      Ret = OpalUtilRevert(\r
              &Session,\r
              FALSE,\r
              Password,\r
              PasswordLen,\r
              &PasswordFailed,\r
              Dev->OpalDisk.Msid,\r
              Dev->OpalDisk.MsidLength\r
              );\r
    } else {\r
      Ret = OpalUtilRevert(\r
              &Session,\r
              KeepUserData,\r
              Password,\r
              PasswordLen,\r
              &PasswordFailed,\r
              Dev->OpalDisk.Msid,\r
              Dev->OpalDisk.MsidLength\r
              );\r
    }\r
    if (Ret == TcgResultSuccess) {\r
      OpalSupportUpdatePassword (&Dev->OpalDisk, Password, PasswordLen);\r
      DEBUG ((DEBUG_INFO, "%s Success\n", RequestString));\r
    } else {\r
      DEBUG ((DEBUG_INFO, "%s Failure\n", RequestString));\r
    }\r
\r
    if (Password != NULL) {\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
    }\r
\r
    if (Ret == TcgResultSuccess) {\r
      break;\r
    }\r
\r
    Count++;\r
\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Invalid password, request failed.",\r
        L"Press ENTER to retry",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
  }\r
\r
  if (Count >= MAX_PASSWORD_TRY_COUNT) {\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Opal password retry count exceeds the limit.",\r
        L"Press ENTER to skip the request and continue boot",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
    gST->ConOut->ClearScreen(gST->ConOut);\r
  }\r
\r
Done:\r
  if (PopUpString2 != NULL) {\r
    FreePool (PopUpString2);\r
  }\r
}\r
\r
/**\r
  Process Secure Erase OPAL request.\r
\r
  @param[in] Dev            The device which has Secure Erase OPAL request.\r
  @param[in] RequestString  Request string.\r
\r
**/\r
VOID\r
ProcessOpalRequestSecureErase (\r
  IN OPAL_DRIVER_DEVICE *Dev,\r
  IN CHAR16             *RequestString\r
  )\r
{\r
  UINT8                 Count;\r
  CHAR8                 *Password;\r
  UINT32                PasswordLen;\r
  OPAL_SESSION          Session;\r
  BOOLEAN               PressEsc;\r
  EFI_INPUT_KEY         Key;\r
  TCG_RESULT            Ret;\r
  BOOLEAN               PasswordFailed;\r
  CHAR16                *PopUpString;\r
\r
  if (Dev == NULL) {\r
    return;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__));\r
\r
  PopUpString = OpalGetPopUpString (Dev, RequestString);\r
\r
  Count = 0;\r
\r
  ZeroMem(&Session, sizeof(Session));\r
  Session.Sscp = Dev->OpalDisk.Sscp;\r
  Session.MediaId = Dev->OpalDisk.MediaId;\r
  Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
\r
  while (Count < MAX_PASSWORD_TRY_COUNT) {\r
    Password = OpalDriverPopUpPasswordInput (Dev, PopUpString, NULL, &PressEsc);\r
    if (PressEsc) {\r
        do {\r
          CreatePopUp (\r
            EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
            &Key,\r
            L"Press ENTER to skip the request and continue boot,",\r
            L"Press ESC to input password again",\r
            NULL\r
            );\r
        } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));\r
\r
        if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
          gST->ConOut->ClearScreen(gST->ConOut);\r
          return;\r
        } else {\r
          //\r
          // Let user input password again.\r
          //\r
          continue;\r
        }\r
    }\r
\r
    if (Password == NULL) {\r
      Count ++;\r
      continue;\r
    }\r
    PasswordLen = (UINT32) AsciiStrLen(Password);\r
\r
    Ret = OpalUtilSecureErase(&Session, Password, PasswordLen, &PasswordFailed);\r
    if (Ret == TcgResultSuccess) {\r
      OpalSupportUpdatePassword (&Dev->OpalDisk, Password, PasswordLen);\r
      DEBUG ((DEBUG_INFO, "%s Success\n", RequestString));\r
    } else {\r
      DEBUG ((DEBUG_INFO, "%s Failure\n", RequestString));\r
    }\r
\r
    if (Password != NULL) {\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
    }\r
\r
    if (Ret == TcgResultSuccess) {\r
      break;\r
    }\r
\r
    Count++;\r
\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Invalid password, request failed.",\r
        L"Press ENTER to retry",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
  }\r
\r
  if (Count >= MAX_PASSWORD_TRY_COUNT) {\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Opal password retry count exceeds the limit.",\r
        L"Press ENTER to skip the request and continue boot",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
    gST->ConOut->ClearScreen(gST->ConOut);\r
  }\r
}\r
\r
/**\r
  Process Set Admin Pwd OPAL request.\r
\r
  @param[in] Dev            The device which has Set Admin Pwd Feature OPAL request.\r
  @param[in] RequestString  Request string.\r
\r
**/\r
VOID\r
ProcessOpalRequestSetUserPwd (\r
  IN OPAL_DRIVER_DEVICE *Dev,\r
  IN CHAR16             *RequestString\r
  )\r
{\r
  UINT8                 Count;\r
  CHAR8                 *OldPassword;\r
  UINT32                OldPasswordLen;\r
  CHAR8                 *Password;\r
  UINT32                PasswordLen;\r
  CHAR8                 *PasswordConfirm;\r
  UINT32                PasswordLenConfirm;\r
  OPAL_SESSION          Session;\r
  BOOLEAN               PressEsc;\r
  EFI_INPUT_KEY         Key;\r
  TCG_RESULT            Ret;\r
  CHAR16                *PopUpString;\r
\r
  if (Dev == NULL) {\r
    return;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__));\r
\r
  PopUpString = OpalGetPopUpString (Dev, RequestString);\r
\r
  Count = 0;\r
\r
  while (Count < MAX_PASSWORD_TRY_COUNT) {\r
    OldPassword = OpalDriverPopUpPasswordInput (Dev, PopUpString, L"Please type in your password", &PressEsc);\r
    if (PressEsc) {\r
        do {\r
          CreatePopUp (\r
            EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
            &Key,\r
            L"Press ENTER to skip the request and continue boot,",\r
            L"Press ESC to input password again",\r
            NULL\r
            );\r
        } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));\r
\r
        if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
          gST->ConOut->ClearScreen(gST->ConOut);\r
          return;\r
        } else {\r
          //\r
          // Let user input password again.\r
          //\r
          continue;\r
        }\r
    }\r
\r
    if (OldPassword == NULL) {\r
      Count ++;\r
      continue;\r
    }\r
    OldPasswordLen = (UINT32) AsciiStrLen(OldPassword);\r
\r
    ZeroMem(&Session, sizeof(Session));\r
    Session.Sscp = Dev->OpalDisk.Sscp;\r
    Session.MediaId = Dev->OpalDisk.MediaId;\r
    Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
    Ret = OpalUtilVerifyPassword (&Session, OldPassword, OldPasswordLen, OPAL_LOCKING_SP_USER1_AUTHORITY);\r
    if (Ret == TcgResultSuccess) {\r
      DEBUG ((DEBUG_INFO, "Verify with USER1 authority : Success\n"));\r
    } else {\r
      Ret = OpalUtilVerifyPassword (&Session, OldPassword, OldPasswordLen, OPAL_LOCKING_SP_ADMIN1_AUTHORITY);\r
      if (Ret == TcgResultSuccess) {\r
        DEBUG ((DEBUG_INFO, "Verify with ADMIN1 authority: Success\n"));\r
      } else {\r
        ZeroMem (OldPassword, OldPasswordLen);\r
        FreePool (OldPassword);\r
        DEBUG ((DEBUG_INFO, "Verify: Failure\n"));\r
        do {\r
          CreatePopUp (\r
            EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
            &Key,\r
            L"Incorrect password.",\r
            L"Press ENTER to retry",\r
            NULL\r
            );\r
        } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
        Count ++;\r
        continue;\r
      }\r
    }\r
\r
    Password = OpalDriverPopUpPasswordInput (Dev, PopUpString, L"Please type in your new password", &PressEsc);\r
    if (Password == NULL) {\r
      ZeroMem (OldPassword, OldPasswordLen);\r
      FreePool (OldPassword);\r
      Count ++;\r
      continue;\r
    }\r
    PasswordLen = (UINT32) AsciiStrLen(Password);\r
\r
    PasswordConfirm = OpalDriverPopUpPasswordInput (Dev, PopUpString, L"Please confirm your new password", &PressEsc);\r
    if (PasswordConfirm == NULL) {\r
      ZeroMem (OldPassword, OldPasswordLen);\r
      FreePool (OldPassword);\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
      Count ++;\r
      continue;\r
    }\r
    PasswordLenConfirm = (UINT32) AsciiStrLen(PasswordConfirm);\r
    if ((PasswordLen != PasswordLenConfirm) ||\r
        (CompareMem (Password, PasswordConfirm, PasswordLen) != 0)) {\r
      ZeroMem (OldPassword, OldPasswordLen);\r
      FreePool (OldPassword);\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
      ZeroMem (PasswordConfirm, PasswordLenConfirm);\r
      FreePool (PasswordConfirm);\r
      do {\r
        CreatePopUp (\r
          EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
          &Key,\r
          L"Passwords are not the same.",\r
          L"Press ENTER to retry",\r
          NULL\r
          );\r
      } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
      Count ++;\r
      continue;\r
    }\r
\r
    if (PasswordConfirm != NULL) {\r
      ZeroMem (PasswordConfirm, PasswordLenConfirm);\r
      FreePool (PasswordConfirm);\r
    }\r
\r
    ZeroMem(&Session, sizeof(Session));\r
    Session.Sscp = Dev->OpalDisk.Sscp;\r
    Session.MediaId = Dev->OpalDisk.MediaId;\r
    Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
    Ret = OpalUtilSetUserPassword(\r
            &Session,\r
            OldPassword,\r
            OldPasswordLen,\r
            Password,\r
            PasswordLen\r
            );\r
    if (Ret == TcgResultSuccess) {\r
      OpalSupportUpdatePassword (&Dev->OpalDisk, Password, PasswordLen);\r
      DEBUG ((DEBUG_INFO, "%s Success\n", RequestString));\r
    } else {\r
      DEBUG ((DEBUG_INFO, "%s Failure\n", RequestString));\r
    }\r
\r
    if (OldPassword != NULL) {\r
      ZeroMem (OldPassword, OldPasswordLen);\r
      FreePool (OldPassword);\r
    }\r
\r
    if (Password != NULL) {\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
    }\r
\r
    if (Ret == TcgResultSuccess) {\r
      break;\r
    }\r
\r
    Count++;\r
\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Request failed.",\r
        L"Press ENTER to retry",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
  }\r
\r
  if (Count >= MAX_PASSWORD_TRY_COUNT) {\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Opal password retry count exceeds the limit.",\r
        L"Press ENTER to skip the request and continue boot",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
    gST->ConOut->ClearScreen(gST->ConOut);\r
  }\r
}\r
\r
/**\r
  Process Set Admin Pwd OPAL request.\r
\r
  @param[in] Dev            The device which has Set Admin Pwd Feature OPAL request.\r
  @param[in] RequestString  Request string.\r
\r
**/\r
VOID\r
ProcessOpalRequestSetAdminPwd (\r
  IN OPAL_DRIVER_DEVICE *Dev,\r
  IN CHAR16             *RequestString\r
  )\r
{\r
  UINT8                 Count;\r
  CHAR8                 *OldPassword;\r
  UINT32                OldPasswordLen;\r
  CHAR8                 *Password;\r
  UINT32                PasswordLen;\r
  CHAR8                 *PasswordConfirm;\r
  UINT32                PasswordLenConfirm;\r
  OPAL_SESSION          Session;\r
  BOOLEAN               PressEsc;\r
  EFI_INPUT_KEY         Key;\r
  TCG_RESULT            Ret;\r
  CHAR16                *PopUpString;\r
\r
  if (Dev == NULL) {\r
    return;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__));\r
\r
  PopUpString = OpalGetPopUpString (Dev, RequestString);\r
\r
  Count = 0;\r
\r
  while (Count < MAX_PASSWORD_TRY_COUNT) {\r
    OldPassword = OpalDriverPopUpPasswordInput (Dev, PopUpString, L"Please type in your password", &PressEsc);\r
    if (PressEsc) {\r
        do {\r
          CreatePopUp (\r
            EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
            &Key,\r
            L"Press ENTER to skip the request and continue boot,",\r
            L"Press ESC to input password again",\r
            NULL\r
            );\r
        } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));\r
\r
        if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
          gST->ConOut->ClearScreen(gST->ConOut);\r
          return;\r
        } else {\r
          //\r
          // Let user input password again.\r
          //\r
          continue;\r
        }\r
    }\r
\r
    if (OldPassword == NULL) {\r
      Count ++;\r
      continue;\r
    }\r
    OldPasswordLen = (UINT32) AsciiStrLen(OldPassword);\r
\r
    ZeroMem(&Session, sizeof(Session));\r
    Session.Sscp = Dev->OpalDisk.Sscp;\r
    Session.MediaId = Dev->OpalDisk.MediaId;\r
    Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
    Ret = OpalUtilVerifyPassword (&Session, OldPassword, OldPasswordLen, OPAL_LOCKING_SP_ADMIN1_AUTHORITY);\r
    if (Ret == TcgResultSuccess) {\r
      DEBUG ((DEBUG_INFO, "Verify: Success\n"));\r
    } else {\r
      ZeroMem (OldPassword, OldPasswordLen);\r
      FreePool (OldPassword);\r
      DEBUG ((DEBUG_INFO, "Verify: Failure\n"));\r
      do {\r
        CreatePopUp (\r
          EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
          &Key,\r
          L"Incorrect password.",\r
          L"Press ENTER to retry",\r
          NULL\r
          );\r
      } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
      Count ++;\r
      continue;\r
    }\r
\r
    Password = OpalDriverPopUpPasswordInput (Dev, PopUpString, L"Please type in your new password", &PressEsc);\r
    if (Password == NULL) {\r
      ZeroMem (OldPassword, OldPasswordLen);\r
      FreePool (OldPassword);\r
      Count ++;\r
      continue;\r
    }\r
    PasswordLen = (UINT32) AsciiStrLen(Password);\r
\r
    PasswordConfirm = OpalDriverPopUpPasswordInput (Dev, PopUpString, L"Please confirm your new password", &PressEsc);\r
    if (PasswordConfirm == NULL) {\r
      ZeroMem (OldPassword, OldPasswordLen);\r
      FreePool (OldPassword);\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
      Count ++;\r
      continue;\r
    }\r
    PasswordLenConfirm = (UINT32) AsciiStrLen(PasswordConfirm);\r
    if ((PasswordLen != PasswordLenConfirm) ||\r
        (CompareMem (Password, PasswordConfirm, PasswordLen) != 0)) {\r
      ZeroMem (OldPassword, OldPasswordLen);\r
      FreePool (OldPassword);\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
      ZeroMem (PasswordConfirm, PasswordLenConfirm);\r
      FreePool (PasswordConfirm);\r
      do {\r
        CreatePopUp (\r
          EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
          &Key,\r
          L"Passwords are not the same.",\r
          L"Press ENTER to retry",\r
          NULL\r
          );\r
      } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
      Count ++;\r
      continue;\r
    }\r
\r
    if (PasswordConfirm != NULL) {\r
      ZeroMem (PasswordConfirm, PasswordLenConfirm);\r
      FreePool (PasswordConfirm);\r
    }\r
\r
\r
    ZeroMem(&Session, sizeof(Session));\r
    Session.Sscp = Dev->OpalDisk.Sscp;\r
    Session.MediaId = Dev->OpalDisk.MediaId;\r
    Session.OpalBaseComId = Dev->OpalDisk.OpalBaseComId;\r
    Ret = OpalUtilSetAdminPassword(\r
            &Session,\r
            OldPassword,\r
            OldPasswordLen,\r
            Password,\r
            PasswordLen\r
            );\r
    if (Ret == TcgResultSuccess) {\r
      OpalSupportUpdatePassword (&Dev->OpalDisk, Password, PasswordLen);\r
      DEBUG ((DEBUG_INFO, "%s Success\n", RequestString));\r
    } else {\r
      DEBUG ((DEBUG_INFO, "%s Failure\n", RequestString));\r
    }\r
\r
    if (OldPassword != NULL) {\r
      ZeroMem (OldPassword, OldPasswordLen);\r
      FreePool (OldPassword);\r
    }\r
\r
    if (Password != NULL) {\r
      ZeroMem (Password, PasswordLen);\r
      FreePool (Password);\r
    }\r
\r
    if (Ret == TcgResultSuccess) {\r
      break;\r
    }\r
\r
    Count++;\r
\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Request failed.",\r
        L"Press ENTER to retry",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
  }\r
\r
  if (Count >= MAX_PASSWORD_TRY_COUNT) {\r
    do {\r
      CreatePopUp (\r
        EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
        &Key,\r
        L"Opal password retry count exceeds the limit.",\r
        L"Press ENTER to skip the request and continue boot",\r
        NULL\r
        );\r
    } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);\r
    gST->ConOut->ClearScreen(gST->ConOut);\r
  }\r
}\r
\r
/**\r
  Process OPAL request.\r
\r
  @param[in] Dev            The device which has OPAL request.\r
\r
**/\r
VOID\r
ProcessOpalRequest (\r
  IN OPAL_DRIVER_DEVICE     *Dev\r
  )\r
{\r
  EFI_STATUS                Status;\r
  OPAL_REQUEST_VARIABLE     *TempVariable;\r
  OPAL_REQUEST_VARIABLE     *Variable;\r
  UINTN                     VariableSize;\r
  EFI_DEVICE_PATH_PROTOCOL  *DevicePathInVariable;\r
  UINTN                     DevicePathSizeInVariable;\r
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;\r
  UINTN                     DevicePathSize;\r
  BOOLEAN                   KeepUserData;\r
\r
  DEBUG ((DEBUG_INFO, "%a() - enter\n", __FUNCTION__));\r
\r
  if (mOpalRequestVariable == NULL) {\r
    Status = GetVariable2 (\r
               OPAL_REQUEST_VARIABLE_NAME,\r
               &gHiiSetupVariableGuid,\r
               (VOID **) &Variable,\r
               &VariableSize\r
               );\r
    if (EFI_ERROR (Status) || (Variable == NULL)) {\r
      return;\r
    }\r
    mOpalRequestVariable = Variable;\r
    mOpalRequestVariableSize = VariableSize;\r
\r
    //\r
    // Delete the OPAL request variable.\r
    //\r
    Status = gRT->SetVariable (\r
                    OPAL_REQUEST_VARIABLE_NAME,\r
                    (EFI_GUID *) &gHiiSetupVariableGuid,\r
                    0,\r
                    0,\r
                    NULL\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
  } else {\r
    Variable = mOpalRequestVariable;\r
    VariableSize = mOpalRequestVariableSize;\r
  }\r
\r
  //\r
  // Process the OPAL requests.\r
  //\r
  TempVariable = Variable;\r
  while ((VariableSize > sizeof (OPAL_REQUEST_VARIABLE)) &&\r
         (VariableSize >= TempVariable->Length) &&\r
         (TempVariable->Length > sizeof (OPAL_REQUEST_VARIABLE))) {\r
    DevicePathInVariable = (EFI_DEVICE_PATH_PROTOCOL *) ((UINTN) TempVariable + sizeof (OPAL_REQUEST_VARIABLE));\r
    DevicePathSizeInVariable = GetDevicePathSize (DevicePathInVariable);\r
    DevicePath = Dev->OpalDisk.OpalDevicePath;\r
    DevicePathSize = GetDevicePathSize (DevicePath);\r
    if ((DevicePathSize == DevicePathSizeInVariable) &&\r
        (CompareMem (DevicePath, DevicePathInVariable, DevicePathSize) == 0)) {\r
      //\r
      // Found the node for the OPAL device.\r
      //\r
      if (TempVariable->OpalRequest.SetAdminPwd != 0) {\r
        ProcessOpalRequestSetAdminPwd (Dev, L"Update Admin Pwd:");\r
      }\r
      if (TempVariable->OpalRequest.SetUserPwd != 0) {\r
        ProcessOpalRequestSetUserPwd (Dev, L"Set User Pwd:");\r
      }\r
      if (TempVariable->OpalRequest.SecureErase!= 0) {\r
        ProcessOpalRequestSecureErase (Dev, L"Secure Erase:");\r
      }\r
      if (TempVariable->OpalRequest.Revert != 0) {\r
        KeepUserData = (BOOLEAN) TempVariable->OpalRequest.KeepUserData;\r
        ProcessOpalRequestRevert (\r
          Dev,\r
          KeepUserData,\r
          KeepUserData ? L"Admin Revert(keep):" : L"Admin Revert:"\r
          );\r
      }\r
      if (TempVariable->OpalRequest.PsidRevert != 0) {\r
        ProcessOpalRequestPsidRevert (Dev, L"Psid Revert:");\r
      }\r
      if (TempVariable->OpalRequest.DisableUser != 0) {\r
        ProcessOpalRequestDisableUser (Dev, L"Disable User:");\r
      }\r
      if (TempVariable->OpalRequest.EnableFeature != 0) {\r
        ProcessOpalRequestEnableFeature (Dev, L"Enable Feature:");\r
      }\r
\r
      break;\r
    }\r
\r
    VariableSize -= TempVariable->Length;\r
    TempVariable = (OPAL_REQUEST_VARIABLE *) ((UINTN) TempVariable + TempVariable->Length);\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "%a() - exit\n", __FUNCTION__));\r
}\r
\r
/**\r
  Add new device to the global device list.\r
\r
  @param Dev             New create device.\r
\r
**/\r
VOID\r
AddDeviceToTail(\r
  IN OPAL_DRIVER_DEVICE    *Dev\r
  )\r
{\r
  OPAL_DRIVER_DEVICE                *TmpDev;\r
\r
  if (mOpalDriver.DeviceList == NULL) {\r
    mOpalDriver.DeviceList = Dev;\r
  } else {\r
    TmpDev = mOpalDriver.DeviceList;\r
    while (TmpDev->Next != NULL) {\r
      TmpDev = TmpDev->Next;\r
    }\r
\r
    TmpDev->Next = Dev;\r
  }\r
}\r
\r
/**\r
  Remove one device in the global device list.\r
\r
  @param Dev             The device need to be removed.\r
\r
**/\r
VOID\r
RemoveDevice (\r
  IN OPAL_DRIVER_DEVICE    *Dev\r
  )\r
{\r
  OPAL_DRIVER_DEVICE                *TmpDev;\r
\r
  if (mOpalDriver.DeviceList == NULL) {\r
    return;\r
  }\r
\r
  if (mOpalDriver.DeviceList == Dev) {\r
    mOpalDriver.DeviceList = NULL;\r
    return;\r
  }\r
\r
  TmpDev = mOpalDriver.DeviceList;\r
  while (TmpDev->Next != NULL) {\r
    if (TmpDev->Next == Dev) {\r
      TmpDev->Next = Dev->Next;\r
      break;\r
    }\r
  }\r
}\r
\r
/**\r
  Get current device count.\r
\r
  @retval  return the current created device count.\r
\r
**/\r
UINT8\r
GetDeviceCount (\r
  VOID\r
  )\r
{\r
  UINT8                Count;\r
  OPAL_DRIVER_DEVICE   *TmpDev;\r
\r
  Count = 0;\r
  TmpDev = mOpalDriver.DeviceList;\r
\r
  while (TmpDev != NULL) {\r
    Count++;\r
    TmpDev = TmpDev->Next;\r
  }\r
\r
  return Count;\r
}\r
\r
/**\r
  Get devcie list info.\r
\r
  @retval     return the device list pointer.\r
**/\r
OPAL_DRIVER_DEVICE*\r
OpalDriverGetDeviceList(\r
  VOID\r
  )\r
{\r
  return mOpalDriver.DeviceList;\r
}\r
\r
/**\r
  ReadyToBoot callback to send BlockSid command.\r
\r
  @param  Event   Pointer to this event\r
  @param  Context Event handler private Data\r
\r
**/\r
VOID\r
EFIAPI\r
ReadyToBootCallback (\r
  IN EFI_EVENT        Event,\r
  IN VOID             *Context\r
  )\r
{\r
  OPAL_DRIVER_DEVICE                         *Itr;\r
  TCG_RESULT                                 Result;\r
  OPAL_SESSION                               Session;\r
  UINT32                                     PpStorageFlag;\r
\r
  gBS->CloseEvent (Event);\r
\r
  PpStorageFlag = Tcg2PhysicalPresenceLibGetManagementFlags ();\r
  if ((PpStorageFlag & TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_ENABLE_BLOCK_SID) != 0) {\r
    //\r
    // Send BlockSID command to each Opal disk\r
    //\r
    Itr = mOpalDriver.DeviceList;\r
    while (Itr != NULL) {\r
      if (Itr->OpalDisk.SupportedAttributes.BlockSid) {\r
        ZeroMem(&Session, sizeof(Session));\r
        Session.Sscp = Itr->OpalDisk.Sscp;\r
        Session.MediaId = Itr->OpalDisk.MediaId;\r
        Session.OpalBaseComId = Itr->OpalDisk.OpalBaseComId;\r
\r
        DEBUG ((DEBUG_INFO, "OpalPassword: ReadyToBoot point, send BlockSid command to device!\n"));\r
        Result = OpalBlockSid (&Session, TRUE);  // HardwareReset must always be TRUE\r
        if (Result != TcgResultSuccess) {\r
          DEBUG ((DEBUG_ERROR, "OpalBlockSid fail\n"));\r
          break;\r
        }\r
      }\r
\r
      Itr = Itr->Next;\r
    }\r
  }\r
}\r
\r
/**\r
  Stop this Controller.\r
\r
  @param  Dev               The device need to be stopped.\r
\r
**/\r
VOID\r
OpalDriverStopDevice (\r
  OPAL_DRIVER_DEVICE     *Dev\r
  )\r
{\r
  //\r
  // free each name\r
  //\r
  FreePool(Dev->Name16);\r
\r
  //\r
  // remove OPAL_DRIVER_DEVICE from the list\r
  // it updates the controllerList pointer\r
  //\r
  RemoveDevice(Dev);\r
\r
  //\r
  // close protocols that were opened\r
  //\r
  gBS->CloseProtocol(\r
    Dev->Handle,\r
    &gEfiStorageSecurityCommandProtocolGuid,\r
    gOpalDriverBinding.DriverBindingHandle,\r
    Dev->Handle\r
    );\r
\r
  gBS->CloseProtocol(\r
    Dev->Handle,\r
    &gEfiBlockIoProtocolGuid,\r
    gOpalDriverBinding.DriverBindingHandle,\r
    Dev->Handle\r
    );\r
\r
  FreePool(Dev);\r
}\r
\r
/**\r
  Get devcie name through the component name protocol.\r
\r
  @param[in]       AllHandlesBuffer   The handle buffer for current system.\r
  @param[in]       NumAllHandles      The number of handles for the handle buffer.\r
  @param[in]       Dev                The device which need to get name.\r
  @param[in]       UseComp1           Whether use component name or name2 protocol.\r
\r
  @retval     TRUE        Find the name for this device.\r
  @retval     FALSE       Not found the name for this device.\r
**/\r
BOOLEAN\r
OpalDriverGetDeviceNameByProtocol(\r
  EFI_HANDLE             *AllHandlesBuffer,\r
  UINTN                  NumAllHandles,\r
  OPAL_DRIVER_DEVICE     *Dev,\r
  BOOLEAN                UseComp1\r
  )\r
{\r
  EFI_HANDLE*                   ProtocolHandlesBuffer;\r
  UINTN                         NumProtocolHandles;\r
  EFI_STATUS                    Status;\r
  EFI_COMPONENT_NAME2_PROTOCOL* Cnp1_2; // efi component name and componentName2 have same layout\r
  EFI_GUID                      Protocol;\r
  UINTN                         StrLength;\r
  EFI_DEVICE_PATH_PROTOCOL*     TmpDevPath;\r
  UINTN                         Index1;\r
  UINTN                         Index2;\r
  EFI_HANDLE                    TmpHandle;\r
  CHAR16                        *DevName;\r
\r
  if (Dev == NULL || AllHandlesBuffer == NULL || NumAllHandles == 0) {\r
    return FALSE;\r
  }\r
\r
  Protocol = UseComp1 ? gEfiComponentNameProtocolGuid : gEfiComponentName2ProtocolGuid;\r
\r
  //\r
  // Find all EFI_HANDLES with protocol\r
  //\r
  Status = gBS->LocateHandleBuffer(\r
               ByProtocol,\r
               &Protocol,\r
               NULL,\r
               &NumProtocolHandles,\r
               &ProtocolHandlesBuffer\r
               );\r
  if (EFI_ERROR(Status)) {\r
    return FALSE;\r
  }\r
\r
\r
  //\r
  // Exit early if no supported devices\r
  //\r
  if (NumProtocolHandles == 0) {\r
    return FALSE;\r
  }\r
\r
  //\r
  // Get printable name by iterating through all protocols\r
  // using the handle as the child, and iterate through all handles for the controller\r
  // exit loop early once found, if not found, then delete device\r
  // storage security protocol instances already exist, add them to internal list\r
  //\r
  Status = EFI_DEVICE_ERROR;\r
  for (Index1 = 0; Index1 < NumProtocolHandles; Index1++) {\r
    DevName = NULL;\r
\r
    if (Dev->Name16 != NULL) {\r
      return TRUE;\r
    }\r
\r
    TmpHandle = ProtocolHandlesBuffer[Index1];\r
\r
    Status = gBS->OpenProtocol(\r
                 TmpHandle,\r
                 &Protocol,\r
                 (VOID**)&Cnp1_2,\r
                 gImageHandle,\r
                 NULL,\r
                 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                 );\r
    if (EFI_ERROR(Status) || Cnp1_2 == NULL) {\r
      continue;\r
    }\r
\r
    //\r
    // Use all handles array as controller handle\r
    //\r
    for (Index2 = 0; Index2 < NumAllHandles; Index2++) {\r
      Status = Cnp1_2->GetControllerName(\r
                   Cnp1_2,\r
                   AllHandlesBuffer[Index2],\r
                   Dev->Handle,\r
                   LANGUAGE_ISO_639_2_ENGLISH,\r
                   &DevName\r
                   );\r
      if (EFI_ERROR(Status)) {\r
        Status = Cnp1_2->GetControllerName(\r
                     Cnp1_2,\r
                     AllHandlesBuffer[Index2],\r
                     Dev->Handle,\r
                     LANGUAGE_RFC_3066_ENGLISH,\r
                     &DevName\r
                     );\r
      }\r
      if (!EFI_ERROR(Status) && DevName != NULL) {\r
        StrLength = StrLen(DevName) + 1;        // Add one for NULL terminator\r
        Dev->Name16 = AllocateZeroPool(StrLength * sizeof (CHAR16));\r
        ASSERT (Dev->Name16 != NULL);\r
        StrCpyS (Dev->Name16, StrLength, DevName);\r
        Dev->NameZ = (CHAR8*)AllocateZeroPool(StrLength);\r
        UnicodeStrToAsciiStrS (DevName, Dev->NameZ, StrLength);\r
\r
        //\r
        // Retrieve bridge BDF info and port number or namespace depending on type\r
        //\r
        TmpDevPath = NULL;\r
        Status = gBS->OpenProtocol(\r
            Dev->Handle,\r
            &gEfiDevicePathProtocolGuid,\r
            (VOID**)&TmpDevPath,\r
            gImageHandle,\r
            NULL,\r
            EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
            );\r
        if (!EFI_ERROR(Status)) {\r
          Dev->OpalDevicePath = DuplicateDevicePath (TmpDevPath);\r
          return TRUE;\r
        }\r
\r
        if (Dev->Name16 != NULL) {\r
          FreePool(Dev->Name16);\r
          Dev->Name16 = NULL;\r
        }\r
        if (Dev->NameZ != NULL) {\r
          FreePool(Dev->NameZ);\r
          Dev->NameZ = NULL;\r
        }\r
      }\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Get devcie name through the component name protocol.\r
\r
  @param[in]       Dev                The device which need to get name.\r
\r
  @retval     TRUE        Find the name for this device.\r
  @retval     FALSE       Not found the name for this device.\r
**/\r
BOOLEAN\r
OpalDriverGetDriverDeviceName(\r
  OPAL_DRIVER_DEVICE          *Dev\r
  )\r
{\r
  EFI_HANDLE*                  AllHandlesBuffer;\r
  UINTN                        NumAllHandles;\r
  EFI_STATUS                   Status;\r
\r
  if (Dev == NULL) {\r
    DEBUG((DEBUG_ERROR | DEBUG_INIT, "OpalDriverGetDriverDeviceName Exiting, Dev=NULL\n"));\r
    return FALSE;\r
  }\r
\r
  //\r
  // Iterate through ComponentName2 handles to get name, if fails, try ComponentName\r
  //\r
  if (Dev->Name16 == NULL) {\r
    DEBUG((DEBUG_ERROR | DEBUG_INIT, "Name is null, update it\n"));\r
    //\r
    // Find all EFI_HANDLES\r
    //\r
    Status = gBS->LocateHandleBuffer(\r
                 AllHandles,\r
                 NULL,\r
                 NULL,\r
                 &NumAllHandles,\r
                 &AllHandlesBuffer\r
                 );\r
    if (EFI_ERROR(Status)) {\r
      DEBUG ((DEBUG_INFO, "LocateHandleBuffer for AllHandles failed %r\n", Status ));\r
      return FALSE;\r
    }\r
\r
    //\r
    // Try component Name2\r
    //\r
    if (!OpalDriverGetDeviceNameByProtocol(AllHandlesBuffer, NumAllHandles, Dev, FALSE)) {\r
      DEBUG((DEBUG_ERROR | DEBUG_INIT, "ComponentName2 failed to get device name, try ComponentName\n"));\r
      if (!OpalDriverGetDeviceNameByProtocol(AllHandlesBuffer, NumAllHandles, Dev, TRUE)) {\r
        DEBUG((DEBUG_ERROR | DEBUG_INIT, "ComponentName failed to get device name, skip device\n"));\r
        return FALSE;\r
      }\r
    }\r
  }\r
\r
  return TRUE;\r
}\r
\r
/**\r
  Main entry for this driver.\r
\r
  @param ImageHandle     Image Handle this driver.\r
  @param SystemTable     Pointer to SystemTable.\r
\r
  @retval EFI_SUCESS     This function always complete successfully.\r
**/\r
EFI_STATUS\r
EFIAPI\r
EfiDriverEntryPoint(\r
  IN EFI_HANDLE         ImageHandle,\r
  IN EFI_SYSTEM_TABLE*  SystemTable\r
  )\r
{\r
  EFI_STATUS                     Status;\r
  EFI_EVENT                      ReadyToBootEvent;\r
  EFI_EVENT                      EndOfDxeEvent;\r
\r
  Status = EfiLibInstallDriverBindingComponentName2 (\r
             ImageHandle,\r
             SystemTable,\r
             &gOpalDriverBinding,\r
             ImageHandle,\r
             &gOpalComponentName,\r
             &gOpalComponentName2\r
             );\r
\r
  if (EFI_ERROR(Status)) {\r
    DEBUG((DEBUG_ERROR, "Install protocols to Opal driver Handle failed\n"));\r
    return Status ;\r
  }\r
\r
  //\r
  // Initialize Driver object\r
  //\r
  ZeroMem(&mOpalDriver, sizeof(mOpalDriver));\r
  mOpalDriver.Handle = ImageHandle;\r
\r
  Status = gBS->CreateEventEx (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_CALLBACK,\r
                  OpalEndOfDxeEventNotify,\r
                  NULL,\r
                  &gEfiEndOfDxeEventGroupGuid,\r
                  &EndOfDxeEvent\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // register a ReadyToBoot event callback for sending BlockSid command\r
  //\r
  Status = EfiCreateEventReadyToBootEx (\r
                  TPL_CALLBACK,\r
                  ReadyToBootCallback,\r
                  (VOID *) &ImageHandle,\r
                  &ReadyToBootEvent\r
                  );\r
\r
  //\r
  // Install Hii packages.\r
  //\r
  HiiInstall();\r
\r
  return Status;\r
}\r
\r
/**\r
  Tests to see if this driver supports a given controller.\r
\r
  This function checks to see if the controller contains an instance of the\r
  EFI_STORAGE_SECURITY_COMMAND_PROTOCOL and the EFI_BLOCK_IO_PROTOCL\r
  and returns EFI_SUCCESS if it does.\r
\r
  @param[in]  This                  A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.\r
  @param[in]  ControllerHandle      The Handle of the controller to test. This Handle\r
                                    must support a protocol interface that supplies\r
                                    an I/O abstraction to the driver.\r
  @param[in]  RemainingDevicePath  This parameter is ignored.\r
\r
  @retval EFI_SUCCESS               The device contains required protocols\r
  @retval EFI_ALREADY_STARTED       The device specified by ControllerHandle and\r
                                    RemainingDevicePath is already being managed by the driver\r
                                    specified by This.\r
  @retval EFI_ACCESS_DENIED         The device specified by ControllerHandle and\r
                                    RemainingDevicePath is already being managed by a different\r
                                    driver or an application that requires exclusive access.\r
                                    Currently not implemented.\r
  @retval EFI_UNSUPPORTED           The device does not contain requires protocols\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
OpalEfiDriverBindingSupported(\r
  IN EFI_DRIVER_BINDING_PROTOCOL* This,\r
  IN EFI_HANDLE                   Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL*    RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS                              Status;\r
  EFI_STORAGE_SECURITY_COMMAND_PROTOCOL*  SecurityCommand;\r
  EFI_BLOCK_IO_PROTOCOL*                  BlkIo;\r
\r
  if (mOpalEndOfDxe) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Test EFI_STORAGE_SECURITY_COMMAND_PROTOCOL on controller Handle.\r
  //\r
  Status = gBS->OpenProtocol(\r
    Controller,\r
    &gEfiStorageSecurityCommandProtocolGuid,\r
    ( VOID ** )&SecurityCommand,\r
    This->DriverBindingHandle,\r
    Controller,\r
    EFI_OPEN_PROTOCOL_BY_DRIVER\r
    );\r
\r
  if (Status == EFI_ALREADY_STARTED) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (EFI_ERROR(Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Close protocol and reopen in Start call\r
  //\r
  gBS->CloseProtocol(\r
      Controller,\r
      &gEfiStorageSecurityCommandProtocolGuid,\r
      This->DriverBindingHandle,\r
      Controller\r
      );\r
\r
  //\r
  // Test EFI_BLOCK_IO_PROTOCOL on controller Handle, required by EFI_STORAGE_SECURITY_COMMAND_PROTOCOL\r
  // function APIs\r
  //\r
  Status = gBS->OpenProtocol(\r
    Controller,\r
    &gEfiBlockIoProtocolGuid,\r
    (VOID **)&BlkIo,\r
    This->DriverBindingHandle,\r
    Controller,\r
    EFI_OPEN_PROTOCOL_BY_DRIVER\r
    );\r
\r
  if (EFI_ERROR(Status)) {\r
    DEBUG((DEBUG_INFO, "No EFI_BLOCK_IO_PROTOCOL on controller\n"));\r
    return Status;\r
  }\r
\r
  //\r
  // Close protocol and reopen in Start call\r
  //\r
  gBS->CloseProtocol(\r
    Controller,\r
    &gEfiBlockIoProtocolGuid,\r
    This->DriverBindingHandle,\r
    Controller\r
    );\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Enables Opal Management on a supported device if available.\r
\r
  The start function is designed to be called after the Opal UEFI Driver has confirmed the\r
  "controller", which is a child Handle, contains the EF_STORAGE_SECURITY_COMMAND protocols.\r
  This function will complete the other necessary checks, such as verifying the device supports\r
  the correct version of Opal.  Upon verification, it will add the device to the\r
  Opal HII list in order to expose Opal managmeent options.\r
\r
  @param[in]  This                  A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.\r
  @param[in]  ControllerHandle      The Handle of the controller to start. This Handle\r
                                    must support a protocol interface that supplies\r
                                    an I/O abstraction to the driver.\r
  @param[in]  RemainingDevicePath   A pointer to the remaining portion of a device path.  This\r
                                    parameter is ignored by device drivers, and is optional for bus\r
                                    drivers. For a bus driver, if this parameter is NULL, then handles\r
                                    for all the children of Controller are created by this driver.\r
                                    If this parameter is not NULL and the first Device Path Node is\r
                                    not the End of Device Path Node, then only the Handle for the\r
                                    child device specified by the first Device Path Node of\r
                                    RemainingDevicePath is created by this driver.\r
                                    If the first Device Path Node of RemainingDevicePath is\r
                                    the End of Device Path Node, no child Handle is created by this\r
                                    driver.\r
\r
  @retval EFI_SUCCESS               Opal management was enabled.\r
  @retval EFI_DEVICE_ERROR          The device could not be started due to a device error.Currently not implemented.\r
  @retval EFI_OUT_OF_RESOURCES      The request could not be completed due to a lack of resources.\r
  @retval Others                    The driver failed to start the device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
OpalEfiDriverBindingStart(\r
  IN EFI_DRIVER_BINDING_PROTOCOL* This,\r
  IN EFI_HANDLE                   Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL*    RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  EFI_BLOCK_IO_PROTOCOL       *BlkIo;\r
  OPAL_DRIVER_DEVICE          *Dev;\r
  OPAL_DRIVER_DEVICE          *Itr;\r
  BOOLEAN                     Result;\r
\r
  Itr = mOpalDriver.DeviceList;\r
  while (Itr != NULL) {\r
    if (Controller == Itr->Handle) {\r
      return EFI_SUCCESS;\r
    }\r
    Itr = Itr->Next;\r
  }\r
\r
  //\r
  // Create internal device for tracking.  This allows all disks to be tracked\r
  // by same HII form\r
  //\r
  Dev = (OPAL_DRIVER_DEVICE*)AllocateZeroPool(sizeof(OPAL_DRIVER_DEVICE));\r
  if (Dev == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  Dev->Handle = Controller;\r
\r
  //\r
  // Open EFI_STORAGE_SECURITY_COMMAND_PROTOCOL to perform Opal supported checks\r
  //\r
  Status = gBS->OpenProtocol(\r
    Controller,\r
    &gEfiStorageSecurityCommandProtocolGuid,\r
    (VOID **)&Dev->Sscp,\r
    This->DriverBindingHandle,\r
    Controller,\r
    EFI_OPEN_PROTOCOL_BY_DRIVER\r
    );\r
  if (EFI_ERROR(Status)) {\r
    FreePool(Dev);\r
    return Status;\r
  }\r
\r
  //\r
  // Open EFI_BLOCK_IO_PROTOCOL on controller Handle, required by EFI_STORAGE_SECURITY_COMMAND_PROTOCOL\r
  // function APIs\r
  //\r
  Status = gBS->OpenProtocol(\r
    Controller,\r
    &gEfiBlockIoProtocolGuid,\r
    (VOID **)&BlkIo,\r
    This->DriverBindingHandle,\r
    Controller,\r
    EFI_OPEN_PROTOCOL_BY_DRIVER\r
    );\r
  if (EFI_ERROR(Status)) {\r
    //\r
    // Close storage security that was opened\r
    //\r
    gBS->CloseProtocol(\r
        Controller,\r
        &gEfiStorageSecurityCommandProtocolGuid,\r
        This->DriverBindingHandle,\r
        Controller\r
        );\r
\r
    FreePool(Dev);\r
    return Status;\r
  }\r
\r
  //\r
  // Save mediaId\r
  //\r
  Dev->MediaId = BlkIo->Media->MediaId;\r
\r
  gBS->CloseProtocol(\r
    Controller,\r
    &gEfiBlockIoProtocolGuid,\r
    This->DriverBindingHandle,\r
    Controller\r
    );\r
\r
  //\r
  // Acquire Ascii printable name of child, if not found, then ignore device\r
  //\r
  Result = OpalDriverGetDriverDeviceName (Dev);\r
  if (!Result) {\r
    goto Done;\r
  }\r
\r
  Status = OpalDiskInitialize (Dev);\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
\r
  AddDeviceToTail(Dev);\r
\r
  //\r
  // Check if device is locked and prompt for password.\r
  //\r
  OpalDriverRequestPassword (Dev, L"Unlock:");\r
\r
  //\r
  // Process OPAL request from last boot.\r
  //\r
  ProcessOpalRequest (Dev);\r
\r
  return EFI_SUCCESS;\r
\r
Done:\r
  //\r
  // free device, close protocols and exit\r
  //\r
  gBS->CloseProtocol(\r
      Controller,\r
      &gEfiStorageSecurityCommandProtocolGuid,\r
      This->DriverBindingHandle,\r
      Controller\r
      );\r
\r
  FreePool(Dev);\r
\r
  return EFI_DEVICE_ERROR;\r
}\r
\r
/**\r
  Stop this driver on Controller.\r
\r
  @param  This              Protocol instance pointer.\r
  @param  Controller        Handle of device to stop driver on\r
  @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of\r
                            children is zero stop the entire bus driver.\r
  @param  ChildHandleBuffer List of Child Handles to Stop.\r
\r
  @retval EFI_SUCCESS       This driver is removed Controller.\r
  @retval other             This driver could not be removed from this device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
OpalEfiDriverBindingStop(\r
  EFI_DRIVER_BINDING_PROTOCOL*    This,\r
  EFI_HANDLE                      Controller,\r
  UINTN                           NumberOfChildren,\r
  EFI_HANDLE*                     ChildHandleBuffer\r
  )\r
{\r
  OPAL_DRIVER_DEVICE*   Itr;\r
\r
  Itr = mOpalDriver.DeviceList;\r
\r
  //\r
  // does Controller match any of the devices we are managing for Opal\r
  //\r
  while (Itr != NULL) {\r
    if (Itr->Handle == Controller) {\r
      OpalDriverStopDevice (Itr);\r
      return EFI_SUCCESS;\r
    }\r
\r
    Itr = Itr->Next;\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
/**\r
  Unloads UEFI Driver.  Very useful for debugging and testing.\r
\r
  @param ImageHandle            Image Handle this driver.\r
\r
  @retval EFI_SUCCESS           This function always complete successfully.\r
  @retval EFI_INVALID_PARAMETER The input ImageHandle is not valid.\r
**/\r
EFI_STATUS\r
EFIAPI\r
OpalEfiDriverUnload (\r
  IN EFI_HANDLE ImageHandle\r
  )\r
{\r
  EFI_STATUS                     Status;\r
  OPAL_DRIVER_DEVICE                   *Itr;\r
\r
  Status = EFI_SUCCESS;\r
\r
  if (ImageHandle != gImageHandle) {\r
    return (EFI_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // Uninstall any interface added to each device by us\r
  //\r
  while (mOpalDriver.DeviceList) {\r
    Itr = mOpalDriver.DeviceList;\r
    //\r
    // Remove OPAL_DRIVER_DEVICE from the list\r
    // it updates the controllerList pointer\r
    //\r
    OpalDriverStopDevice(Itr);\r
  }\r
\r
  //\r
  // Uninstall the HII capability\r
  //\r
  Status = HiiUninstall();\r
\r
  return Status;\r
}\r
\r