TcgStorageOpalCore.c

Go to the documentation of this file.

 
#include <Uefi.h>
#include <Library/BaseLib.h>
#include <Library/TimerLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/TcgStorageOpalLib.h>
 
#include "TcgStorageOpalLibInternal.h"
 
#pragma pack(1)
typedef struct {
  UINT8    HardwareReset : 1;
  UINT8    Reserved      : 7;
} TCG_BLOCK_SID_CLEAR_EVENTS;
#pragma pack()
 
#define TRUSTED_COMMAND_TIMEOUT_NS  ((UINT64) 5 * ((UINT64)(1000000)) * 1000)     // 5 seconds
#define BUFFER_SIZE                 512
 
TCG_RESULT
OpalTrustedSend (
  EFI_STORAGE_SECURITY_COMMAND_PROTOCOL  *Sscp,
  UINT32                                 MediaId,
  UINT8                                  SecurityProtocol,
  UINT16                                 SpSpecific,
  UINTN                                  TransferLength,
  VOID                                   *Buffer,
  UINTN                                  BufferSize
  )
{
  UINTN       TransferLength512;
  EFI_STATUS  Status;
 
  //
  // Round transferLength up to a 512-byte multiple
  //
  TransferLength512 = (TransferLength + 511) & ~(UINTN)511;
 
  if (TransferLength512 > BufferSize) {
    return TcgResultFailureBufferTooSmall;
  }
 
  ZeroMem ((UINT8 *)Buffer + TransferLength, TransferLength512 - TransferLength);
 
  Status = Sscp->SendData (
                   Sscp,
                   MediaId,
                   TRUSTED_COMMAND_TIMEOUT_NS,
                   SecurityProtocol,
                   SwapBytes16 (SpSpecific),
                   TransferLength512,
                   Buffer
                   );
 
  return Status == EFI_SUCCESS ? TcgResultSuccess : TcgResultFailure;
}
 
TCG_RESULT
OpalTrustedRecv (
  EFI_STORAGE_SECURITY_COMMAND_PROTOCOL  *Sscp,
  UINT32                                 MediaId,
  UINT8                                  SecurityProtocol,
  UINT16                                 SpSpecific,
  VOID                                   *Buffer,
  UINTN                                  BufferSize,
  UINT32                                 EstimateTimeCost
  )
{
  UINTN           TransferLength512;
  UINT32          Tries;
  TCG_COM_PACKET  *ComPacket;
  UINT32          Length;
  UINT32          OutstandingData;
  EFI_STATUS      Status;
  UINTN           TransferSize;
 
  //
  // Round Buffer Size down to a 512-byte multiple
  //
  TransferLength512 = BufferSize & ~(UINTN)511;
  Tries             = 0;
  ComPacket         = NULL;
  Length            = 0;
  OutstandingData   = 0;
 
  if (TransferLength512 < sizeof (TCG_COM_PACKET)) {
    DEBUG ((DEBUG_INFO, "transferLength %u too small for ComPacket\n", TransferLength512));
    return TcgResultFailureBufferTooSmall;
  }
 
  //
  // Some devices respond with Length = 0 and OutstandingData = 1 to indicate that processing is not yet completed,
  // so we need to retry the IF-RECV to get the actual Data.
  // See TCG Core Spec v2 Table 45 IF-RECV ComPacket Field Values Summary
  // This is an arbitrary number of retries, not from the spec.
  //
  // if user input estimate time cost(second level) value bigger than 10s, base on user input value to wait.
  // Else, Use a max timeout of 10 seconds to wait, 5000 tries * 2ms = 10s
  //
  if (EstimateTimeCost > 10) {
    Tries = EstimateTimeCost * 500; // 500 = 1000 * 1000 / 2000;
  } else {
    Tries = 5000;
  }
 
  while ((Tries--) > 0) {
    ZeroMem (Buffer, BufferSize);
    TransferSize = 0;
 
    Status = Sscp->ReceiveData (
                     Sscp,
                     MediaId,
                     TRUSTED_COMMAND_TIMEOUT_NS,
                     SecurityProtocol,
                     SwapBytes16 (SpSpecific),
                     TransferLength512,
                     Buffer,
                     &TransferSize
                     );
    if (EFI_ERROR (Status)) {
      return TcgResultFailure;
    }
 
    if ((SecurityProtocol != TCG_OPAL_SECURITY_PROTOCOL_1) && (SecurityProtocol != TCG_OPAL_SECURITY_PROTOCOL_2)) {
      return TcgResultSuccess;
    }
 
    if (SpSpecific == TCG_SP_SPECIFIC_PROTOCOL_LEVEL0_DISCOVERY) {
      return TcgResultSuccess;
    }
 
    ComPacket       = (TCG_COM_PACKET *)Buffer;
    Length          = SwapBytes32 (ComPacket->LengthBE);
    OutstandingData = SwapBytes32 (ComPacket->OutstandingDataBE);
 
    if ((Length != 0) && (OutstandingData == 0)) {
      return TcgResultSuccess;
    }
 
    //
    // Delay for 2 ms
    //
    MicroSecondDelay (2000);
  }
 
  return TcgResultFailure;
}
 
TCG_RESULT
EFIAPI
OpalPerformMethod (
  OPAL_SESSION      *Session,
  UINT32            SendSize,
  VOID              *Buffer,
  UINT32            BufferSize,
  TCG_PARSE_STRUCT  *ParseStruct,
  UINT8             *MethodStatus,
  UINT32            EstimateTimeCost
  )
{
  NULL_CHECK (Session);
  NULL_CHECK (MethodStatus);
 
  ERROR_CHECK (
    OpalTrustedSend (
      Session->Sscp,
      Session->MediaId,
      TCG_OPAL_SECURITY_PROTOCOL_1,
      Session->OpalBaseComId,
      SendSize,
      Buffer,
      BufferSize
      )
    );
 
  ERROR_CHECK (
    OpalTrustedRecv (
      Session->Sscp,
      Session->MediaId,
      TCG_OPAL_SECURITY_PROTOCOL_1,
      Session->OpalBaseComId,
      Buffer,
      BufferSize,
      EstimateTimeCost
      )
    );
 
  ERROR_CHECK (TcgInitTcgParseStruct (ParseStruct, Buffer, BufferSize));
  ERROR_CHECK (TcgCheckComIds (ParseStruct, Session->OpalBaseComId, Session->ComIdExtension));
  ERROR_CHECK (TcgGetMethodStatus (ParseStruct, MethodStatus));
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalBlockSid (
  OPAL_SESSION  *Session,
  BOOLEAN       HardwareReset
  )
{
  UINT8                       Buffer[BUFFER_SIZE];
  TCG_BLOCK_SID_CLEAR_EVENTS  *ClearEvents;
 
  NULL_CHECK (Session);
 
  //
  // Set Hardware Reset bit
  //
  ClearEvents = (TCG_BLOCK_SID_CLEAR_EVENTS *)&Buffer[0];
 
  ClearEvents->Reserved      = 0;
  ClearEvents->HardwareReset = HardwareReset;
 
  return (OpalTrustedSend (
            Session->Sscp,
            Session->MediaId,
            TCG_OPAL_SECURITY_PROTOCOL_2,
            TCG_BLOCKSID_COMID,         // hardcode ComID 0x0005
            1,
            Buffer,
            BUFFER_SIZE
            ));
}
 
TCG_RESULT
EFIAPI
OpalPsidRevert (
  OPAL_SESSION  *AdminSpSession
  )
{
  //
  // Now that base comid is known, start Session
  // we'll attempt to start Session as PSID authority
  // verify PSID Authority is defined in ADMIN SP authority table... is this possible?
  //
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
  UINT8              Buffer[BUFFER_SIZE];
  UINT8              MethodStatus;
 
  NULL_CHECK (AdminSpSession);
 
  //
  // Send Revert action on Admin SP
  //
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buffer, BUFFER_SIZE));
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, AdminSpSession->OpalBaseComId, AdminSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, AdminSpSession->TperSessionId, AdminSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, OPAL_UID_ADMIN_SP, OPAL_ADMIN_SP_REVERT_METHOD));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  //
  // Send Revert Method Call
  //
  ERROR_CHECK (OpalPerformMethod (AdminSpSession, Size, Buffer, BUFFER_SIZE, &ParseStruct, &MethodStatus, 0));
  METHOD_STATUS_ERROR_CHECK (MethodStatus, TcgResultFailure);
 
  return TcgResultSuccess;
}
 
TCG_RESULT
OpalPyrite2PsidRevert (
  OPAL_SESSION  *AdminSpSession,
  UINT32        EstimateTimeCost
  )
{
  //
  // Now that base comid is known, start Session
  // we'll attempt to start Session as PSID authority
  // verify PSID Authority is defined in ADMIN SP authority table... is this possible?
  //
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
  UINT8              Buffer[BUFFER_SIZE];
  UINT8              MethodStatus;
 
  NULL_CHECK (AdminSpSession);
 
  //
  // Send Revert action on Admin SP
  //
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buffer, BUFFER_SIZE));
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, AdminSpSession->OpalBaseComId, AdminSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, AdminSpSession->TperSessionId, AdminSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, OPAL_UID_ADMIN_SP, OPAL_ADMIN_SP_REVERT_METHOD));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  //
  // Send Revert Method Call
  //
  ERROR_CHECK (OpalPerformMethod (AdminSpSession, Size, Buffer, BUFFER_SIZE, &ParseStruct, &MethodStatus, EstimateTimeCost));
  METHOD_STATUS_ERROR_CHECK (MethodStatus, TcgResultFailure);
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalRetrieveLevel0DiscoveryHeader (
  OPAL_SESSION  *Session,
  UINTN         BufferSize,
  VOID          *BuffAddress
  )
{
  return (OpalTrustedRecv (
            Session->Sscp,
            Session->MediaId,
            TCG_OPAL_SECURITY_PROTOCOL_1,              // SP
            TCG_SP_SPECIFIC_PROTOCOL_LEVEL0_DISCOVERY, // SP_Specific
            BuffAddress,
            BufferSize,
            0
            ));
}
 
TCG_RESULT
EFIAPI
OpalRetrieveSupportedProtocolList (
  OPAL_SESSION  *Session,
  UINTN         BufferSize,
  VOID          *BuffAddress
  )
{
  return (OpalTrustedRecv (
            Session->Sscp,
            Session->MediaId,
            TCG_SECURITY_PROTOCOL_INFO,    // SP
            TCG_SP_SPECIFIC_PROTOCOL_LIST, // SP_Specific
            BuffAddress,
            BufferSize,
            0
            ));
}
 
TCG_RESULT
EFIAPI
OpalStartSession (
  OPAL_SESSION  *Session,
  TCG_UID       SpId,
  BOOLEAN       Write,
  UINT32        HostChallengeLength,
  const VOID    *HostChallenge,
  TCG_UID       HostSigningAuthority,
  UINT8         *MethodStatus
  )
{
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
  UINT8              Buf[BUFFER_SIZE];
  UINT16             ComIdExtension;
  UINT32             HostSessionId;
 
  ComIdExtension = 0;
  HostSessionId  = 1;
 
  NULL_CHECK (Session);
  NULL_CHECK (MethodStatus);
 
  Session->ComIdExtension = ComIdExtension;
  Session->HostSessionId  = HostSessionId;
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (
    TcgCreateStartSession (
      &CreateStruct,
      &Size,
      Session->OpalBaseComId,
      ComIdExtension,
      HostSessionId,
      SpId,
      Write,
      HostChallengeLength,
      HostChallenge,
      HostSigningAuthority
      )
    );
  ERROR_CHECK (OpalPerformMethod (Session, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
  if (*MethodStatus != TCG_METHOD_STATUS_CODE_SUCCESS) {
    return TcgResultSuccess; // return early if method failed - user must check MethodStatus
  }
 
  if (TcgParseSyncSession (&ParseStruct, Session->OpalBaseComId, ComIdExtension, HostSessionId, &Session->TperSessionId) != TcgResultSuccess) {
    OpalEndSession (Session);
    return TcgResultFailure;
  }
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalEndSession (
  OPAL_SESSION  *Session
  )
{
  UINT8              Buffer[BUFFER_SIZE];
  TCG_CREATE_STRUCT  CreateStruct;
  UINT32             Size;
  TCG_PARSE_STRUCT   ParseStruct;
 
  NULL_CHECK (Session);
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buffer, sizeof (Buffer)));
  ERROR_CHECK (
    TcgCreateEndSession (
      &CreateStruct,
      &Size,
      Session->OpalBaseComId,
      Session->ComIdExtension,
      Session->HostSessionId,
      Session->TperSessionId
      )
    );
 
  ERROR_CHECK (
    OpalTrustedSend (
      Session->Sscp,
      Session->MediaId,
      TCG_OPAL_SECURITY_PROTOCOL_1,
      Session->OpalBaseComId,
      Size,
      Buffer,
      sizeof (Buffer)
      )
    );
 
  ERROR_CHECK (
    OpalTrustedRecv (
      Session->Sscp,
      Session->MediaId,
      TCG_OPAL_SECURITY_PROTOCOL_1,
      Session->OpalBaseComId,
      Buffer,
      sizeof (Buffer),
      0
      )
    );
 
  ERROR_CHECK (TcgInitTcgParseStruct (&ParseStruct, Buffer, sizeof (Buffer)));
  ERROR_CHECK (TcgCheckComIds (&ParseStruct, Session->OpalBaseComId, Session->ComIdExtension));
 
  ERROR_CHECK (TcgGetNextEndOfSession (&ParseStruct));
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalGetMsid (
  OPAL_SESSION  *AdminSpSession,
  UINT32        MsidBufferSize,
  UINT8         *Msid,
  UINT32        *MsidLength
  )
{
  //
  // now that base comid is known, start Session
  // we'll attempt to start Session as PSID authority
  // verify PSID Authority is defined in ADMIN SP authority table... is this possible?
  //
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
  UINT8              MethodStatus;
  UINT32             Col;
  const VOID         *RecvMsid;
  UINT8              Buffer[BUFFER_SIZE];
 
  NULL_CHECK (AdminSpSession);
  NULL_CHECK (Msid);
  NULL_CHECK (MsidLength);
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buffer, BUFFER_SIZE));
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, AdminSpSession->OpalBaseComId, AdminSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, AdminSpSession->TperSessionId, AdminSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, OPAL_UID_ADMIN_SP_C_PIN_MSID, TCG_UID_METHOD_GET));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
  ERROR_CHECK (TcgAddStartList (&CreateStruct));
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, TCG_CELL_BLOCK_START_COLUMN_NAME));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, OPAL_ADMIN_SP_PIN_COL));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, TCG_CELL_BLOCK_END_COLUMN_NAME));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, OPAL_ADMIN_SP_PIN_COL));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
  ERROR_CHECK (TcgAddEndList (&CreateStruct));
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  //
  // Send MSID Method Call
  //
  ERROR_CHECK (OpalPerformMethod (AdminSpSession, Size, Buffer, BUFFER_SIZE, &ParseStruct, &MethodStatus, 0));
  METHOD_STATUS_ERROR_CHECK (MethodStatus, TcgResultFailure);
 
  ERROR_CHECK (TcgGetNextStartList (&ParseStruct));
  ERROR_CHECK (TcgGetNextStartList (&ParseStruct));
  ERROR_CHECK (TcgGetNextStartName (&ParseStruct));
  ERROR_CHECK (TcgGetNextUINT32 (&ParseStruct, &Col));
  ERROR_CHECK (TcgGetNextByteSequence (&ParseStruct, &RecvMsid, MsidLength));
  ERROR_CHECK (TcgGetNextEndName (&ParseStruct));
  ERROR_CHECK (TcgGetNextEndList (&ParseStruct));
  ERROR_CHECK (TcgGetNextEndList (&ParseStruct));
  ERROR_CHECK (TcgGetNextEndOfData (&ParseStruct));
 
  if (Col != OPAL_ADMIN_SP_PIN_COL) {
    DEBUG ((DEBUG_INFO, "ERROR: got col %u, expected %u\n", Col, OPAL_ADMIN_SP_PIN_COL));
    return TcgResultFailure;
  }
 
  if (RecvMsid == NULL) {
    return TcgResultFailure;
  }
 
  if (MsidBufferSize < *MsidLength) {
    DEBUG ((DEBUG_INFO, "Buffer too small MsidBufferSize: %d MsidLength: %d\n", MsidBufferSize, *MsidLength));
    return TcgResultFailureBufferTooSmall;
  }
 
  //
  // copy msid into Buffer
  //
  CopyMem (Msid, RecvMsid, *MsidLength);
  return TcgResultSuccess;
}
 
TCG_RESULT
OpalPyrite2GetActiveDataRemovalMechanism (
  IN  OPAL_SESSION  *AdminSpSession,
  OUT UINT8         *ActiveDataRemovalMechanism
  )
{
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
  UINT8              MethodStatus;
  UINT32             Col;
  UINT8              RecvActiveDataRemovalMechanism;
  UINT8              Buffer[BUFFER_SIZE];
 
  NULL_CHECK (AdminSpSession);
  NULL_CHECK (ActiveDataRemovalMechanism);
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buffer, BUFFER_SIZE));
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, AdminSpSession->OpalBaseComId, AdminSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, AdminSpSession->TperSessionId, AdminSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, OPAL_UID_ADMIN_SP_DATA_REMOVAL_MECHANISM, TCG_UID_METHOD_GET));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
  ERROR_CHECK (TcgAddStartList (&CreateStruct));
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, TCG_CELL_BLOCK_START_COLUMN_NAME));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, OPAL_ADMIN_SP_ACTIVE_DATA_REMOVAL_MECHANISM_COL));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, TCG_CELL_BLOCK_END_COLUMN_NAME));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, OPAL_ADMIN_SP_ACTIVE_DATA_REMOVAL_MECHANISM_COL));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
  ERROR_CHECK (TcgAddEndList (&CreateStruct));
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  //
  // Send Get Active Data Removal Mechanism Method Call
  //
  ERROR_CHECK (OpalPerformMethod (AdminSpSession, Size, Buffer, BUFFER_SIZE, &ParseStruct, &MethodStatus, 0));
  METHOD_STATUS_ERROR_CHECK (MethodStatus, TcgResultFailure);
 
  ERROR_CHECK (TcgGetNextStartList (&ParseStruct));
  ERROR_CHECK (TcgGetNextStartList (&ParseStruct));
  ERROR_CHECK (TcgGetNextStartName (&ParseStruct));
  ERROR_CHECK (TcgGetNextUINT32 (&ParseStruct, &Col));
  ERROR_CHECK (TcgGetNextUINT8 (&ParseStruct, &RecvActiveDataRemovalMechanism));
  ERROR_CHECK (TcgGetNextEndName (&ParseStruct));
  ERROR_CHECK (TcgGetNextEndList (&ParseStruct));
  ERROR_CHECK (TcgGetNextEndList (&ParseStruct));
  ERROR_CHECK (TcgGetNextEndOfData (&ParseStruct));
 
  if (Col != OPAL_ADMIN_SP_ACTIVE_DATA_REMOVAL_MECHANISM_COL) {
    DEBUG ((DEBUG_INFO, "ERROR: got col %u, expected %u\n", Col, OPAL_ADMIN_SP_ACTIVE_DATA_REMOVAL_MECHANISM_COL));
    return TcgResultFailure;
  }
 
  if (RecvActiveDataRemovalMechanism >= ResearvedMechanism) {
    return TcgResultFailure;
  }
 
  //
  // Copy active data removal mechanism into Buffer
  //
  CopyMem (ActiveDataRemovalMechanism, &RecvActiveDataRemovalMechanism, sizeof (RecvActiveDataRemovalMechanism));
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalAdminRevert (
  OPAL_SESSION  *LockingSpSession,
  BOOLEAN       KeepUserData,
  UINT8         *MethodStatus
  )
{
  UINT8              Buf[BUFFER_SIZE];
  TCG_CREATE_STRUCT  CreateStruct;
  UINT32             Size;
  TCG_PARSE_STRUCT   ParseStruct;
  TCG_RESULT         Ret;
 
  NULL_CHECK (LockingSpSession);
  NULL_CHECK (MethodStatus);
 
  //
  // ReadLocked or WriteLocked must be False (per Opal spec) to guarantee revertSP can keep user Data
  //
  if (KeepUserData) {
    //
    // set readlocked and writelocked to false
    //
    Ret = OpalUpdateGlobalLockingRange (
            LockingSpSession,
            FALSE,
            FALSE,
            MethodStatus
            );
 
    if ((Ret != TcgResultSuccess) || (*MethodStatus != TCG_METHOD_STATUS_CODE_SUCCESS)) {
      //
      // bail out
      //
      return Ret;
    }
  }
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, LockingSpSession->OpalBaseComId, LockingSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, LockingSpSession->TperSessionId, LockingSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, TCG_UID_THIS_SP, OPAL_LOCKING_SP_REVERTSP_METHOD));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
 
  if (KeepUserData) {
    //
    // optional parameter to keep Data after revert
    //
    ERROR_CHECK (TcgAddStartName (&CreateStruct));
    ERROR_CHECK (TcgAddUINT32 (&CreateStruct, 0x060000));      // weird Value but that's what spec says
    ERROR_CHECK (TcgAddBOOLEAN (&CreateStruct, KeepUserData));
    ERROR_CHECK (TcgAddEndName (&CreateStruct));
  }
 
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  //
  // Send RevertSP method call
  //
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
  //
  // Session is immediately ended by device after successful revertsp, so no need to end Session
  //
  if (*MethodStatus == TCG_METHOD_STATUS_CODE_SUCCESS) {
    //
    // Caller should take ownership again
    //
    return TcgResultSuccess;
  } else {
    //
    // End Session
    //
    METHOD_STATUS_ERROR_CHECK (*MethodStatus, TcgResultSuccess);     // exit with success on method failure - user must inspect MethodStatus
  }
 
  return TcgResultSuccess;
}
 
TCG_RESULT
OpalPyrite2AdminRevert (
  OPAL_SESSION  *LockingSpSession,
  BOOLEAN       KeepUserData,
  UINT8         *MethodStatus,
  UINT32        EstimateTimeCost
  )
{
  UINT8              Buf[BUFFER_SIZE];
  TCG_CREATE_STRUCT  CreateStruct;
  UINT32             Size;
  TCG_PARSE_STRUCT   ParseStruct;
  TCG_RESULT         Ret;
 
  NULL_CHECK (LockingSpSession);
  NULL_CHECK (MethodStatus);
 
  //
  // ReadLocked or WriteLocked must be False (per Opal spec) to guarantee revertSP can keep user Data
  //
  if (KeepUserData) {
    //
    // set readlocked and writelocked to false
    //
    Ret = OpalUpdateGlobalLockingRange (
            LockingSpSession,
            FALSE,
            FALSE,
            MethodStatus
            );
 
    if ((Ret != TcgResultSuccess) || (*MethodStatus != TCG_METHOD_STATUS_CODE_SUCCESS)) {
      //
      // bail out
      //
      return Ret;
    }
  }
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, LockingSpSession->OpalBaseComId, LockingSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, LockingSpSession->TperSessionId, LockingSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, TCG_UID_THIS_SP, OPAL_LOCKING_SP_REVERTSP_METHOD));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
 
  if (KeepUserData) {
    //
    // optional parameter to keep Data after revert
    //
    ERROR_CHECK (TcgAddStartName (&CreateStruct));
    ERROR_CHECK (TcgAddUINT32 (&CreateStruct, 0x060000));      // weird Value but that's what spec says
    ERROR_CHECK (TcgAddBOOLEAN (&CreateStruct, KeepUserData));
    ERROR_CHECK (TcgAddEndName (&CreateStruct));
  }
 
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  //
  // Send RevertSP method call
  //
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, EstimateTimeCost));
 
  //
  // Session is immediately ended by device after successful revertsp, so no need to end Session
  //
  if (*MethodStatus == TCG_METHOD_STATUS_CODE_SUCCESS) {
    //
    // Caller should take ownership again
    //
    return TcgResultSuccess;
  } else {
    //
    // End Session
    //
    METHOD_STATUS_ERROR_CHECK (*MethodStatus, TcgResultSuccess);     // exit with success on method failure - user must inspect MethodStatus
  }
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalActivateLockingSp (
  OPAL_SESSION  *AdminSpSession,
  UINT8         *MethodStatus
  )
{
  UINT8              Buf[BUFFER_SIZE];
  TCG_CREATE_STRUCT  CreateStruct;
  UINT32             Size;
  TCG_PARSE_STRUCT   ParseStruct;
 
  NULL_CHECK (AdminSpSession);
  NULL_CHECK (MethodStatus);
 
  //
  // Call Activate method on Locking SP
  //
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, AdminSpSession->OpalBaseComId, AdminSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, AdminSpSession->TperSessionId, AdminSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, OPAL_UID_LOCKING_SP, OPAL_ADMIN_SP_ACTIVATE_METHOD));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  //
  // Send Activate method call
  //
  ERROR_CHECK (OpalPerformMethod (AdminSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
  METHOD_STATUS_ERROR_CHECK (*MethodStatus, TcgResultSuccess); // exit with success on method failure - user must inspect MethodStatus
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalSetPassword (
  OPAL_SESSION  *Session,
  TCG_UID       CpinRowUid,
  const VOID    *NewPin,
  UINT32        NewPinLength,
  UINT8         *MethodStatus
  )
{
  UINT8              Buf[BUFFER_SIZE];
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
 
  NULL_CHECK (Session);
  NULL_CHECK (NewPin);
  NULL_CHECK (MethodStatus);
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (
    TcgCreateSetCPin (
      &CreateStruct,
      &Size,
      Session->OpalBaseComId,
      Session->ComIdExtension,
      Session->TperSessionId,
      Session->HostSessionId,
      CpinRowUid,
      NewPin,
      NewPinLength
      )
    );
 
  ERROR_CHECK (OpalPerformMethod (Session, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
  // exit with success on method failure - user must inspect MethodStatus
  METHOD_STATUS_ERROR_CHECK (*MethodStatus, TcgResultSuccess);
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalSetLockingSpAuthorityEnabledAndPin (
  OPAL_SESSION  *LockingSpSession,
  TCG_UID       CpinRowUid,
  TCG_UID       AuthorityUid,
  const VOID    *NewPin,
  UINT32        NewPinLength,
  UINT8         *MethodStatus
  )
{
  UINT8              Buf[BUFFER_SIZE];
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
  TCG_UID            ActiveKey;
  TCG_RESULT         Ret;
 
  NULL_CHECK (LockingSpSession);
  NULL_CHECK (NewPin);
  NULL_CHECK (MethodStatus);
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (
    TcgSetAuthorityEnabled (
      &CreateStruct,
      &Size,
      LockingSpSession->OpalBaseComId,
      LockingSpSession->ComIdExtension,
      LockingSpSession->TperSessionId,
      LockingSpSession->HostSessionId,
      AuthorityUid,
      TRUE
      )
    );
 
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
  if (*MethodStatus != TCG_METHOD_STATUS_CODE_SUCCESS) {
    DEBUG ((DEBUG_INFO, "Send Set Authority error\n"));
    return TcgResultFailure;
  }
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
 
  ERROR_CHECK (
    TcgCreateSetCPin (
      &CreateStruct,
      &Size,
      LockingSpSession->OpalBaseComId,
      LockingSpSession->ComIdExtension,
      LockingSpSession->TperSessionId,
      LockingSpSession->HostSessionId,
      CpinRowUid,
      NewPin,
      NewPinLength
      )
    );
 
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
  //
  // allow user1 to set global range to unlocked/locked by modifying ACE_Locking_GlobalRange_SetRdLocked/SetWrLocked
  //
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (
    TcgCreateSetAce (
      &CreateStruct,
      &Size,
      LockingSpSession->OpalBaseComId,
      LockingSpSession->ComIdExtension,
      LockingSpSession->TperSessionId,
      LockingSpSession->HostSessionId,
      OPAL_LOCKING_SP_ACE_LOCKING_GLOBALRANGE_SET_RDLOCKED,
      OPAL_LOCKING_SP_USER1_AUTHORITY,
      TCG_ACE_EXPRESSION_OR,
      OPAL_LOCKING_SP_ADMINS_AUTHORITY
      )
    );
 
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
  if (*MethodStatus != TCG_METHOD_STATUS_CODE_SUCCESS) {
    DEBUG ((DEBUG_INFO, "Update ACE for RDLOCKED failed\n"));
    return TcgResultFailure;
  }
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (
    TcgCreateSetAce (
      &CreateStruct,
      &Size,
      LockingSpSession->OpalBaseComId,
      LockingSpSession->ComIdExtension,
      LockingSpSession->TperSessionId,
      LockingSpSession->HostSessionId,
      OPAL_LOCKING_SP_ACE_LOCKING_GLOBALRANGE_SET_WRLOCKED,
      OPAL_LOCKING_SP_USER1_AUTHORITY,
      TCG_ACE_EXPRESSION_OR,
      OPAL_LOCKING_SP_ADMINS_AUTHORITY
      )
    );
 
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
  if (*MethodStatus != TCG_METHOD_STATUS_CODE_SUCCESS) {
    DEBUG ((DEBUG_INFO, "Update ACE for WRLOCKED failed\n"));
    return TcgResultFailure;
  }
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (OpalCreateRetrieveGlobalLockingRangeActiveKey (LockingSpSession, &CreateStruct, &Size));
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
  //
  // For Pyrite type SSC, it not supports Active Key.
  // So here add check logic before enable it.
  //
  Ret = OpalParseRetrieveGlobalLockingRangeActiveKey (&ParseStruct, &ActiveKey);
  if (Ret == TcgResultSuccess) {
    ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
    ERROR_CHECK (
      TcgCreateSetAce (
        &CreateStruct,
        &Size,
        LockingSpSession->OpalBaseComId,
        LockingSpSession->ComIdExtension,
        LockingSpSession->TperSessionId,
        LockingSpSession->HostSessionId,
        (ActiveKey == OPAL_LOCKING_SP_K_AES_256_GLOBALRANGE_KEY) ? OPAL_LOCKING_SP_ACE_K_AES_256_GLOBALRANGE_GENKEY : OPAL_LOCKING_SP_ACE_K_AES_128_GLOBALRANGE_GENKEY,
        OPAL_LOCKING_SP_USER1_AUTHORITY,
        TCG_ACE_EXPRESSION_OR,
        OPAL_LOCKING_SP_ADMINS_AUTHORITY
        )
      );
 
    ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
    if (*MethodStatus != TCG_METHOD_STATUS_CODE_SUCCESS) {
      DEBUG ((DEBUG_INFO, "Update ACE for GLOBALRANGE_GENKEY failed\n"));
      //
      // Disable user1 if all permissions are not granted.
      //
      return TcgResultFailure;
    }
  }
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (
    TcgCreateSetAce (
      &CreateStruct,
      &Size,
      LockingSpSession->OpalBaseComId,
      LockingSpSession->ComIdExtension,
      LockingSpSession->TperSessionId,
      LockingSpSession->HostSessionId,
      OPAL_LOCKING_SP_ACE_LOCKING_GLOBALRANGE_GET_ALL,
      OPAL_LOCKING_SP_USER1_AUTHORITY,
      TCG_ACE_EXPRESSION_OR,
      OPAL_LOCKING_SP_ADMINS_AUTHORITY
      )
    );
 
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
  if (*MethodStatus != TCG_METHOD_STATUS_CODE_SUCCESS) {
    DEBUG ((DEBUG_INFO, "Update ACE for OPAL_LOCKING_SP_ACE_LOCKING_GLOBALRANGE_GET_ALL failed\n"));
    return TcgResultFailure;
  }
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalDisableUser (
  OPAL_SESSION  *LockingSpSession,
  UINT8         *MethodStatus
  )
{
  UINT8              Buf[BUFFER_SIZE];
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
 
  NULL_CHECK (LockingSpSession);
  NULL_CHECK (MethodStatus);
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (
    TcgSetAuthorityEnabled (
      &CreateStruct,
      &Size,
      LockingSpSession->OpalBaseComId,
      LockingSpSession->ComIdExtension,
      LockingSpSession->TperSessionId,
      LockingSpSession->HostSessionId,
      OPAL_LOCKING_SP_USER1_AUTHORITY,
      FALSE
      )
    );
 
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalGlobalLockingRangeGenKey (
  OPAL_SESSION  *LockingSpSession,
  UINT8         *MethodStatus
  )
{
  UINT8              Buf[BUFFER_SIZE];
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
  TCG_UID            ActiveKey;
 
  NULL_CHECK (LockingSpSession);
  NULL_CHECK (MethodStatus);
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  //
  // retrieve the activekey in order to know which globalrange key to generate
  //
  ERROR_CHECK (OpalCreateRetrieveGlobalLockingRangeActiveKey (LockingSpSession, &CreateStruct, &Size));
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
  METHOD_STATUS_ERROR_CHECK (*MethodStatus, TcgResultSuccess);
 
  ERROR_CHECK (OpalParseRetrieveGlobalLockingRangeActiveKey (&ParseStruct, &ActiveKey));
 
  //
  // call genkey on ActiveKey UID
  //
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, LockingSpSession->OpalBaseComId, LockingSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, LockingSpSession->TperSessionId, LockingSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, ActiveKey, TCG_UID_METHOD_GEN_KEY));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalUpdateGlobalLockingRange (
  OPAL_SESSION  *LockingSpSession,
  BOOLEAN       ReadLocked,
  BOOLEAN       WriteLocked,
  UINT8         *MethodStatus
  )
{
  UINT8              Buf[BUFFER_SIZE];
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
 
  NULL_CHECK (LockingSpSession);
  NULL_CHECK (MethodStatus);
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
 
  //
  // set global locking range values
  //
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, LockingSpSession->OpalBaseComId, LockingSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, LockingSpSession->TperSessionId, LockingSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, OPAL_LOCKING_SP_LOCKING_GLOBALRANGE, TCG_UID_METHOD_SET));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, 0x01));                       // "Values"
  ERROR_CHECK (TcgAddStartList (&CreateStruct));
 
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, 0x07));                       // "ReadLocked"
  ERROR_CHECK (TcgAddBOOLEAN (&CreateStruct, ReadLocked));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
 
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, 0x08));                       // "WriteLocked"
  ERROR_CHECK (TcgAddBOOLEAN (&CreateStruct, WriteLocked));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
 
  ERROR_CHECK (TcgAddEndList (&CreateStruct));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
  METHOD_STATUS_ERROR_CHECK (*MethodStatus, TcgResultSuccess);
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalSetLockingRange (
  OPAL_SESSION  *LockingSpSession,
  TCG_UID       LockingRangeUid,
  UINT64        RangeStart,
  UINT64        RangeLength,
  BOOLEAN       ReadLockEnabled,
  BOOLEAN       WriteLockEnabled,
  BOOLEAN       ReadLocked,
  BOOLEAN       WriteLocked,
  UINT8         *MethodStatus
  )
{
  UINT8              Buf[BUFFER_SIZE];
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
 
  NULL_CHECK (LockingSpSession);
  NULL_CHECK (MethodStatus);
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
 
  //
  // set locking range values
  //
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, LockingSpSession->OpalBaseComId, LockingSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, LockingSpSession->TperSessionId, LockingSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, LockingRangeUid, TCG_UID_METHOD_SET));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, 0x01));                        // "Values"
  ERROR_CHECK (TcgAddStartList (&CreateStruct));
 
  //
  // range start and range Length only apply to non-global locking ranges
  //
  if (LockingRangeUid != OPAL_LOCKING_SP_LOCKING_GLOBALRANGE) {
    ERROR_CHECK (TcgAddStartName (&CreateStruct));
    ERROR_CHECK (TcgAddUINT8 (&CreateStruct, 0x03));                       // "RangeStart"
    ERROR_CHECK (TcgAddUINT64 (&CreateStruct, RangeStart));
    ERROR_CHECK (TcgAddEndName (&CreateStruct));
 
    ERROR_CHECK (TcgAddStartName (&CreateStruct));
    ERROR_CHECK (TcgAddUINT8 (&CreateStruct, 0x04));                       // "RangeLength"
    ERROR_CHECK (TcgAddUINT64 (&CreateStruct, RangeLength));
    ERROR_CHECK (TcgAddEndName (&CreateStruct));
  }
 
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, 0x05));                       // "ReadLockEnabled"
  ERROR_CHECK (TcgAddBOOLEAN (&CreateStruct, ReadLockEnabled));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
 
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, 0x06));                       // "WriteLockEnabled"
  ERROR_CHECK (TcgAddBOOLEAN (&CreateStruct, WriteLockEnabled));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
 
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, 0x07));                       // "ReadLocked"
  ERROR_CHECK (TcgAddBOOLEAN (&CreateStruct, ReadLocked));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
 
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, 0x08));                       // "WriteLocked"
  ERROR_CHECK (TcgAddBOOLEAN (&CreateStruct, WriteLocked));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
 
  ERROR_CHECK (TcgAddEndList (&CreateStruct));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, MethodStatus, 0));
  // Exit with success on method failure - user must inspect MethodStatus
  METHOD_STATUS_ERROR_CHECK (*MethodStatus, TcgResultSuccess);
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalCreateRetrieveGlobalLockingRangeActiveKey (
  const OPAL_SESSION  *Session,
  TCG_CREATE_STRUCT   *CreateStruct,
  UINT32              *Size
  )
{
  NULL_CHECK (Session);
  NULL_CHECK (CreateStruct);
  NULL_CHECK (Size);
 
  // Retrieve the activekey in order to know which globalrange key to generate
  ERROR_CHECK (TcgStartComPacket (CreateStruct, Session->OpalBaseComId, Session->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (CreateStruct, Session->TperSessionId, Session->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (CreateStruct, OPAL_LOCKING_SP_LOCKING_GLOBALRANGE, TCG_UID_METHOD_GET));
  ERROR_CHECK (TcgStartParameters (CreateStruct));
  ERROR_CHECK (TcgAddStartList (CreateStruct));
  ERROR_CHECK (TcgAddStartName (CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (CreateStruct, TCG_CELL_BLOCK_START_COLUMN_NAME));
  ERROR_CHECK (TcgAddUINT8 (CreateStruct, 0x0A));         // ActiveKey
  ERROR_CHECK (TcgAddEndName (CreateStruct));
  ERROR_CHECK (TcgAddStartName (CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (CreateStruct, TCG_CELL_BLOCK_END_COLUMN_NAME));
  ERROR_CHECK (TcgAddUINT8 (CreateStruct, 0x0A));
  ERROR_CHECK (TcgAddEndName (CreateStruct));
  ERROR_CHECK (TcgAddEndList (CreateStruct));
  ERROR_CHECK (TcgEndParameters (CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (CreateStruct));
  ERROR_CHECK (TcgEndPacket (CreateStruct));
  ERROR_CHECK (TcgEndComPacket (CreateStruct, Size));
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalParseRetrieveGlobalLockingRangeActiveKey (
  TCG_PARSE_STRUCT  *ParseStruct,
  TCG_UID           *ActiveKey
  )
{
  UINT32  ColumnName;
 
  NULL_CHECK (ParseStruct);
  NULL_CHECK (ActiveKey);
 
  // parse response
  ERROR_CHECK (TcgGetNextStartList (ParseStruct));
  ERROR_CHECK (TcgGetNextStartList (ParseStruct));
  ERROR_CHECK (TcgGetNextStartName (ParseStruct));
  ERROR_CHECK (TcgGetNextUINT32 (ParseStruct, &ColumnName));
  ERROR_CHECK (TcgGetNextTcgUid (ParseStruct, ActiveKey));
  ERROR_CHECK (TcgGetNextEndName (ParseStruct));
  ERROR_CHECK (TcgGetNextEndList (ParseStruct));
  ERROR_CHECK (TcgGetNextEndList (ParseStruct));
  ERROR_CHECK (TcgGetNextEndOfData (ParseStruct));
 
  if (ColumnName != 0x0A) {
    DEBUG ((DEBUG_INFO, "Unexpected column name %u (exp 0x0A)\n", ColumnName));
    return TcgResultFailure;
  }
 
  if ((*ActiveKey != OPAL_LOCKING_SP_K_AES_256_GLOBALRANGE_KEY) && (*ActiveKey != OPAL_LOCKING_SP_K_AES_128_GLOBALRANGE_KEY)) {
    DEBUG ((DEBUG_INFO, "Unexpected gen key %u (exp %u or %u)\n", *ActiveKey, OPAL_LOCKING_SP_K_AES_256_GLOBALRANGE_KEY, OPAL_LOCKING_SP_K_AES_128_GLOBALRANGE_KEY));
    return TcgResultFailure;
  }
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalGetTryLimit (
  OPAL_SESSION  *LockingSpSession,
  TCG_UID       RowUid,
  UINT32        *TryLimit
  )
{
  TCG_CREATE_STRUCT  CreateStruct;
  TCG_PARSE_STRUCT   ParseStruct;
  UINT32             Size;
  UINT8              MethodStatus;
  UINT8              Buf[BUFFER_SIZE];
  UINT32             Col;
 
  NULL_CHECK (LockingSpSession);
  NULL_CHECK (TryLimit);
 
  ERROR_CHECK (TcgInitTcgCreateStruct (&CreateStruct, Buf, sizeof (Buf)));
  ERROR_CHECK (TcgStartComPacket (&CreateStruct, LockingSpSession->OpalBaseComId, LockingSpSession->ComIdExtension));
  ERROR_CHECK (TcgStartPacket (&CreateStruct, LockingSpSession->TperSessionId, LockingSpSession->HostSessionId, 0x0, 0x0, 0x0));
  ERROR_CHECK (TcgStartSubPacket (&CreateStruct, 0x0));
  ERROR_CHECK (TcgStartMethodCall (&CreateStruct, RowUid, TCG_UID_METHOD_GET));
  ERROR_CHECK (TcgStartParameters (&CreateStruct));
  ERROR_CHECK (TcgAddStartList (&CreateStruct));
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, TCG_CELL_BLOCK_START_COLUMN_NAME));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, OPAL_LOCKING_SP_C_PIN_TRYLIMIT_COL));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
  ERROR_CHECK (TcgAddStartName (&CreateStruct));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, TCG_CELL_BLOCK_END_COLUMN_NAME));
  ERROR_CHECK (TcgAddUINT8 (&CreateStruct, OPAL_LOCKING_SP_C_PIN_TRYLIMIT_COL));
  ERROR_CHECK (TcgAddEndName (&CreateStruct));
  ERROR_CHECK (TcgAddEndList (&CreateStruct));
  ERROR_CHECK (TcgEndParameters (&CreateStruct));
  ERROR_CHECK (TcgEndMethodCall (&CreateStruct));
  ERROR_CHECK (TcgEndSubPacket (&CreateStruct));
  ERROR_CHECK (TcgEndPacket (&CreateStruct));
  ERROR_CHECK (TcgEndComPacket (&CreateStruct, &Size));
 
  ERROR_CHECK (OpalPerformMethod (LockingSpSession, Size, Buf, sizeof (Buf), &ParseStruct, &MethodStatus, 0));
  METHOD_STATUS_ERROR_CHECK (MethodStatus, TcgResultFailure);
 
  ERROR_CHECK (TcgGetNextStartList (&ParseStruct));
  ERROR_CHECK (TcgGetNextStartList (&ParseStruct));
  ERROR_CHECK (TcgGetNextStartName (&ParseStruct));
  ERROR_CHECK (TcgGetNextUINT32 (&ParseStruct, &Col));
  ERROR_CHECK (TcgGetNextUINT32 (&ParseStruct, TryLimit));
  ERROR_CHECK (TcgGetNextEndName (&ParseStruct));
  ERROR_CHECK (TcgGetNextEndList (&ParseStruct));
  ERROR_CHECK (TcgGetNextEndList (&ParseStruct));
  ERROR_CHECK (TcgGetNextEndOfData (&ParseStruct));
 
  if (Col != OPAL_LOCKING_SP_C_PIN_TRYLIMIT_COL) {
    DEBUG ((DEBUG_INFO, "ERROR: got col %u, expected %u\n", Col, OPAL_LOCKING_SP_C_PIN_TRYLIMIT_COL));
    return TcgResultFailure;
  }
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalGetSupportedAttributesInfo (
  IN  OPAL_SESSION                 *Session,
  OUT OPAL_DISK_SUPPORT_ATTRIBUTE  *SupportedAttributes,
  OUT UINT16                       *OpalBaseComId
  )
{
  UINT8                             Buffer[BUFFER_SIZE];
  TCG_SUPPORTED_SECURITY_PROTOCOLS  *SupportedProtocols;
  TCG_LEVEL0_DISCOVERY_HEADER       *DiscoveryHeader;
  OPAL_LEVEL0_FEATURE_DESCRIPTOR    *Feat;
  OPAL_LEVEL0_FEATURE_DESCRIPTOR    *Feat2;
  UINTN                             Size;
  UINTN                             Size2;
 
  NULL_CHECK (Session);
  NULL_CHECK (SupportedAttributes);
  NULL_CHECK (OpalBaseComId);
 
  ZeroMem (Buffer, BUFFER_SIZE);
  ZeroMem (SupportedAttributes, sizeof (OPAL_DISK_SUPPORT_ATTRIBUTE));
  ASSERT (sizeof (Buffer) >= sizeof (TCG_SUPPORTED_SECURITY_PROTOCOLS));
 
  //
  // Retrieve supported protocols verify security protocol 1 is supported
  //
  SupportedProtocols = (TCG_SUPPORTED_SECURITY_PROTOCOLS *)Buffer;
 
  //
  // Get list of supported protocols
  //
  if (OpalRetrieveSupportedProtocolList (Session, sizeof (TCG_SUPPORTED_SECURITY_PROTOCOLS), SupportedProtocols) == TcgResultFailure) {
    DEBUG ((DEBUG_INFO, "OpalRetrieveSupportedProtocolList failed\n"));
    return TcgResultFailure;
  }
 
  SupportedAttributes->Sp1        = TcgIsProtocolSupported (SupportedProtocols, TCG_OPAL_SECURITY_PROTOCOL_1);
  SupportedAttributes->Sp2        = TcgIsProtocolSupported (SupportedProtocols, TCG_OPAL_SECURITY_PROTOCOL_2);
  SupportedAttributes->SpIeee1667 = TcgIsProtocolSupported (SupportedProtocols, TCG_SECURITY_PROTOCOL_IEEE_1667);
 
  DEBUG ((
    DEBUG_INFO,
    "Supported Protocols: Sp1 %d Sp2: %d SpIeee1667 %d \n",
    SupportedAttributes->Sp1,
    SupportedAttributes->Sp2,
    SupportedAttributes->SpIeee1667
    ));
 
  //
  // Perform level 0 discovery and assign desired feature info to Opal Disk structure
  //
  ZeroMem (Buffer, BUFFER_SIZE);
  if (OpalRetrieveLevel0DiscoveryHeader (Session, BUFFER_SIZE, Buffer) == TcgResultFailure) {
    DEBUG ((DEBUG_INFO, "OpalRetrieveLevel0DiscoveryHeader failed\n"));
    return TcgResultFailure;
  }
 
  //
  // Check for required feature descriptors
  //
  DiscoveryHeader = (TCG_LEVEL0_DISCOVERY_HEADER *)Buffer;
 
  Size                          = 0;
  Feat                          = (OPAL_LEVEL0_FEATURE_DESCRIPTOR *)TcgGetFeature (DiscoveryHeader, TCG_FEATURE_OPAL_SSC_V2_0_0, &Size);
  SupportedAttributes->OpalSsc2 = (Feat != NULL);
 
  *OpalBaseComId = TCG_RESERVED_COMID;
 
  //
  // Check Opal SCC V2 has valid settings for SID C_PIN on revert
  //
  if (SupportedAttributes->OpalSsc2 && (Size >= sizeof (OPAL_SSCV2_FEATURE_DESCRIPTOR))) {
    //
    // Want opposite polarity b/c Value is greater than a bit, but we only care about non-zero vs zero
    //
    SupportedAttributes->InitCpinIndicator = (Feat->OpalSscV2.InitialCPINSIDPIN == 0);
    SupportedAttributes->CpinUponRevert    = (Feat->OpalSscV2.CPINSIDPINRevertBehavior == 0);
    DEBUG ((
      DEBUG_INFO,
      "Opal SSC V2 InitCpinIndicator %d  CpinUponRevert %d \n",
      SupportedAttributes->InitCpinIndicator,
      SupportedAttributes->CpinUponRevert
      ));
    *OpalBaseComId = SwapBytes16 (Feat->OpalSscV2.BaseComdIdBE);
  }
 
  Size                             = 0;
  Feat                             = (OPAL_LEVEL0_FEATURE_DESCRIPTOR *)TcgGetFeature (DiscoveryHeader, TCG_FEATURE_OPAL_SSC_LITE, &Size);
  SupportedAttributes->OpalSscLite = (Feat != NULL);
 
  if ((Feat != NULL) && (Size >= sizeof (OPAL_SSCLITE_FEATURE_DESCRIPTOR))) {
    if (*OpalBaseComId == TCG_RESERVED_COMID) {
      //
      // Pin values used always match up with ComId used
      //
      *OpalBaseComId                         = SwapBytes16 (Feat->OpalSscLite.BaseComdIdBE);
      SupportedAttributes->InitCpinIndicator = (Feat->OpalSscV2.InitialCPINSIDPIN == 0);
      SupportedAttributes->CpinUponRevert    = (Feat->OpalSscV2.CPINSIDPINRevertBehavior == 0);
      DEBUG ((
        DEBUG_INFO,
        "Opal SSC Lite InitCpinIndicator %d  CpinUponRevert %d \n",
        SupportedAttributes->InitCpinIndicator,
        SupportedAttributes->CpinUponRevert
        ));
    }
  }
 
  //
  // For some pyrite 2.0 device, it contains both pyrite 1.0 and 2.0 feature data.
  // so here try to get data from pyrite 2.0 feature data first.
  //
  Size  = 0;
  Feat  = (OPAL_LEVEL0_FEATURE_DESCRIPTOR *)TcgGetFeature (DiscoveryHeader, TCG_FEATURE_PYRITE_SSC, &Size);
  Size2 = 0;
  Feat2 = (OPAL_LEVEL0_FEATURE_DESCRIPTOR *)TcgGetFeature (DiscoveryHeader, TCG_FEATURE_PYRITE_SSC_V2_0_0, &Size2);
  if ((Feat2 != NULL) && (Size2 >= sizeof (PYRITE_SSCV2_FEATURE_DESCRIPTOR))) {
    SupportedAttributes->PyriteSscV2 = TRUE;
    if (*OpalBaseComId == TCG_RESERVED_COMID) {
      *OpalBaseComId                         = SwapBytes16 (Feat2->PyriteSscV2.BaseComdIdBE);
      SupportedAttributes->InitCpinIndicator = (Feat2->PyriteSscV2.InitialCPINSIDPIN == 0);
      SupportedAttributes->CpinUponRevert    = (Feat2->PyriteSscV2.CPINSIDPINRevertBehavior == 0);
      DEBUG ((
        DEBUG_INFO,
        "Pyrite SSC V2 InitCpinIndicator %d  CpinUponRevert %d \n",
        SupportedAttributes->InitCpinIndicator,
        SupportedAttributes->CpinUponRevert
        ));
    }
  } else {
    SupportedAttributes->PyriteSsc = (Feat != NULL);
    if ((Feat != NULL) && (Size >= sizeof (PYRITE_SSC_FEATURE_DESCRIPTOR))) {
      if (*OpalBaseComId == TCG_RESERVED_COMID) {
        *OpalBaseComId                         = SwapBytes16 (Feat->PyriteSsc.BaseComdIdBE);
        SupportedAttributes->InitCpinIndicator = (Feat->PyriteSsc.InitialCPINSIDPIN == 0);
        SupportedAttributes->CpinUponRevert    = (Feat->PyriteSsc.CPINSIDPINRevertBehavior == 0);
        DEBUG ((
          DEBUG_INFO,
          "Pyrite SSC InitCpinIndicator %d  CpinUponRevert %d \n",
          SupportedAttributes->InitCpinIndicator,
          SupportedAttributes->CpinUponRevert
          ));
      }
    }
  }
 
  Size                          = 0;
  Feat                          = (OPAL_LEVEL0_FEATURE_DESCRIPTOR *)TcgGetFeature (DiscoveryHeader, TCG_FEATURE_OPAL_SSC_V1_0_0, &Size);
  SupportedAttributes->OpalSsc1 = (Feat != NULL);
  if ((Feat != NULL) && (Size >= sizeof (OPAL_SSCV1_FEATURE_DESCRIPTOR))) {
    if (*OpalBaseComId == TCG_RESERVED_COMID) {
      *OpalBaseComId = SwapBytes16 (Feat->OpalSscV1.BaseComdIdBE);
    }
  }
 
  Size = 0;
  Feat = (OPAL_LEVEL0_FEATURE_DESCRIPTOR *)TcgGetFeature (DiscoveryHeader, TCG_FEATURE_LOCKING, &Size);
  if ((Feat != NULL) && (Size >= sizeof (TCG_LOCKING_FEATURE_DESCRIPTOR))) {
    SupportedAttributes->MediaEncryption = Feat->Locking.MediaEncryption;
    DEBUG ((DEBUG_INFO, "SupportedAttributes->MediaEncryption 0x%X \n", SupportedAttributes->MediaEncryption));
  }
 
  Size = 0;
  Feat = (OPAL_LEVEL0_FEATURE_DESCRIPTOR *)TcgGetFeature (DiscoveryHeader, TCG_FEATURE_BLOCK_SID, &Size);
  if ((Feat != NULL) && (Size >= sizeof (TCG_BLOCK_SID_FEATURE_DESCRIPTOR))) {
    SupportedAttributes->BlockSid = TRUE;
    DEBUG ((DEBUG_INFO, "BlockSid Supported!!! Current Status is 0x%X \n", Feat->BlockSid.SIDBlockedState));
  } else {
    DEBUG ((DEBUG_INFO, "BlockSid Unsupported!!!"));
  }
 
  Size = 0;
  Feat = (OPAL_LEVEL0_FEATURE_DESCRIPTOR *)TcgGetFeature (DiscoveryHeader, TCG_FEATURE_DATA_REMOVAL, &Size);
  if ((Feat != NULL) && (Size >= sizeof (DATA_REMOVAL_FEATURE_DESCRIPTOR))) {
    SupportedAttributes->DataRemoval = TRUE;
    DEBUG ((DEBUG_INFO, "DataRemoval Feature Supported!\n"));
    DEBUG ((DEBUG_INFO, "Operation Processing = 0x%x\n", Feat->DataRemoval.OperationProcessing));
    DEBUG ((DEBUG_INFO, "RemovalMechanism = 0x%x\n", Feat->DataRemoval.RemovalMechanism));
    DEBUG ((DEBUG_INFO, "BIT0 :: Format = 0x%x, Time = 0x%x\n", Feat->DataRemoval.FormatBit0, SwapBytes16 (Feat->DataRemoval.TimeBit0)));
    DEBUG ((DEBUG_INFO, "BIT1 :: Format = 0x%x, Time = 0x%x\n", Feat->DataRemoval.FormatBit1, SwapBytes16 (Feat->DataRemoval.TimeBit1)));
    DEBUG ((DEBUG_INFO, "BIT2 :: Format = 0x%x, Time = 0x%x\n", Feat->DataRemoval.FormatBit2, SwapBytes16 (Feat->DataRemoval.TimeBit2)));
    DEBUG ((DEBUG_INFO, "BIT3 :: Format = 0x%x, Time = 0x%x\n", Feat->DataRemoval.FormatBit3, SwapBytes16 (Feat->DataRemoval.TimeBit3)));
    DEBUG ((DEBUG_INFO, "BIT4 :: Format = 0x%x, Time = 0x%x\n", Feat->DataRemoval.FormatBit4, SwapBytes16 (Feat->DataRemoval.TimeBit4)));
  }
 
  DEBUG ((DEBUG_INFO, "Base COMID 0x%04X \n", *OpalBaseComId));
 
  return TcgResultSuccess;
}
 
TCG_RESULT
EFIAPI
OpalGetLockingInfo (
  OPAL_SESSION                    *Session,
  TCG_LOCKING_FEATURE_DESCRIPTOR  *LockingFeature
  )
{
  UINT8                           Buffer[BUFFER_SIZE];
  TCG_LEVEL0_DISCOVERY_HEADER     *DiscoveryHeader;
  OPAL_LEVEL0_FEATURE_DESCRIPTOR  *Feat;
  UINTN                           Size;
 
  NULL_CHECK (Session);
  NULL_CHECK (LockingFeature);
 
  ZeroMem (Buffer, BUFFER_SIZE);
  ASSERT (sizeof (Buffer) >= sizeof (TCG_SUPPORTED_SECURITY_PROTOCOLS));
 
  if (OpalRetrieveLevel0DiscoveryHeader (Session, BUFFER_SIZE, Buffer) == TcgResultFailure) {
    DEBUG ((DEBUG_INFO, "OpalRetrieveLevel0DiscoveryHeader failed\n"));
    return TcgResultFailure;
  }
 
  DiscoveryHeader = (TCG_LEVEL0_DISCOVERY_HEADER *)Buffer;
 
  Size = 0;
  Feat = (OPAL_LEVEL0_FEATURE_DESCRIPTOR *)TcgGetFeature (DiscoveryHeader, TCG_FEATURE_LOCKING, &Size);
  if ((Feat != NULL) && (Size >= sizeof (TCG_LOCKING_FEATURE_DESCRIPTOR))) {
    CopyMem (LockingFeature, &Feat->Locking, sizeof (TCG_LOCKING_FEATURE_DESCRIPTOR));
  }
 
  return TcgResultSuccess;
}
 
TCG_RESULT
OpalGetFeatureDescriptor (
  IN     OPAL_SESSION  *Session,
  IN     UINT16        FeatureCode,
  IN OUT UINTN         *DataSize,
  OUT    VOID          *Data
  )
{
  UINT8                           Buffer[BUFFER_SIZE];
  TCG_LEVEL0_DISCOVERY_HEADER     *DiscoveryHeader;
  OPAL_LEVEL0_FEATURE_DESCRIPTOR  *Feat;
  UINTN                           Size;
 
  NULL_CHECK (Session);
  NULL_CHECK (DataSize);
  NULL_CHECK (Data);
 
  ZeroMem (Buffer, BUFFER_SIZE);
  ASSERT (sizeof (Buffer) >= sizeof (TCG_SUPPORTED_SECURITY_PROTOCOLS));
 
  if (OpalRetrieveLevel0DiscoveryHeader (Session, BUFFER_SIZE, Buffer) == TcgResultFailure) {
    DEBUG ((DEBUG_INFO, "OpalRetrieveLevel0DiscoveryHeader failed\n"));
    return TcgResultFailure;
  }
 
  DiscoveryHeader = (TCG_LEVEL0_DISCOVERY_HEADER *)Buffer;
 
  Size = 0;
  Feat = (OPAL_LEVEL0_FEATURE_DESCRIPTOR *)TcgGetFeature (DiscoveryHeader, FeatureCode, &Size);
  if (Feat != NULL) {
    if (Size > *DataSize) {
      *DataSize = Size;
      return TcgResultFailureBufferTooSmall;
    }
 
    *DataSize = Size;
    CopyMem (Data, Feat, Size);
  }
 
  return TcgResultSuccess;
}
 
BOOLEAN
EFIAPI
OpalFeatureSupported (
  OPAL_DISK_SUPPORT_ATTRIBUTE  *SupportedAttributes
  )
{
  NULL_CHECK (SupportedAttributes);
 
  if (SupportedAttributes->Sp1 == 0) {
    return FALSE;
  }
 
  if ((SupportedAttributes->OpalSscLite == 0) &&
      (SupportedAttributes->OpalSsc1 == 0) &&
      (SupportedAttributes->OpalSsc2 == 0) &&
      (SupportedAttributes->PyriteSsc == 0) &&
      (SupportedAttributes->PyriteSscV2 == 0)
      )
  {
    return FALSE;
  }
 
  return TRUE;
}
 
BOOLEAN
EFIAPI
OpalFeatureEnabled (
  OPAL_DISK_SUPPORT_ATTRIBUTE     *SupportedAttributes,
  TCG_LOCKING_FEATURE_DESCRIPTOR  *LockingFeature
  )
{
  NULL_CHECK (SupportedAttributes);
  NULL_CHECK (LockingFeature);
 
  if (!OpalFeatureSupported (SupportedAttributes)) {
    return FALSE;
  }
 
  if (LockingFeature->LockingSupported && LockingFeature->LockingEnabled) {
    return TRUE;
  }
 
  return FALSE;
}
 
BOOLEAN
OpalDeviceLocked (
  OPAL_DISK_SUPPORT_ATTRIBUTE     *SupportedAttributes,
  TCG_LOCKING_FEATURE_DESCRIPTOR  *LockingFeature
  )
{
  NULL_CHECK (SupportedAttributes);
  NULL_CHECK (LockingFeature);
 
  if (!OpalFeatureEnabled (SupportedAttributes, LockingFeature)) {
    return FALSE;
  }
 
  return LockingFeature->Locked;
}