Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-12-27 16:58:09 +01:00
Code Issues Packages Projects Releases Wiki Activity
4beb089a18
CloverBootloader/MdeModulePkg/Bus/Ufs/UfsPassThruDxe/UfsPassThruHci.c
Sergey Isakov 7c0aa811ec initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 
Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 12:58:42 +03:00

2451 lines
80 KiB
C
Raw Blame History

/** @file
UfsPassThruDxe driver is used to produce EFI_EXT_SCSI_PASS_THRU protocol interface
for upper layer application to execute UFS-supported SCSI cmds.
Copyright (c) 2014 - 2019, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include "UfsPassThru.h"
/**
Read 32bits data from specified UFS MMIO register.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Offset The offset within the UFS Host Controller MMIO space to start
the memory operation.
@param[out] Value The data buffer to store.
@retval EFI_TIMEOUT The operation is time out.
@retval EFI_SUCCESS The operation succeeds.
@retval Others The operation fails.
**/
EFI_STATUS
UfsMmioRead32 (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UINTN Offset,
OUT UINT32 *Value
)
{
EDKII_UFS_HOST_CONTROLLER_PROTOCOL *UfsHc;
EFI_STATUS Status;
UfsHc = Private->UfsHostController;
Status = UfsHc->Read (UfsHc, EfiUfsHcWidthUint32, Offset, 1, Value);
return Status;
}
/**
Write 32bits data to specified UFS MMIO register.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Offset The offset within the UFS Host Controller MMIO space to start
the memory operation.
@param[in] Value The data to write.
@retval EFI_TIMEOUT The operation is time out.
@retval EFI_SUCCESS The operation succeeds.
@retval Others The operation fails.
**/
EFI_STATUS
UfsMmioWrite32 (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UINTN Offset,
IN UINT32 Value
)
{
EDKII_UFS_HOST_CONTROLLER_PROTOCOL *UfsHc;
EFI_STATUS Status;
UfsHc = Private->UfsHostController;
Status = UfsHc->Write (UfsHc, EfiUfsHcWidthUint32, Offset, 1, &Value);
return Status;
}
/**
Wait for the value of the specified system memory set to the test value.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Offset The offset within the UFS Host Controller MMIO space to start
the memory operation.
@param[in] MaskValue The mask value of memory.
@param[in] TestValue The test value of memory.
@param[in] Timeout The time out value for wait memory set, uses 100ns as a unit.
@retval EFI_TIMEOUT The system memory setting is time out.
@retval EFI_SUCCESS The system memory is correct set.
@retval Others The operation fails.
**/
EFI_STATUS
UfsWaitMemSet (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UINTN Offset,
IN UINT32 MaskValue,
IN UINT32 TestValue,
IN UINT64 Timeout
)
{
UINT32 Value;
UINT64 Delay;
BOOLEAN InfiniteWait;
EFI_STATUS Status;
if (Timeout == 0) {
InfiniteWait = TRUE;
} else {
InfiniteWait = FALSE;
}
Delay = DivU64x32 (Timeout, 10) + 1;
do {
//
// Access PCI MMIO space to see if the value is the tested one.
//
Status = UfsMmioRead32 (Private, Offset, &Value);
if (EFI_ERROR (Status)) {
return Status;
}
Value &= MaskValue;
if (Value == TestValue) {
return EFI_SUCCESS;
}
//
// Stall for 1 microseconds.
//
MicroSecondDelay (1);
Delay--;
} while (InfiniteWait || (Delay > 0));
return EFI_TIMEOUT;
}
/**
Dump UIC command execution result for debugging.
@param[in] UicOpcode The executed UIC opcode.
@param[in] Result The result to be parsed.
**/
VOID
DumpUicCmdExecResult (
IN UINT8 UicOpcode,
IN UINT8 Result
)
{
if (UicOpcode <= UfsUicDmePeerSet) {
switch (Result) {
case 0x00:
break;
case 0x01:
DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - INVALID_MIB_ATTRIBUTE\n"));
break;
case 0x02:
DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - INVALID_MIB_ATTRIBUTE_VALUE\n"));
break;
case 0x03:
DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - READ_ONLY_MIB_ATTRIBUTE\n"));
break;
case 0x04:
DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - WRITE_ONLY_MIB_ATTRIBUTE\n"));
break;
case 0x05:
DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - BAD_INDEX\n"));
break;
case 0x06:
DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - LOCKED_MIB_ATTRIBUTE\n"));
break;
case 0x07:
DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - BAD_TEST_FEATURE_INDEX\n"));
break;
case 0x08:
DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - PEER_COMMUNICATION_FAILURE\n"));
break;
case 0x09:
DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - BUSY\n"));
break;
case 0x0A:
DEBUG ((DEBUG_VERBOSE, "UIC configuration command fails - DME_FAILURE\n"));
break;
default :
ASSERT (FALSE);
break;
}
} else {
switch (Result) {
case 0x00:
break;
case 0x01:
DEBUG ((DEBUG_VERBOSE, "UIC control command fails - FAILURE\n"));
break;
default :
ASSERT (FALSE);
break;
}
}
}
/**
Dump QUERY RESPONSE UPIU result for debugging.
@param[in] Result The result to be parsed.
**/
VOID
DumpQueryResponseResult (
IN UINT8 Result
)
{
switch (Result) {
case 0xF6:
DEBUG ((DEBUG_VERBOSE, "Query Response with Parameter Not Readable\n"));
break;
case 0xF7:
DEBUG ((DEBUG_VERBOSE, "Query Response with Parameter Not Writeable\n"));
break;
case 0xF8:
DEBUG ((DEBUG_VERBOSE, "Query Response with Parameter Already Written\n"));
break;
case 0xF9:
DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Length\n"));
break;
case 0xFA:
DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Value\n"));
break;
case 0xFB:
DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Selector\n"));
break;
case 0xFC:
DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Index\n"));
break;
case 0xFD:
DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Idn\n"));
break;
case 0xFE:
DEBUG ((DEBUG_VERBOSE, "Query Response with Invalid Opcode\n"));
break;
case 0xFF:
DEBUG ((DEBUG_VERBOSE, "Query Response with General Failure\n"));
break;
default :
ASSERT (FALSE);
break;
}
}
/**
Swap little endian to big endian.
@param[in, out] Buffer The data buffer. In input, it contains little endian data.
In output, it will become big endian.
@param[in] BufferSize The length of converted data.
**/
VOID
SwapLittleEndianToBigEndian (
IN OUT UINT8 *Buffer,
IN UINT32 BufferSize
)
{
UINT32 Index;
UINT8 Temp;
UINT32 SwapCount;
SwapCount = BufferSize / 2;
for (Index = 0; Index < SwapCount; Index++) {
Temp = Buffer[Index];
Buffer[Index] = Buffer[BufferSize - 1 - Index];
Buffer[BufferSize - 1 - Index] = Temp;
}
}
/**
Fill TSF field of QUERY REQUEST UPIU.
@param[in, out] TsfBase The base address of TSF field of QUERY REQUEST UPIU.
@param[in] Opcode The opcode of request.
@param[in] DescId The descriptor ID of request.
@param[in] Index The index of request.
@param[in] Selector The selector of request.
@param[in] Length The length of transferred data. The maximum is 4.
@param[in] Value The value of transferred data.
**/
VOID
UfsFillTsfOfQueryReqUpiu (
IN OUT UTP_UPIU_TSF *TsfBase,
IN UINT8 Opcode,
IN UINT8 DescId OPTIONAL,
IN UINT8 Index OPTIONAL,
IN UINT8 Selector OPTIONAL,
IN UINT16 Length OPTIONAL,
IN UINT32 Value OPTIONAL
)
{
ASSERT (TsfBase != NULL);
ASSERT (Opcode <= UtpQueryFuncOpcodeTogFlag);
TsfBase->Opcode = Opcode;
if (Opcode != UtpQueryFuncOpcodeNop) {
TsfBase->DescId = DescId;
TsfBase->Index = Index;
TsfBase->Selector = Selector;
if ((Opcode == UtpQueryFuncOpcodeRdDesc) || (Opcode == UtpQueryFuncOpcodeWrDesc)) {
SwapLittleEndianToBigEndian ((UINT8*)&Length, sizeof (Length));
TsfBase->Length = Length;
}
if (Opcode == UtpQueryFuncOpcodeWrAttr) {
SwapLittleEndianToBigEndian ((UINT8*)&Value, sizeof (Value));
TsfBase->Value = Value;
}
}
}
/**
Initialize COMMAND UPIU.
@param[in, out] Command The base address of COMMAND UPIU.
@param[in] Lun The Lun on which the SCSI command is executed.
@param[in] TaskTag The task tag of request.
@param[in] Cdb The cdb buffer containing SCSI command.
@param[in] CdbLength The cdb length.
@param[in] DataDirection The direction of data transfer.
@param[in] ExpDataTranLen The expected transfer data length.
@retval EFI_SUCCESS The initialization succeed.
**/
EFI_STATUS
UfsInitCommandUpiu (
IN OUT UTP_COMMAND_UPIU *Command,
IN UINT8 Lun,
IN UINT8 TaskTag,
IN UINT8 *Cdb,
IN UINT8 CdbLength,
IN UFS_DATA_DIRECTION DataDirection,
IN UINT32 ExpDataTranLen
)
{
UINT8 Flags;
ASSERT ((Command != NULL) && (Cdb != NULL));
//
// Task attribute is hard-coded to Ordered.
//
if (DataDirection == UfsDataIn) {
Flags = BIT0 | BIT6;
} else if (DataDirection == UfsDataOut) {
Flags = BIT0 | BIT5;
} else {
Flags = BIT0;
}
//
// Fill UTP COMMAND UPIU associated fields.
//
Command->TransCode = 0x01;
Command->Flags = Flags;
Command->Lun = Lun;
Command->TaskTag = TaskTag;
Command->CmdSet = 0x00;
SwapLittleEndianToBigEndian ((UINT8*)&ExpDataTranLen, sizeof (ExpDataTranLen));
Command->ExpDataTranLen = ExpDataTranLen;
CopyMem (Command->Cdb, Cdb, CdbLength);
return EFI_SUCCESS;
}
/**
Initialize UTP PRDT for data transfer.
@param[in] Prdt The base address of PRDT.
@param[in] Buffer The buffer to be read or written.
@param[in] BufferSize The data size to be read or written.
@retval EFI_SUCCESS The initialization succeed.
**/
EFI_STATUS
UfsInitUtpPrdt (
IN UTP_TR_PRD *Prdt,
IN VOID *Buffer,
IN UINT32 BufferSize
)
{
UINT32 PrdtIndex;
UINT32 RemainingLen;
UINT8 *Remaining;
UINTN PrdtNumber;
ASSERT (((UINTN)Buffer & (BIT0 | BIT1)) == 0);
ASSERT ((BufferSize & (BIT1 | BIT0)) == 0);
if (BufferSize == 0) {
return EFI_SUCCESS;
}
RemainingLen = BufferSize;
Remaining = Buffer;
PrdtNumber = (UINTN)DivU64x32 ((UINT64)BufferSize + UFS_MAX_DATA_LEN_PER_PRD - 1, UFS_MAX_DATA_LEN_PER_PRD);
for (PrdtIndex = 0; PrdtIndex < PrdtNumber; PrdtIndex++) {
if (RemainingLen < UFS_MAX_DATA_LEN_PER_PRD) {
Prdt[PrdtIndex].DbCount = (UINT32)RemainingLen - 1;
} else {
Prdt[PrdtIndex].DbCount = UFS_MAX_DATA_LEN_PER_PRD - 1;
}
Prdt[PrdtIndex].DbAddr = (UINT32)RShiftU64 ((UINT64)(UINTN)Remaining, 2);
Prdt[PrdtIndex].DbAddrU = (UINT32)RShiftU64 ((UINT64)(UINTN)Remaining, 32);
RemainingLen -= UFS_MAX_DATA_LEN_PER_PRD;
Remaining += UFS_MAX_DATA_LEN_PER_PRD;
}
return EFI_SUCCESS;
}
/**
Initialize QUERY REQUEST UPIU.
@param[in, out] QueryReq The base address of QUERY REQUEST UPIU.
@param[in] TaskTag The task tag of request.
@param[in] Opcode The opcode of request.
@param[in] DescId The descriptor ID of request.
@param[in] Index The index of request.
@param[in] Selector The selector of request.
@param[in] DataSize The data size to be read or written.
@param[in] Data The buffer to be read or written.
@retval EFI_SUCCESS The initialization succeed.
**/
EFI_STATUS
UfsInitQueryRequestUpiu (
IN OUT UTP_QUERY_REQ_UPIU *QueryReq,
IN UINT8 TaskTag,
IN UINT8 Opcode,
IN UINT8 DescId,
IN UINT8 Index,
IN UINT8 Selector,
IN UINTN DataSize OPTIONAL,
IN UINT8 *Data OPTIONAL
)
{
ASSERT (QueryReq != NULL);
QueryReq->TransCode = 0x16;
QueryReq->TaskTag = TaskTag;
if ((Opcode == UtpQueryFuncOpcodeRdDesc) || (Opcode == UtpQueryFuncOpcodeRdFlag) || (Opcode == UtpQueryFuncOpcodeRdAttr)) {
QueryReq->QueryFunc = QUERY_FUNC_STD_READ_REQ;
} else {
QueryReq->QueryFunc = QUERY_FUNC_STD_WRITE_REQ;
}
if (Opcode == UtpQueryFuncOpcodeWrAttr) {
UfsFillTsfOfQueryReqUpiu (&QueryReq->Tsf, Opcode, DescId, Index, Selector, 0, *(UINT32*)Data);
} else if ((Opcode == UtpQueryFuncOpcodeRdDesc) || (Opcode == UtpQueryFuncOpcodeWrDesc)) {
UfsFillTsfOfQueryReqUpiu (&QueryReq->Tsf, Opcode, DescId, Index, Selector, (UINT16)DataSize, 0);
} else {
UfsFillTsfOfQueryReqUpiu (&QueryReq->Tsf, Opcode, DescId, Index, Selector, 0, 0);
}
if (Opcode == UtpQueryFuncOpcodeWrDesc) {
CopyMem (QueryReq + 1, Data, DataSize);
SwapLittleEndianToBigEndian ((UINT8*)&DataSize, sizeof (UINT16));
QueryReq->DataSegLen = (UINT16)DataSize;
}
return EFI_SUCCESS;
}
/**
Allocate COMMAND/RESPONSE UPIU for filling UTP TRD's command descriptor field.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Lun The Lun on which the SCSI command is executed.
@param[in] Packet The pointer to the EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET data structure.
@param[in] Trd The pointer to the UTP Transfer Request Descriptor.
@param[out] CmdDescHost A pointer to store the base system memory address of the allocated range.
@param[out] CmdDescMapping A resulting value to pass to Unmap().
@retval EFI_SUCCESS The creation succeed.
@retval EFI_DEVICE_ERROR The creation failed.
@retval EFI_OUT_OF_RESOURCES The memory resource is insufficient.
**/
EFI_STATUS
UfsCreateScsiCommandDesc (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UINT8 Lun,
IN EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
IN UTP_TRD *Trd,
OUT VOID **CmdDescHost,
OUT VOID **CmdDescMapping
)
{
UINTN TotalLen;
UINTN PrdtNumber;
UTP_COMMAND_UPIU *CommandUpiu;
EFI_PHYSICAL_ADDRESS CmdDescPhyAddr;
EFI_STATUS Status;
UINT32 DataLen;
UFS_DATA_DIRECTION DataDirection;
ASSERT ((Private != NULL) && (Packet != NULL) && (Trd != NULL));
if (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {
DataLen = Packet->InTransferLength;
DataDirection = UfsDataIn;
} else {
DataLen = Packet->OutTransferLength;
DataDirection = UfsDataOut;
}
if (DataLen == 0) {
DataDirection = UfsNoData;
}
PrdtNumber = (UINTN)DivU64x32 ((UINT64)DataLen + UFS_MAX_DATA_LEN_PER_PRD - 1, UFS_MAX_DATA_LEN_PER_PRD);
TotalLen = ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)) + ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU)) + PrdtNumber * sizeof (UTP_TR_PRD);
Status = UfsAllocateAlignCommonBuffer (Private, TotalLen, CmdDescHost, &CmdDescPhyAddr, CmdDescMapping);
if (EFI_ERROR (Status)) {
return Status;
}
CommandUpiu = (UTP_COMMAND_UPIU*)*CmdDescHost;
UfsInitCommandUpiu (CommandUpiu, Lun, Private->TaskTag++, Packet->Cdb, Packet->CdbLength, DataDirection, DataLen);
//
// Fill UTP_TRD associated fields
// NOTE: Some UFS host controllers request the Response UPIU and the Physical Region Description Table
// *MUST* be located at a 64-bit aligned boundary.
//
Trd->Int = UFS_INTERRUPT_COMMAND;
Trd->Dd = DataDirection;
Trd->Ct = UFS_STORAGE_COMMAND_TYPE;
Trd->Ocs = UFS_HC_TRD_OCS_INIT_VALUE;
Trd->UcdBa = (UINT32)RShiftU64 ((UINT64)CmdDescPhyAddr, 7);
Trd->UcdBaU = (UINT32)RShiftU64 ((UINT64)CmdDescPhyAddr, 32);
Trd->RuL = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU)), sizeof (UINT32));
Trd->RuO = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)), sizeof (UINT32));
Trd->PrdtL = (UINT16)PrdtNumber;
Trd->PrdtO = (UINT16)DivU64x32 ((UINT64)(ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)) + ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU))), sizeof (UINT32));
return EFI_SUCCESS;
}
/**
Allocate QUERY REQUEST/QUERY RESPONSE UPIU for filling UTP TRD's command descriptor field.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Packet The pointer to the UFS_DEVICE_MANAGEMENT_REQUEST_PACKET data structure.
@param[in] Trd The pointer to the UTP Transfer Request Descriptor.
@param[out] CmdDescHost A pointer to store the base system memory address of the allocated range.
@param[out] CmdDescMapping A resulting value to pass to Unmap().
@retval EFI_SUCCESS The creation succeed.
@retval EFI_DEVICE_ERROR The creation failed.
@retval EFI_OUT_OF_RESOURCES The memory resource is insufficient.
@retval EFI_INVALID_PARAMETER The parameter passed in is invalid.
**/
EFI_STATUS
UfsCreateDMCommandDesc (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UFS_DEVICE_MANAGEMENT_REQUEST_PACKET *Packet,
IN UTP_TRD *Trd,
OUT VOID **CmdDescHost,
OUT VOID **CmdDescMapping
)
{
UINTN TotalLen;
UTP_QUERY_REQ_UPIU *QueryReqUpiu;
UINT8 Opcode;
UINT32 DataSize;
UINT8 *Data;
UINT8 DataDirection;
EFI_PHYSICAL_ADDRESS CmdDescPhyAddr;
EFI_STATUS Status;
ASSERT ((Private != NULL) && (Packet != NULL) && (Trd != NULL));
Opcode = Packet->Opcode;
if ((Opcode > UtpQueryFuncOpcodeTogFlag) || (Opcode == UtpQueryFuncOpcodeNop)) {
return EFI_INVALID_PARAMETER;
}
DataDirection = Packet->DataDirection;
DataSize = Packet->TransferLength;
Data = Packet->DataBuffer;
if ((Opcode == UtpQueryFuncOpcodeWrDesc) || (Opcode == UtpQueryFuncOpcodeRdDesc)) {
if (DataSize == 0 || Data == NULL) {
return EFI_INVALID_PARAMETER;
}
TotalLen = ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)) + ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU)) + ROUNDUP8 (DataSize);
} else {
TotalLen = ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)) + ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU));
}
Status = UfsAllocateAlignCommonBuffer (Private, TotalLen, CmdDescHost, &CmdDescPhyAddr, CmdDescMapping);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Initialize UTP QUERY REQUEST UPIU
//
QueryReqUpiu = (UTP_QUERY_REQ_UPIU*)*CmdDescHost;
ASSERT (QueryReqUpiu != NULL);
UfsInitQueryRequestUpiu (
QueryReqUpiu,
Private->TaskTag++,
Opcode,
Packet->DescId,
Packet->Index,
Packet->Selector,
DataSize,
Data
);
//
// Fill UTP_TRD associated fields
// NOTE: Some UFS host controllers request the Query Response UPIU *MUST* be located at a 64-bit aligned boundary.
//
Trd->Int = UFS_INTERRUPT_COMMAND;
Trd->Dd = DataDirection;
Trd->Ct = UFS_STORAGE_COMMAND_TYPE;
Trd->Ocs = UFS_HC_TRD_OCS_INIT_VALUE;
Trd->UcdBa = (UINT32)RShiftU64 ((UINT64)CmdDescPhyAddr, 7);
Trd->UcdBaU = (UINT32)RShiftU64 ((UINT64)CmdDescPhyAddr, 32);
if (Opcode == UtpQueryFuncOpcodeWrDesc) {
Trd->RuL = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU)), sizeof (UINT32));
Trd->RuO = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)) + ROUNDUP8 (DataSize), sizeof (UINT32));
} else {
Trd->RuL = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU)) + ROUNDUP8 (DataSize), sizeof (UINT32));
Trd->RuO = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)), sizeof (UINT32));
}
return EFI_SUCCESS;
}
/**
Allocate NOP IN and NOP OUT UPIU for filling UTP TRD's command descriptor field.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Trd The pointer to the UTP Transfer Request Descriptor.
@param[out] CmdDescHost A pointer to store the base system memory address of the allocated range.
@param[out] CmdDescMapping A resulting value to pass to Unmap().
@retval EFI_SUCCESS The creation succeed.
@retval EFI_DEVICE_ERROR The creation failed.
@retval EFI_OUT_OF_RESOURCES The memory resource is insufficient.
**/
EFI_STATUS
UfsCreateNopCommandDesc (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UTP_TRD *Trd,
OUT VOID **CmdDescHost,
OUT VOID **CmdDescMapping
)
{
UINTN TotalLen;
UTP_NOP_OUT_UPIU *NopOutUpiu;
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS CmdDescPhyAddr;
ASSERT ((Private != NULL) && (Trd != NULL));
TotalLen = ROUNDUP8 (sizeof (UTP_NOP_OUT_UPIU)) + ROUNDUP8 (sizeof (UTP_NOP_IN_UPIU));
Status = UfsAllocateAlignCommonBuffer (Private, TotalLen, CmdDescHost, &CmdDescPhyAddr, CmdDescMapping);
if (EFI_ERROR (Status)) {
return Status;
}
NopOutUpiu = (UTP_NOP_OUT_UPIU*)*CmdDescHost;
ASSERT (NopOutUpiu != NULL);
NopOutUpiu->TaskTag = Private->TaskTag++;
//
// Fill UTP_TRD associated fields
// NOTE: Some UFS host controllers request the Nop Out UPIU *MUST* be located at a 64-bit aligned boundary.
//
Trd->Int = UFS_INTERRUPT_COMMAND;
Trd->Dd = 0x00;
Trd->Ct = UFS_STORAGE_COMMAND_TYPE;
Trd->Ocs = UFS_HC_TRD_OCS_INIT_VALUE;
Trd->UcdBa = (UINT32)RShiftU64 ((UINT64)CmdDescPhyAddr, 7);
Trd->UcdBaU = (UINT32)RShiftU64 ((UINT64)CmdDescPhyAddr, 32);
Trd->RuL = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_NOP_IN_UPIU)), sizeof (UINT32));
Trd->RuO = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_NOP_OUT_UPIU)), sizeof (UINT32));
return EFI_SUCCESS;
}
/**
Find out available slot in transfer list of a UFS device.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[out] Slot The available slot.
@retval EFI_SUCCESS The available slot was found successfully.
@retval EFI_NOT_READY No slot is available at this moment.
**/
EFI_STATUS
UfsFindAvailableSlotInTrl (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
OUT UINT8 *Slot
)
{
UINT8 Nutrs;
UINT8 Index;
UINT32 Data;
EFI_STATUS Status;
ASSERT ((Private != NULL) && (Slot != NULL));
Status = UfsMmioRead32 (Private, UFS_HC_UTRLDBR_OFFSET, &Data);
if (EFI_ERROR (Status)) {
return Status;
}
Nutrs = (UINT8)((Private->UfsHcInfo.Capabilities & UFS_HC_CAP_NUTRS) + 1);
for (Index = 0; Index < Nutrs; Index++) {
if ((Data & (BIT0 << Index)) == 0) {
*Slot = Index;
return EFI_SUCCESS;
}
}
return EFI_NOT_READY;
}
/**
Start specified slot in transfer list of a UFS device.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Slot The slot to be started.
**/
EFI_STATUS
UfsStartExecCmd (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UINT8 Slot
)
{
UINT32 Data;
EFI_STATUS Status;
Status = UfsMmioRead32 (Private, UFS_HC_UTRLRSR_OFFSET, &Data);
if (EFI_ERROR (Status)) {
return Status;
}
if ((Data & UFS_HC_UTRLRSR) != UFS_HC_UTRLRSR) {
Status = UfsMmioWrite32 (Private, UFS_HC_UTRLRSR_OFFSET, UFS_HC_UTRLRSR);
if (EFI_ERROR (Status)) {
return Status;
}
}
Status = UfsMmioWrite32 (Private, UFS_HC_UTRLDBR_OFFSET, BIT0 << Slot);
if (EFI_ERROR (Status)) {
return Status;
}
return EFI_SUCCESS;
}
/**
Stop specified slot in transfer list of a UFS device.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Slot The slot to be stop.
**/
EFI_STATUS
UfsStopExecCmd (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UINT8 Slot
)
{
UINT32 Data;
EFI_STATUS Status;
Status = UfsMmioRead32 (Private, UFS_HC_UTRLDBR_OFFSET, &Data);
if (EFI_ERROR (Status)) {
return Status;
}
if ((Data & (BIT0 << Slot)) != 0) {
Status = UfsMmioRead32 (Private, UFS_HC_UTRLCLR_OFFSET, &Data);
if (EFI_ERROR (Status)) {
return Status;
}
Status = UfsMmioWrite32 (Private, UFS_HC_UTRLCLR_OFFSET, Data & ~(BIT0 << Slot));
if (EFI_ERROR (Status)) {
return Status;
}
}
return EFI_SUCCESS;
}
/**
Extracts return data from query response upiu.
@param[in] Packet Pointer to the UFS_DEVICE_MANAGEMENT_REQUEST_PACKET.
@param[in] QueryResp Pointer to the query response.
@retval EFI_INVALID_PARAMETER Packet or QueryResp are empty or opcode is invalid.
@retval EFI_DEVICE_ERROR Data returned from device is invalid.
@retval EFI_SUCCESS Data extracted.
**/
EFI_STATUS
UfsGetReturnDataFromQueryResponse (
IN UFS_DEVICE_MANAGEMENT_REQUEST_PACKET *Packet,
IN UTP_QUERY_RESP_UPIU *QueryResp
)
{
UINT16 ReturnDataSize;
UINT32 ReturnData;
if (Packet == NULL || QueryResp == NULL) {
return EFI_INVALID_PARAMETER;
}
switch (Packet->Opcode) {
case UtpQueryFuncOpcodeRdDesc:
ReturnDataSize = QueryResp->Tsf.Length;
SwapLittleEndianToBigEndian ((UINT8*)&ReturnDataSize, sizeof (UINT16));
//
// Make sure the hardware device does not return more data than expected.
//
if (ReturnDataSize > Packet->TransferLength) {
return EFI_DEVICE_ERROR;
}
CopyMem (Packet->DataBuffer, (QueryResp + 1), ReturnDataSize);
Packet->TransferLength = ReturnDataSize;
break;
case UtpQueryFuncOpcodeWrDesc:
ReturnDataSize = QueryResp->Tsf.Length;
SwapLittleEndianToBigEndian ((UINT8*)&ReturnDataSize, sizeof (UINT16));
Packet->TransferLength = ReturnDataSize;
break;
case UtpQueryFuncOpcodeRdFlag:
case UtpQueryFuncOpcodeSetFlag:
case UtpQueryFuncOpcodeClrFlag:
case UtpQueryFuncOpcodeTogFlag:
CopyMem (Packet->DataBuffer, &QueryResp->Tsf.Value, sizeof (UINT8));
break;
case UtpQueryFuncOpcodeRdAttr:
case UtpQueryFuncOpcodeWrAttr:
ReturnData = QueryResp->Tsf.Value;
SwapLittleEndianToBigEndian ((UINT8*) &ReturnData, sizeof (UINT32));
CopyMem (Packet->DataBuffer, &ReturnData, sizeof (UINT32));
break;
default:
return EFI_INVALID_PARAMETER;
}
return EFI_SUCCESS;
}
/**
Creates Transfer Request descriptor and sends Query Request to the device.
@param[in] Private Pointer to the UFS_PASS_THRU_PRIVATE_DATA.
@param[in] Packet Pointer to the UFS_DEVICE_MANAGEMENT_REQUEST_PACKET.
@retval EFI_SUCCESS The device descriptor was read/written successfully.
@retval EFI_INVALID_PARAMETER The DescId, Index and Selector fields in Packet are invalid
combination to point to a type of UFS device descriptor.
@retval EFI_DEVICE_ERROR A device error occurred while attempting to r/w the device descriptor.
@retval EFI_TIMEOUT A timeout occurred while waiting for the completion of r/w the device descriptor.
**/
EFI_STATUS
UfsSendDmRequestRetry (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UFS_DEVICE_MANAGEMENT_REQUEST_PACKET *Packet
)
{
UINT8 Slot;
UTP_TRD *Trd;
VOID *CmdDescHost;
VOID *CmdDescMapping;
UINT32 CmdDescSize;
EDKII_UFS_HOST_CONTROLLER_PROTOCOL *UfsHc;
UTP_QUERY_RESP_UPIU *QueryResp;
EFI_STATUS Status;
//
// Find out which slot of transfer request list is available.
//
Status = UfsFindAvailableSlotInTrl (Private, &Slot);
if (EFI_ERROR (Status)) {
return Status;
}
Trd = ((UTP_TRD*)Private->UtpTrlBase) + Slot;
//
// Fill transfer request descriptor to this slot.
//
Status = UfsCreateDMCommandDesc (Private, Packet, Trd, &CmdDescHost, &CmdDescMapping);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failed to create DM command descriptor\n"));
return Status;
}
UfsHc = Private->UfsHostController;
QueryResp = (UTP_QUERY_RESP_UPIU*)((UINT8*)CmdDescHost + Trd->RuO * sizeof (UINT32));
ASSERT (QueryResp != NULL);
CmdDescSize = Trd->RuO * sizeof (UINT32) + Trd->RuL * sizeof (UINT32);
//
// Start to execute the transfer request.
//
UfsStartExecCmd (Private, Slot);
//
// Wait for the completion of the transfer request.
//
Status = UfsWaitMemSet (Private, UFS_HC_UTRLDBR_OFFSET, BIT0, 0, Packet->Timeout);
if (EFI_ERROR (Status)) {
goto Exit;
}
if (Trd->Ocs != 0 || QueryResp->QueryResp != UfsUtpQueryResponseSuccess) {
DEBUG ((DEBUG_ERROR, "Failed to send query request, OCS = %X, QueryResp = %X\n", Trd->Ocs, QueryResp->QueryResp));
DumpQueryResponseResult (QueryResp->QueryResp);
if ((QueryResp->QueryResp == UfsUtpQueryResponseInvalidSelector) ||
(QueryResp->QueryResp == UfsUtpQueryResponseInvalidIndex) ||
(QueryResp->QueryResp == UfsUtpQueryResponseInvalidIdn)) {
Status = EFI_INVALID_PARAMETER;
} else {
Status = EFI_DEVICE_ERROR;
}
goto Exit;
}
Status = UfsGetReturnDataFromQueryResponse (Packet, QueryResp);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failed to get return data from query response\n"));
goto Exit;
}
Exit:
UfsHc->Flush (UfsHc);
UfsStopExecCmd (Private, Slot);
if (CmdDescMapping != NULL) {
UfsHc->Unmap (UfsHc, CmdDescMapping);
}
if (CmdDescHost != NULL) {
UfsHc->FreeBuffer (UfsHc, EFI_SIZE_TO_PAGES (CmdDescSize), CmdDescHost);
}
return Status;
}
/**
Sends Query Request to the device. Query is sent until device responds correctly or counter runs out.
@param[in] Private Pointer to the UFS_PASS_THRU_PRIVATE_DATA.
@param[in] Packet Pointer to the UFS_DEVICE_MANAGEMENT_PACKET.
@retval EFI_SUCCESS The device responded correctly to the Query request.
@retval EFI_INVALID_PARAMETER The DescId, Index and Selector fields in Packet are invalid
combination to point to a type of UFS device descriptor.
@retval EFI_DEVICE_ERROR A device error occurred while waiting for the response from the device.
@retval EFI_TIMEOUT A timeout occurred while waiting for the completion of the operation.
**/
EFI_STATUS
UfsSendDmRequest (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UFS_DEVICE_MANAGEMENT_REQUEST_PACKET *Packet
)
{
EFI_STATUS Status;
UINT8 Retry;
Status = EFI_SUCCESS;
for (Retry = 0; Retry < 5; Retry ++) {
Status = UfsSendDmRequestRetry (Private, Packet);
if (!EFI_ERROR (Status)) {
return EFI_SUCCESS;
}
}
DEBUG ((DEBUG_ERROR, "Failed to get response from the device after %d retries\n", Retry));
return Status;
}
/**
Read or write specified device descriptor of a UFS device.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Read The boolean variable to show r/w direction.
@param[in] DescId The ID of device descriptor.
@param[in] Index The Index of device descriptor.
@param[in] Selector The Selector of device descriptor.
@param[in, out] Descriptor The buffer of device descriptor to be read or written.
@param[in, out] DescSize The size of device descriptor buffer. On input, the size, in bytes,
of the data buffer specified by Descriptor. On output, the number
of bytes that were actually transferred.
@retval EFI_SUCCESS The device descriptor was read/written successfully.
@retval EFI_INVALID_PARAMETER DescId, Index and Selector are invalid combination to point to a
type of UFS device descriptor.
@retval EFI_DEVICE_ERROR A device error occurred while attempting to r/w the device descriptor.
@retval EFI_TIMEOUT A timeout occurred while waiting for the completion of r/w the device descriptor.
**/
EFI_STATUS
UfsRwDeviceDesc (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN BOOLEAN Read,
IN UINT8 DescId,
IN UINT8 Index,
IN UINT8 Selector,
IN OUT VOID *Descriptor,
IN OUT UINT32 *DescSize
)
{
UFS_DEVICE_MANAGEMENT_REQUEST_PACKET Packet;
EFI_STATUS Status;
if (DescSize == NULL) {
return EFI_INVALID_PARAMETER;
}
ZeroMem (&Packet, sizeof (UFS_DEVICE_MANAGEMENT_REQUEST_PACKET));
if (Read) {
Packet.DataDirection = UfsDataIn;
Packet.Opcode = UtpQueryFuncOpcodeRdDesc;
} else {
Packet.DataDirection = UfsDataOut;
Packet.Opcode = UtpQueryFuncOpcodeWrDesc;
}
Packet.DataBuffer = Descriptor;
Packet.TransferLength = *DescSize;
Packet.DescId = DescId;
Packet.Index = Index;
Packet.Selector = Selector;
Packet.Timeout = UFS_TIMEOUT;
Status = UfsSendDmRequest (Private, &Packet);
if (EFI_ERROR (Status)) {
*DescSize = 0;
} else {
*DescSize = Packet.TransferLength;
}
return Status;
}
/**
Read or write specified attribute of a UFS device.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Read The boolean variable to show r/w direction.
@param[in] AttrId The ID of Attribute.
@param[in] Index The Index of Attribute.
@param[in] Selector The Selector of Attribute.
@param[in, out] Attributes The value of Attribute to be read or written.
@retval EFI_SUCCESS The Attribute was read/written successfully.
@retval EFI_INVALID_PARAMETER AttrId, Index and Selector are invalid combination to point to a
type of UFS device descriptor.
@retval EFI_DEVICE_ERROR A device error occurred while attempting to r/w the Attribute.
@retval EFI_TIMEOUT A timeout occurred while waiting for the completion of r/w the Attribute.
**/
EFI_STATUS
UfsRwAttributes (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN BOOLEAN Read,
IN UINT8 AttrId,
IN UINT8 Index,
IN UINT8 Selector,
IN OUT UINT32 *Attributes
)
{
UFS_DEVICE_MANAGEMENT_REQUEST_PACKET Packet;
ZeroMem (&Packet, sizeof (UFS_DEVICE_MANAGEMENT_REQUEST_PACKET));
if (Read) {
Packet.DataDirection = UfsDataIn;
Packet.Opcode = UtpQueryFuncOpcodeRdAttr;
} else {
Packet.DataDirection = UfsDataOut;
Packet.Opcode = UtpQueryFuncOpcodeWrAttr;
}
Packet.DataBuffer = Attributes;
Packet.DescId = AttrId;
Packet.Index = Index;
Packet.Selector = Selector;
Packet.Timeout = UFS_TIMEOUT;
return UfsSendDmRequest (Private, &Packet);
}
/**
Read or write specified flag of a UFS device.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Read The boolean variable to show r/w direction.
@param[in] FlagId The ID of flag to be read or written.
@param[in, out] Value The value to set or clear flag.
@retval EFI_SUCCESS The flag was read/written successfully.
@retval EFI_INVALID_PARAMETER FlagId is an invalid UFS flag ID.
@retval EFI_DEVICE_ERROR A device error occurred while attempting to r/w the flag.
@retval EFI_TIMEOUT A timeout occurred while waiting for the completion of r/w the flag.
**/
EFI_STATUS
UfsRwFlags (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN BOOLEAN Read,
IN UINT8 FlagId,
IN OUT UINT8 *Value
)
{
UFS_DEVICE_MANAGEMENT_REQUEST_PACKET Packet;
if (Value == NULL) {
return EFI_INVALID_PARAMETER;
}
ZeroMem (&Packet, sizeof (UFS_DEVICE_MANAGEMENT_REQUEST_PACKET));
if (Read) {
ASSERT (Value != NULL);
Packet.DataDirection = UfsDataIn;
Packet.Opcode = UtpQueryFuncOpcodeRdFlag;
} else {
Packet.DataDirection = UfsDataOut;
if (*Value == 1) {
Packet.Opcode = UtpQueryFuncOpcodeSetFlag;
} else if (*Value == 0) {
Packet.Opcode = UtpQueryFuncOpcodeClrFlag;
} else {
return EFI_INVALID_PARAMETER;
}
}
Packet.DataBuffer = Value;
Packet.DescId = FlagId;
Packet.Index = 0;
Packet.Selector = 0;
Packet.Timeout = UFS_TIMEOUT;
return UfsSendDmRequest (Private, &Packet);
}
/**
Set specified flag to 1 on a UFS device.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] FlagId The ID of flag to be set.
@retval EFI_SUCCESS The flag was set successfully.
@retval EFI_DEVICE_ERROR A device error occurred while attempting to set the flag.
@retval EFI_TIMEOUT A timeout occurred while waiting for the completion of setting the flag.
**/
EFI_STATUS
UfsSetFlag (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UINT8 FlagId
)
{
EFI_STATUS Status;
UINT8 Value;
Value = 1;
Status = UfsRwFlags (Private, FALSE, FlagId, &Value);
return Status;
}
/**
Read specified flag from a UFS device.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] FlagId The ID of flag to be read.
@param[out] Value The flag's value.
@retval EFI_SUCCESS The flag was read successfully.
@retval EFI_DEVICE_ERROR A device error occurred while attempting to read the flag.
@retval EFI_TIMEOUT A timeout occurred while waiting for the completion of reading the flag.
**/
EFI_STATUS
UfsReadFlag (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UINT8 FlagId,
OUT UINT8 *Value
)
{
EFI_STATUS Status;
Status = UfsRwFlags (Private, TRUE, FlagId, Value);
return Status;
}
/**
Sends NOP IN cmd to a UFS device for initialization process request.
For more details, please refer to UFS 2.0 spec Figure 13.3.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@retval EFI_SUCCESS The NOP IN command was sent by the host. The NOP OUT response was
received successfully.
@retval EFI_DEVICE_ERROR A device error occurred while attempting to execute NOP IN command.
@retval EFI_OUT_OF_RESOURCES The resource for transfer is not available.
@retval EFI_TIMEOUT A timeout occurred while waiting for the NOP IN command to execute.
**/
EFI_STATUS
UfsExecNopCmds (
IN UFS_PASS_THRU_PRIVATE_DATA *Private
)
{
EFI_STATUS Status;
UINT8 Slot;
UTP_TRD *Trd;
UTP_NOP_IN_UPIU *NopInUpiu;
UINT32 CmdDescSize;
VOID *CmdDescHost;
VOID *CmdDescMapping;
EDKII_UFS_HOST_CONTROLLER_PROTOCOL *UfsHc;
//
// Find out which slot of transfer request list is available.
//
Status = UfsFindAvailableSlotInTrl (Private, &Slot);
if (EFI_ERROR (Status)) {
return Status;
}
Trd = ((UTP_TRD*)Private->UtpTrlBase) + Slot;
Status = UfsCreateNopCommandDesc (Private, Trd, &CmdDescHost, &CmdDescMapping);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Check the transfer request result.
//
UfsHc = Private->UfsHostController;
NopInUpiu = (UTP_NOP_IN_UPIU*)((UINT8*)CmdDescHost + Trd->RuO * sizeof (UINT32));
ASSERT (NopInUpiu != NULL);
CmdDescSize = Trd->RuO * sizeof (UINT32) + Trd->RuL * sizeof (UINT32);
//
// Start to execute the transfer request.
//
UfsStartExecCmd (Private, Slot);
//
// Wait for the completion of the transfer request.
//
Status = UfsWaitMemSet (Private, UFS_HC_UTRLDBR_OFFSET, BIT0 << Slot, 0, UFS_TIMEOUT);
if (EFI_ERROR (Status)) {
goto Exit;
}
if (NopInUpiu->Resp != 0) {
Status = EFI_DEVICE_ERROR;
} else {
Status = EFI_SUCCESS;
}
Exit:
UfsHc->Flush (UfsHc);
UfsStopExecCmd (Private, Slot);
if (CmdDescMapping != NULL) {
UfsHc->Unmap (UfsHc, CmdDescMapping);
}
if (CmdDescHost != NULL) {
UfsHc->FreeBuffer (UfsHc, EFI_SIZE_TO_PAGES (CmdDescSize), CmdDescHost);
}
return Status;
}
/**
Cleanup data buffers after data transfer. This function
also takes care to copy all data to user memory pool for
unaligned data transfers.
@param[in] Private Pointer to the UFS_PASS_THRU_PRIVATE_DATA
@param[in] TransReq Pointer to the transfer request
**/
VOID
UfsReconcileDataTransferBuffer (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UFS_PASS_THRU_TRANS_REQ *TransReq
)
{
if (TransReq->DataBufMapping != NULL) {
Private->UfsHostController->Unmap (
Private->UfsHostController,
TransReq->DataBufMapping
);
}
//
// Check if unaligned transfer was performed. If it was and we read
// data from device copy memory to user data buffers before cleanup.
// The assumption is if auxiliary aligned data buffer is not NULL then
// unaligned transfer has been performed.
//
if (TransReq->AlignedDataBuf != NULL) {
if (TransReq->Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {
CopyMem (TransReq->Packet->InDataBuffer, TransReq->AlignedDataBuf, TransReq->Packet->InTransferLength);
}
//
// Wipe out the transfer buffer in case it contains sensitive data.
//
ZeroMem (TransReq->AlignedDataBuf, TransReq->AlignedDataBufSize);
FreeAlignedPages (TransReq->AlignedDataBuf, EFI_SIZE_TO_PAGES (TransReq->AlignedDataBufSize));
TransReq->AlignedDataBuf = NULL;
}
}
/**
Prepare data buffer for transfer.
@param[in] Private Pointer to the UFS_PASS_THRU_PRIVATE_DATA
@param[in, out] TransReq Pointer to the transfer request
@retval EFI_DEVICE_ERROR Failed to prepare buffer for transfer
@retval EFI_SUCCESS Buffer ready for transfer
**/
EFI_STATUS
UfsPrepareDataTransferBuffer (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN OUT UFS_PASS_THRU_TRANS_REQ *TransReq
)
{
EFI_STATUS Status;
VOID *DataBuf;
UINT32 DataLen;
UINTN MapLength;
EFI_PHYSICAL_ADDRESS DataBufPhyAddr;
EDKII_UFS_HOST_CONTROLLER_OPERATION Flag;
UTP_TR_PRD *PrdtBase;
DataBufPhyAddr = 0;
DataBuf = NULL;
//
// For unaligned data transfers we allocate auxiliary DWORD aligned memory pool.
// When command is finished auxiliary memory pool is copied into actual user memory.
// This is requiered to assure data transfer safety(DWORD alignment required by UFS spec.)
//
if (TransReq->Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {
if (((UINTN)TransReq->Packet->InDataBuffer % 4 != 0) || (TransReq->Packet->InTransferLength % 4 != 0)) {
DataLen = TransReq->Packet->InTransferLength + (4 - (TransReq->Packet->InTransferLength % 4));
DataBuf = AllocateAlignedPages (EFI_SIZE_TO_PAGES (DataLen), 4);
if (DataBuf == NULL) {
return EFI_DEVICE_ERROR;
}
ZeroMem (DataBuf, DataLen);
TransReq->AlignedDataBuf = DataBuf;
TransReq->AlignedDataBufSize = DataLen;
} else {
DataLen = TransReq->Packet->InTransferLength;
DataBuf = TransReq->Packet->InDataBuffer;
}
Flag = EdkiiUfsHcOperationBusMasterWrite;
} else {
if (((UINTN)TransReq->Packet->OutDataBuffer % 4 != 0) || (TransReq->Packet->OutTransferLength % 4 != 0)) {
DataLen = TransReq->Packet->OutTransferLength + (4 - (TransReq->Packet->OutTransferLength % 4));
DataBuf = AllocateAlignedPages (EFI_SIZE_TO_PAGES (DataLen), 4);
if (DataBuf == NULL) {
return EFI_DEVICE_ERROR;
}
CopyMem (DataBuf, TransReq->Packet->OutDataBuffer, TransReq->Packet->OutTransferLength);
TransReq->AlignedDataBuf = DataBuf;
TransReq->AlignedDataBufSize = DataLen;
} else {
DataLen = TransReq->Packet->OutTransferLength;
DataBuf = TransReq->Packet->OutDataBuffer;
}
Flag = EdkiiUfsHcOperationBusMasterRead;
}
if (DataLen != 0) {
MapLength = DataLen;
Status = Private->UfsHostController->Map (
Private->UfsHostController,
Flag,
DataBuf,
&MapLength,
&DataBufPhyAddr,
&TransReq->DataBufMapping
);
if (EFI_ERROR (Status) || (DataLen != MapLength)) {
if (TransReq->AlignedDataBuf != NULL) {
//
// Wipe out the transfer buffer in case it contains sensitive data.
//
ZeroMem (TransReq->AlignedDataBuf, TransReq->AlignedDataBufSize);
FreeAlignedPages (TransReq->AlignedDataBuf, EFI_SIZE_TO_PAGES (TransReq->AlignedDataBufSize));
TransReq->AlignedDataBuf = NULL;
}
return EFI_DEVICE_ERROR;
}
}
//
// Fill PRDT table of Command UPIU for executed SCSI cmd.
//
PrdtBase = (UTP_TR_PRD*)((UINT8*)TransReq->CmdDescHost + ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)) + ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU)));
ASSERT (PrdtBase != NULL);
UfsInitUtpPrdt (PrdtBase, (VOID*)(UINTN)DataBufPhyAddr, DataLen);
return EFI_SUCCESS;
}
/**
Sends a UFS-supported SCSI Request Packet to a UFS device that is attached to the UFS host controller.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Lun The LUN of the UFS device to send the SCSI Request Packet.
@param[in, out] Packet A pointer to the SCSI Request Packet to send to a specified Lun of the
UFS device.
@param[in] Event If nonblocking I/O is not supported then Event is ignored, and blocking
I/O is performed. If Event is NULL, then blocking I/O is performed. If
Event is not NULL and non blocking I/O is supported, then
nonblocking I/O is performed, and Event will be signaled when the
SCSI Request Packet completes.
@retval EFI_SUCCESS The SCSI Request Packet was sent by the host. For bi-directional
commands, InTransferLength bytes were transferred from
InDataBuffer. For write and bi-directional commands,
OutTransferLength bytes were transferred by
OutDataBuffer.
@retval EFI_DEVICE_ERROR A device error occurred while attempting to send the SCSI Request
Packet.
@retval EFI_OUT_OF_RESOURCES The resource for transfer is not available.
@retval EFI_TIMEOUT A timeout occurred while waiting for the SCSI Request Packet to execute.
**/
EFI_STATUS
UfsExecScsiCmds (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UINT8 Lun,
IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
IN EFI_EVENT Event OPTIONAL
)
{
EFI_STATUS Status;
UTP_RESPONSE_UPIU *Response;
UINT16 SenseDataLen;
UINT32 ResTranCount;
EFI_TPL OldTpl;
UFS_PASS_THRU_TRANS_REQ *TransReq;
EDKII_UFS_HOST_CONTROLLER_PROTOCOL *UfsHc;
TransReq = AllocateZeroPool (sizeof (UFS_PASS_THRU_TRANS_REQ));
if (TransReq == NULL) {
return EFI_OUT_OF_RESOURCES;
}
TransReq->Signature = UFS_PASS_THRU_TRANS_REQ_SIG;
TransReq->TimeoutRemain = Packet->Timeout;
TransReq->Packet = Packet;
UfsHc = Private->UfsHostController;
//
// Find out which slot of transfer request list is available.
//
Status = UfsFindAvailableSlotInTrl (Private, &TransReq->Slot);
if (EFI_ERROR (Status)) {
return Status;
}
TransReq->Trd = ((UTP_TRD*)Private->UtpTrlBase) + TransReq->Slot;
//
// Fill transfer request descriptor to this slot.
//
Status = UfsCreateScsiCommandDesc (
Private,
Lun,
Packet,
TransReq->Trd,
&TransReq->CmdDescHost,
&TransReq->CmdDescMapping
);
if (EFI_ERROR (Status)) {
return Status;
}
TransReq->CmdDescSize = TransReq->Trd->PrdtO * sizeof (UINT32) + TransReq->Trd->PrdtL * sizeof (UTP_TR_PRD);
Status = UfsPrepareDataTransferBuffer (Private, TransReq);
if (EFI_ERROR (Status)) {
goto Exit1;
}
//
// Insert the async SCSI cmd to the Async I/O list
//
if (Event != NULL) {
OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
TransReq->CallerEvent = Event;
InsertTailList (&Private->Queue, &TransReq->TransferList);
gBS->RestoreTPL (OldTpl);
}
//
// Start to execute the transfer request.
//
UfsStartExecCmd (Private, TransReq->Slot);
//
// Immediately return for async I/O.
//
if (Event != NULL) {
return EFI_SUCCESS;
}
//
// Wait for the completion of the transfer request.
//
Status = UfsWaitMemSet (Private, UFS_HC_UTRLDBR_OFFSET, BIT0 << TransReq->Slot, 0, Packet->Timeout);
if (EFI_ERROR (Status)) {
goto Exit;
}
//
// Get sense data if exists
//
Response = (UTP_RESPONSE_UPIU*)((UINT8*)TransReq->CmdDescHost + TransReq->Trd->RuO * sizeof (UINT32));
ASSERT (Response != NULL);
SenseDataLen = Response->SenseDataLen;
SwapLittleEndianToBigEndian ((UINT8*)&SenseDataLen, sizeof (UINT16));
if ((Packet->SenseDataLength != 0) && (Packet->SenseData != NULL)) {
//
// Make sure the hardware device does not return more data than expected.
//
if (SenseDataLen <= Packet->SenseDataLength) {
CopyMem (Packet->SenseData, Response->SenseData, SenseDataLen);
Packet->SenseDataLength = (UINT8)SenseDataLen;
} else {
Packet->SenseDataLength = 0;
}
}
//
// Check the transfer request result.
//
Packet->TargetStatus = Response->Status;
if (Response->Response != 0) {
DEBUG ((DEBUG_ERROR, "UfsExecScsiCmds() fails with Target Failure\n"));
Status = EFI_DEVICE_ERROR;
goto Exit;
}
if (TransReq->Trd->Ocs == 0) {
if (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {
if ((Response->Flags & BIT5) == BIT5) {
ResTranCount = Response->ResTranCount;
SwapLittleEndianToBigEndian ((UINT8*)&ResTranCount, sizeof (UINT32));
Packet->InTransferLength -= ResTranCount;
}
} else {
if ((Response->Flags & BIT5) == BIT5) {
ResTranCount = Response->ResTranCount;
SwapLittleEndianToBigEndian ((UINT8*)&ResTranCount, sizeof (UINT32));
Packet->OutTransferLength -= ResTranCount;
}
}
} else {
Status = EFI_DEVICE_ERROR;
}
Exit:
UfsHc->Flush (UfsHc);
UfsStopExecCmd (Private, TransReq->Slot);
UfsReconcileDataTransferBuffer (Private, TransReq);
Exit1:
if (TransReq->CmdDescMapping != NULL) {
UfsHc->Unmap (UfsHc, TransReq->CmdDescMapping);
}
if (TransReq->CmdDescHost != NULL) {
UfsHc->FreeBuffer (UfsHc, EFI_SIZE_TO_PAGES (TransReq->CmdDescSize), TransReq->CmdDescHost);
}
if (TransReq != NULL) {
FreePool (TransReq);
}
return Status;
}
/**
Send UIC command.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in, out] UicCommand UIC command descriptor. On exit contains UIC command results.
@return EFI_SUCCESS Successfully execute this UIC command and detect attached UFS device.
@return EFI_DEVICE_ERROR Fail to execute this UIC command and detect attached UFS device.
**/
EFI_STATUS
UfsExecUicCommands (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN OUT EDKII_UIC_COMMAND *UicCommand
)
{
EFI_STATUS Status;
UINT32 Data;
Status = UfsMmioRead32 (Private, UFS_HC_IS_OFFSET, &Data);
if (EFI_ERROR (Status)) {
return Status;
}
if ((Data & UFS_HC_IS_UCCS) == UFS_HC_IS_UCCS) {
//
// Clear IS.BIT10 UIC Command Completion Status (UCCS) at first.
//
Status = UfsMmioWrite32 (Private, UFS_HC_IS_OFFSET, Data);
if (EFI_ERROR (Status)) {
return Status;
}
}
//
// When programming UIC command registers, host software shall set the register UICCMD
// only after all the UIC command argument registers (UICCMDARG1, UICCMDARG2 and UICCMDARG3)
// are set.
//
Status = UfsMmioWrite32 (Private, UFS_HC_UCMD_ARG1_OFFSET, UicCommand->Arg1);
if (EFI_ERROR (Status)) {
return Status;
}
Status = UfsMmioWrite32 (Private, UFS_HC_UCMD_ARG2_OFFSET, UicCommand->Arg2);
if (EFI_ERROR (Status)) {
return Status;
}
Status = UfsMmioWrite32 (Private, UFS_HC_UCMD_ARG3_OFFSET, UicCommand->Arg3);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Host software shall only set the UICCMD if HCS.UCRDY is set to 1.
//
Status = UfsWaitMemSet (Private, UFS_HC_STATUS_OFFSET, UFS_HC_HCS_UCRDY, UFS_HC_HCS_UCRDY, UFS_TIMEOUT);
if (EFI_ERROR (Status)) {
return Status;
}
Status = UfsMmioWrite32 (Private, UFS_HC_UIC_CMD_OFFSET, UicCommand->Opcode);
if (EFI_ERROR (Status)) {
return Status;
}
//
// UFS 2.0 spec section 5.3.1 Offset:0x20 IS.Bit10 UIC Command Completion Status (UCCS)
// This bit is set to '1' by the host controller upon completion of a UIC command.
//
Status = UfsWaitMemSet (Private, UFS_HC_IS_OFFSET, UFS_HC_IS_UCCS, UFS_HC_IS_UCCS, UFS_TIMEOUT);
if (EFI_ERROR (Status)) {
return Status;
}
if (UicCommand->Opcode != UfsUicDmeReset) {
Status = UfsMmioRead32 (Private, UFS_HC_UCMD_ARG2_OFFSET, &UicCommand->Arg2);
if (EFI_ERROR (Status)) {
return Status;
}
Status = UfsMmioRead32 (Private, UFS_HC_UCMD_ARG3_OFFSET, &UicCommand->Arg3);
if (EFI_ERROR (Status)) {
return Status;
}
if ((UicCommand->Arg2 & 0xFF) != 0) {
DEBUG_CODE_BEGIN();
DumpUicCmdExecResult ((UINT8)UicCommand->Opcode, (UINT8)(UicCommand->Arg2 & 0xFF));
DEBUG_CODE_END();
return EFI_DEVICE_ERROR;
}
}
return EFI_SUCCESS;
}
/**
Allocate common buffer for host and UFS bus master access simultaneously.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@param[in] Size The length of buffer to be allocated.
@param[out] CmdDescHost A pointer to store the base system memory address of the allocated range.
@param[out] CmdDescPhyAddr The resulting map address for the UFS bus master to use to access the hosts CmdDescHost.
@param[out] CmdDescMapping A resulting value to pass to Unmap().
@retval EFI_SUCCESS The common buffer was allocated successfully.
@retval EFI_DEVICE_ERROR The allocation fails.
@retval EFI_OUT_OF_RESOURCES The memory resource is insufficient.
**/
EFI_STATUS
UfsAllocateAlignCommonBuffer (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UINTN Size,
OUT VOID **CmdDescHost,
OUT EFI_PHYSICAL_ADDRESS *CmdDescPhyAddr,
OUT VOID **CmdDescMapping
)
{
EFI_STATUS Status;
UINTN Bytes;
BOOLEAN Is32BitAddr;
EDKII_UFS_HOST_CONTROLLER_PROTOCOL *UfsHc;
if ((Private->UfsHcInfo.Capabilities & UFS_HC_CAP_64ADDR) == UFS_HC_CAP_64ADDR) {
Is32BitAddr = FALSE;
} else {
Is32BitAddr = TRUE;
}
UfsHc = Private->UfsHostController;
Status = UfsHc->AllocateBuffer (
UfsHc,
AllocateAnyPages,
EfiBootServicesData,
EFI_SIZE_TO_PAGES (Size),
CmdDescHost,
0
);
if (EFI_ERROR (Status)) {
*CmdDescMapping = NULL;
*CmdDescHost = NULL;
*CmdDescPhyAddr = 0;
return EFI_OUT_OF_RESOURCES;
}
Bytes = EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (Size));
Status = UfsHc->Map (
UfsHc,
EdkiiUfsHcOperationBusMasterCommonBuffer,
*CmdDescHost,
&Bytes,
CmdDescPhyAddr,
CmdDescMapping
);
if (EFI_ERROR (Status) || (Bytes != EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (Size)))) {
UfsHc->FreeBuffer (
UfsHc,
EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (Size)),
*CmdDescHost
);
*CmdDescHost = NULL;
return EFI_OUT_OF_RESOURCES;
}
if (Is32BitAddr && ((*CmdDescPhyAddr) > 0x100000000ULL)) {
//
// The UFS host controller doesn't support 64bit addressing, so should not get a >4G UFS bus master address.
//
UfsHc->Unmap (
UfsHc,
*CmdDescMapping
);
UfsHc->FreeBuffer (
UfsHc,
EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (Size)),
*CmdDescHost
);
*CmdDescMapping = NULL;
*CmdDescHost = NULL;
return EFI_DEVICE_ERROR;
}
ZeroMem (*CmdDescHost, EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (Size)));
return EFI_SUCCESS;
}
/**
Enable the UFS host controller for accessing.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@retval EFI_SUCCESS The UFS host controller enabling was executed successfully.
@retval EFI_DEVICE_ERROR A device error occurred while enabling the UFS host controller.
**/
EFI_STATUS
UfsEnableHostController (
IN UFS_PASS_THRU_PRIVATE_DATA *Private
)
{
EFI_STATUS Status;
UINT32 Data;
if (mUfsHcPlatform != NULL && mUfsHcPlatform->Callback != NULL) {
Status = mUfsHcPlatform->Callback (Private->Handle, EdkiiUfsHcPreHce, &Private->UfsHcDriverInterface);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failure from platform driver during EdkiiUfsHcPreHce, Status = %r\n", Status));
return Status;
}
}
//
// UFS 2.0 spec section 7.1.1 - Host Controller Initialization
//
// Reinitialize the UFS host controller if HCE bit of HC register is set.
//
Status = UfsMmioRead32 (Private, UFS_HC_ENABLE_OFFSET, &Data);
if (EFI_ERROR (Status)) {
return Status;
}
if ((Data & UFS_HC_HCE_EN) == UFS_HC_HCE_EN) {
//
// Write a 0 to the HCE register at first to disable the host controller.
//
Status = UfsMmioWrite32 (Private, UFS_HC_ENABLE_OFFSET, 0);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Wait until HCE is read as '0' before continuing.
//
Status = UfsWaitMemSet (Private, UFS_HC_ENABLE_OFFSET, UFS_HC_HCE_EN, 0, UFS_TIMEOUT);
if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}
}
//
// Write a 1 to the HCE register to enable the UFS host controller.
//
Status = UfsMmioWrite32 (Private, UFS_HC_ENABLE_OFFSET, UFS_HC_HCE_EN);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Wait until HCE is read as '1' before continuing.
//
Status = UfsWaitMemSet (Private, UFS_HC_ENABLE_OFFSET, UFS_HC_HCE_EN, UFS_HC_HCE_EN, UFS_TIMEOUT);
if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}
if (mUfsHcPlatform != NULL && mUfsHcPlatform->Callback != NULL) {
Status = mUfsHcPlatform->Callback (Private->Handle, EdkiiUfsHcPostHce, &Private->UfsHcDriverInterface);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failure from platform driver during EdkiiUfsHcPostHce, Status = %r\n", Status));
return Status;
}
}
return EFI_SUCCESS;
}
/**
Detect if a UFS device attached.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@retval EFI_SUCCESS The UFS device detection was executed successfully.
@retval EFI_NOT_FOUND Not found a UFS device attached.
@retval EFI_DEVICE_ERROR A device error occurred while detecting the UFS device.
**/
EFI_STATUS
UfsDeviceDetection (
IN UFS_PASS_THRU_PRIVATE_DATA *Private
)
{
UINTN Retry;
EFI_STATUS Status;
UINT32 Data;
EDKII_UIC_COMMAND LinkStartupCommand;
if (mUfsHcPlatform != NULL && mUfsHcPlatform->Callback != NULL) {
Status = mUfsHcPlatform->Callback (Private->Handle, EdkiiUfsHcPreLinkStartup, &Private->UfsHcDriverInterface);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failure from platform driver during EdkiiUfsHcPreLinkStartup, Status = %r\n", Status));
return Status;
}
}
//
// Start UFS device detection.
// Try up to 3 times for establishing data link with device.
//
for (Retry = 0; Retry < 3; Retry++) {
LinkStartupCommand.Opcode = UfsUicDmeLinkStartup;
LinkStartupCommand.Arg1 = 0;
LinkStartupCommand.Arg2 = 0;
LinkStartupCommand.Arg3 = 0;
Status = UfsExecUicCommands (Private, &LinkStartupCommand);
if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}
Status = UfsMmioRead32 (Private, UFS_HC_STATUS_OFFSET, &Data);
if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}
if ((Data & UFS_HC_HCS_DP) == 0) {
Status = UfsWaitMemSet (Private, UFS_HC_IS_OFFSET, UFS_HC_IS_ULSS, UFS_HC_IS_ULSS, UFS_TIMEOUT);
if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}
} else {
if (mUfsHcPlatform != NULL && mUfsHcPlatform->Callback != NULL) {
Status = mUfsHcPlatform->Callback (Private->Handle, EdkiiUfsHcPostLinkStartup, &Private->UfsHcDriverInterface);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failure from platform driver during EdkiiUfsHcPostLinkStartup, Status = %r\n", Status));
return Status;
}
}
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
/**
Initialize UFS task management request list related h/w context.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@retval EFI_SUCCESS The UFS task management list was initialzed successfully.
@retval EFI_DEVICE_ERROR The initialization fails.
**/
EFI_STATUS
UfsInitTaskManagementRequestList (
IN UFS_PASS_THRU_PRIVATE_DATA *Private
)
{
UINT8 Nutmrs;
VOID *CmdDescHost;
EFI_PHYSICAL_ADDRESS CmdDescPhyAddr;
VOID *CmdDescMapping;
EFI_STATUS Status;
//
// Initial h/w and s/w context for future operations.
//
CmdDescHost = NULL;
CmdDescMapping = NULL;
CmdDescPhyAddr = 0;
//
// Allocate and initialize UTP Task Management Request List.
//
Nutmrs = (UINT8) (RShiftU64 ((Private->UfsHcInfo.Capabilities & UFS_HC_CAP_NUTMRS), 16) + 1);
Status = UfsAllocateAlignCommonBuffer (Private, Nutmrs * sizeof (UTP_TMRD), &CmdDescHost, &CmdDescPhyAddr, &CmdDescMapping);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Program the UTP Task Management Request List Base Address and UTP Task Management
// Request List Base Address with a 64-bit address allocated at step 6.
//
Status = UfsMmioWrite32 (Private, UFS_HC_UTMRLBA_OFFSET, (UINT32)(UINTN)CmdDescPhyAddr);
if (EFI_ERROR (Status)) {
return Status;
}
Status = UfsMmioWrite32 (Private, UFS_HC_UTMRLBAU_OFFSET, (UINT32)RShiftU64 ((UINT64)CmdDescPhyAddr, 32));
if (EFI_ERROR (Status)) {
return Status;
}
Private->UtpTmrlBase = CmdDescHost;
Private->Nutmrs = Nutmrs;
Private->TmrlMapping = CmdDescMapping;
//
// Enable the UTP Task Management Request List by setting the UTP Task Management
// Request List RunStop Register (UTMRLRSR) to '1'.
//
Status = UfsMmioWrite32 (Private, UFS_HC_UTMRLRSR_OFFSET, UFS_HC_UTMRLRSR);
if (EFI_ERROR (Status)) {
return Status;
}
return EFI_SUCCESS;
}
/**
Initialize UFS transfer request list related h/w context.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@retval EFI_SUCCESS The UFS transfer list was initialzed successfully.
@retval EFI_DEVICE_ERROR The initialization fails.
**/
EFI_STATUS
UfsInitTransferRequestList (
IN UFS_PASS_THRU_PRIVATE_DATA *Private
)
{
UINT8 Nutrs;
VOID *CmdDescHost;
EFI_PHYSICAL_ADDRESS CmdDescPhyAddr;
VOID *CmdDescMapping;
EFI_STATUS Status;
//
// Initial h/w and s/w context for future operations.
//
CmdDescHost = NULL;
CmdDescMapping = NULL;
CmdDescPhyAddr = 0;
//
// Allocate and initialize UTP Transfer Request List.
//
Nutrs = (UINT8)((Private->UfsHcInfo.Capabilities & UFS_HC_CAP_NUTRS) + 1);
Status = UfsAllocateAlignCommonBuffer (Private, Nutrs * sizeof (UTP_TRD), &CmdDescHost, &CmdDescPhyAddr, &CmdDescMapping);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Program the UTP Transfer Request List Base Address and UTP Transfer Request List
// Base Address with a 64-bit address allocated at step 8.
//
Status = UfsMmioWrite32 (Private, UFS_HC_UTRLBA_OFFSET, (UINT32)(UINTN)CmdDescPhyAddr);
if (EFI_ERROR (Status)) {
return Status;
}
Status = UfsMmioWrite32 (Private, UFS_HC_UTRLBAU_OFFSET, (UINT32)RShiftU64 ((UINT64)CmdDescPhyAddr, 32));
if (EFI_ERROR (Status)) {
return Status;
}
Private->UtpTrlBase = CmdDescHost;
Private->Nutrs = Nutrs;
Private->TrlMapping = CmdDescMapping;
//
// Enable the UTP Transfer Request List by setting the UTP Transfer Request List
// RunStop Register (UTRLRSR) to '1'.
//
Status = UfsMmioWrite32 (Private, UFS_HC_UTRLRSR_OFFSET, UFS_HC_UTRLRSR);
if (EFI_ERROR (Status)) {
return Status;
}
return EFI_SUCCESS;
}
/**
Initialize the UFS host controller.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@retval EFI_SUCCESS The Ufs Host Controller is initialized successfully.
@retval Others A device error occurred while initializing the controller.
**/
EFI_STATUS
UfsControllerInit (
IN UFS_PASS_THRU_PRIVATE_DATA *Private
)
{
EFI_STATUS Status;
Status = UfsEnableHostController (Private);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "UfsControllerInit: Enable Host Controller Fails, Status = %r\n", Status));
return Status;
}
Status = UfsDeviceDetection (Private);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "UfsControllerInit: Device Detection Fails, Status = %r\n", Status));
return Status;
}
Status = UfsInitTaskManagementRequestList (Private);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "UfsControllerInit: Task management list initialization Fails, Status = %r\n", Status));
return Status;
}
Status = UfsInitTransferRequestList (Private);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "UfsControllerInit: Transfer list initialization Fails, Status = %r\n", Status));
return Status;
}
DEBUG ((DEBUG_INFO, "UfsControllerInit Finished\n"));
return EFI_SUCCESS;
}
/**
Stop the UFS host controller.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data structure.
@retval EFI_SUCCESS The Ufs Host Controller is stopped successfully.
@retval Others A device error occurred while stopping the controller.
**/
EFI_STATUS
UfsControllerStop (
IN UFS_PASS_THRU_PRIVATE_DATA *Private
)
{
EFI_STATUS Status;
UINT32 Data;
//
// Enable the UTP Task Management Request List by setting the UTP Task Management
// Request List RunStop Register (UTMRLRSR) to '1'.
//
Status = UfsMmioWrite32 (Private, UFS_HC_UTMRLRSR_OFFSET, 0);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Enable the UTP Transfer Request List by setting the UTP Transfer Request List
// RunStop Register (UTRLRSR) to '1'.
//
Status = UfsMmioWrite32 (Private, UFS_HC_UTRLRSR_OFFSET, 0);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Write a 0 to the HCE register in order to disable the host controller.
//
Status = UfsMmioRead32 (Private, UFS_HC_ENABLE_OFFSET, &Data);
if (EFI_ERROR (Status)) {
return Status;
}
ASSERT ((Data & UFS_HC_HCE_EN) == UFS_HC_HCE_EN);
Status = UfsMmioWrite32 (Private, UFS_HC_ENABLE_OFFSET, 0);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Wait until HCE is read as '0' before continuing.
//
Status = UfsWaitMemSet (Private, UFS_HC_ENABLE_OFFSET, UFS_HC_HCE_EN, 0, UFS_TIMEOUT);
if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}
DEBUG ((DEBUG_INFO, "UfsController is stopped\n"));
return EFI_SUCCESS;
}
/**
Internal helper function which will signal the caller event and clean up
resources.
@param[in] Private The pointer to the UFS_PASS_THRU_PRIVATE_DATA data
structure.
@param[in] TransReq The pointer to the UFS_PASS_THRU_TRANS_REQ data
structure.
**/
VOID
EFIAPI
SignalCallerEvent (
IN UFS_PASS_THRU_PRIVATE_DATA *Private,
IN UFS_PASS_THRU_TRANS_REQ *TransReq
)
{
EDKII_UFS_HOST_CONTROLLER_PROTOCOL *UfsHc;
EFI_EVENT CallerEvent;
ASSERT ((Private != NULL) && (TransReq != NULL));
UfsHc = Private->UfsHostController;
CallerEvent = TransReq->CallerEvent;
RemoveEntryList (&TransReq->TransferList);
UfsHc->Flush (UfsHc);
UfsStopExecCmd (Private, TransReq->Slot);
UfsReconcileDataTransferBuffer (Private, TransReq);
if (TransReq->CmdDescMapping != NULL) {
UfsHc->Unmap (UfsHc, TransReq->CmdDescMapping);
}
if (TransReq->CmdDescHost != NULL) {
UfsHc->FreeBuffer (
UfsHc,
EFI_SIZE_TO_PAGES (TransReq->CmdDescSize),
TransReq->CmdDescHost
);
}
FreePool (TransReq);
gBS->SignalEvent (CallerEvent);
return;
}
/**
Call back function when the timer event is signaled.
@param[in] Event The Event this notify function registered to.
@param[in] Context Pointer to the context data registered to the Event.
**/
VOID
EFIAPI
ProcessAsyncTaskList (
IN EFI_EVENT Event,
IN VOID *Context
)
{
UFS_PASS_THRU_PRIVATE_DATA *Private;
LIST_ENTRY *Entry;
LIST_ENTRY *NextEntry;
UFS_PASS_THRU_TRANS_REQ *TransReq;
EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet;
UTP_RESPONSE_UPIU *Response;
UINT16 SenseDataLen;
UINT32 ResTranCount;
UINT32 SlotsMap;
UINT32 Value;
EFI_STATUS Status;
Private = (UFS_PASS_THRU_PRIVATE_DATA*) Context;
SlotsMap = 0;
//
// Check the entries in the async I/O queue are done or not.
//
if (!IsListEmpty(&Private->Queue)) {
EFI_LIST_FOR_EACH_SAFE (Entry, NextEntry, &Private->Queue) {
TransReq = UFS_PASS_THRU_TRANS_REQ_FROM_THIS (Entry);
Packet = TransReq->Packet;
if ((SlotsMap & (BIT0 << TransReq->Slot)) != 0) {
return;
}
SlotsMap |= BIT0 << TransReq->Slot;
Status = UfsMmioRead32 (Private, UFS_HC_UTRLDBR_OFFSET, &Value);
if (EFI_ERROR (Status)) {
//
// TODO: Should find/add a proper host adapter return status for this
// case.
//
Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PHASE_ERROR;
DEBUG ((DEBUG_VERBOSE, "ProcessAsyncTaskList(): Signal Event %p UfsMmioRead32() Error.\n", TransReq->CallerEvent));
SignalCallerEvent (Private, TransReq);
continue;
}
if ((Value & (BIT0 << TransReq->Slot)) != 0) {
//
// Scsi cmd not finished yet.
//
if (TransReq->TimeoutRemain > UFS_HC_ASYNC_TIMER) {
TransReq->TimeoutRemain -= UFS_HC_ASYNC_TIMER;
continue;
} else {
//
// Timeout occurs.
//
Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT_COMMAND;
DEBUG ((DEBUG_VERBOSE, "ProcessAsyncTaskList(): Signal Event %p EFI_TIMEOUT.\n", TransReq->CallerEvent));
SignalCallerEvent (Private, TransReq);
continue;
}
} else {
//
// Scsi cmd finished.
//
// Get sense data if exists
//
Response = (UTP_RESPONSE_UPIU*)((UINT8*)TransReq->CmdDescHost + TransReq->Trd->RuO * sizeof (UINT32));
ASSERT (Response != NULL);
SenseDataLen = Response->SenseDataLen;
SwapLittleEndianToBigEndian ((UINT8*)&SenseDataLen, sizeof (UINT16));
if ((Packet->SenseDataLength != 0) && (Packet->SenseData != NULL)) {
//
// Make sure the hardware device does not return more data than expected.
//
if (SenseDataLen <= Packet->SenseDataLength) {
CopyMem (Packet->SenseData, Response->SenseData, SenseDataLen);
Packet->SenseDataLength = (UINT8)SenseDataLen;
} else {
Packet->SenseDataLength = 0;
}
}
//
// Check the transfer request result.
//
Packet->TargetStatus = Response->Status;
if (Response->Response != 0) {
DEBUG ((DEBUG_VERBOSE, "ProcessAsyncTaskList(): Signal Event %p Target Failure.\n", TransReq->CallerEvent));
SignalCallerEvent (Private, TransReq);
continue;
}
if (TransReq->Trd->Ocs == 0) {
if (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {
if ((Response->Flags & BIT5) == BIT5) {
ResTranCount = Response->ResTranCount;
SwapLittleEndianToBigEndian ((UINT8*)&ResTranCount, sizeof (UINT32));
Packet->InTransferLength -= ResTranCount;
}
} else {
if ((Response->Flags & BIT5) == BIT5) {
ResTranCount = Response->ResTranCount;
SwapLittleEndianToBigEndian ((UINT8*)&ResTranCount, sizeof (UINT32));
Packet->OutTransferLength -= ResTranCount;
}
}
} else {
DEBUG ((DEBUG_VERBOSE, "ProcessAsyncTaskList(): Signal Event %p Target Device Error.\n", TransReq->CallerEvent));
SignalCallerEvent (Private, TransReq);
continue;
}
DEBUG ((DEBUG_VERBOSE, "ProcessAsyncTaskList(): Signal Event %p Success.\n", TransReq->CallerEvent));
SignalCallerEvent (Private, TransReq);
}
}
}
}
/**
Execute UIC command.
@param[in] This Pointer to driver interface produced by the UFS controller.
@param[in, out] UicCommand Descriptor of the command that will be executed.
@retval EFI_SUCCESS Command executed successfully.
@retval EFI_INVALID_PARAMETER This or UicCommand is NULL.
@retval Others Command failed to execute.
**/
EFI_STATUS
EFIAPI
UfsHcDriverInterfaceExecUicCommand (
IN EDKII_UFS_HC_DRIVER_INTERFACE *This,
IN OUT EDKII_UIC_COMMAND *UicCommand
)
{
UFS_PASS_THRU_PRIVATE_DATA *Private;
if (This == NULL || UicCommand == NULL) {
return EFI_INVALID_PARAMETER;
}
Private = UFS_PASS_THRU_PRIVATE_DATA_FROM_DRIVER_INTF (This);
return UfsExecUicCommands (Private, UicCommand);
}
/**
Initializes UfsHcInfo field in private data.
@param[in] Private Pointer to host controller private data.
@retval EFI_SUCCESS UfsHcInfo initialized successfully.
@retval Others Failed to initalize UfsHcInfo.
**/
EFI_STATUS
GetUfsHcInfo (
IN UFS_PASS_THRU_PRIVATE_DATA *Private
)
{
UINT32 Data;
EFI_STATUS Status;
Status = UfsMmioRead32 (Private, UFS_HC_VER_OFFSET, &Data);
if (EFI_ERROR (Status)) {
return Status;
}
Private->UfsHcInfo.Version = Data;
Status = UfsMmioRead32 (Private, UFS_HC_CAP_OFFSET, &Data);
if (EFI_ERROR (Status)) {
return Status;
}
Private->UfsHcInfo.Capabilities = Data;
if (mUfsHcPlatform != NULL && mUfsHcPlatform->OverrideHcInfo != NULL) {
Status = mUfsHcPlatform->OverrideHcInfo (Private->Handle, &Private->UfsHcInfo);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failure from platform on OverrideHcInfo, Status = %r\n", Status));
return Status;
}
}
return EFI_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink