/*******************************************************************************
*Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
*
*Redistribution and use in source and binary forms, with or without modification, are permitted provided
*that the following conditions are met:
*1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
*following disclaimer.
*2. Redistributions in binary form must reproduce the above copyright notice,
*this list of conditions and the following disclaimer in the documentation and/or other materials provided
*with the distribution.
*
*THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
*WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
*FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
*NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
*BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
*LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
*SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
********************************************************************************/
/*******************************************************************************/
/*! \file sasata.c
* \brief The file implements the functions to SATA IO
*
*/
/******************************************************************************/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <dev/pms/config.h>
#include <dev/pms/RefTisa/sallsdk/spc/saglobal.h>
#ifdef SA_ENABLE_TRACE_FUNCTIONS
#ifdef siTraceFileID
#undef siTraceFileID
#endif
#define siTraceFileID 'M'
#endif
/******************************************************************************/
/*! \brief Start SATA command
*
* Start SATA command
*
* \param agRoot handles for this instance of SAS/SATA hardware
* \param queueNum
* \param agIORequest
* \param agDevHandle
* \param agRequestType
* \param agSATAReq
* \param agTag
* \param agCB
*
* \return If command is started successfully
* - \e AGSA_RC_SUCCESS command is started successfully
* - \e AGSA_RC_FAILURE command is not started successfully
*/
/*******************************************************************************/
GLOBAL bit32 saSATAStart(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 queueNum,
agsaDevHandle_t *agDevHandle,
bit32 agRequestType,
agsaSATAInitiatorRequest_t *agSATAReq,
bit8 agTag,
ossaSATACompletedCB_t agCB
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
mpiICQueue_t *circularQ = agNULL;
agsaDeviceDesc_t *pDevice = agNULL;
agsaPort_t *pPort = agNULL;
agsaIORequestDesc_t *pRequest = agNULL;
void *pMessage = agNULL;
agsaSgl_t *pSgl = agNULL;
bit32 *payload = agNULL;
bit32 deviceIndex = 0;
bit32 ret = AGSA_RC_SUCCESS, retVal = 0;
bit32 AtapDir = 0;
bit32 encryptFlags = 0;
bit16 size = 0;
bit16 opCode = 0;
bit8 inq = 0, outq = 0;
OSSA_INP_ENTER(agRoot);
smTraceFuncEnter(hpDBG_VERY_LOUD, "8a");
SA_DBG3(("saSATAStart: in\n"));
/* sanity check */
SA_ASSERT((agNULL != agRoot), "(saSATAStart) agRoot is NULL");
SA_ASSERT((agNULL != agIORequest), "(saSATAStart) agIORequest is NULL");
SA_ASSERT((agNULL != agDevHandle), "(saSATAStart) agDevHandle is NULL");
SA_ASSERT((agNULL != agSATAReq), "(saSATAStart) agSATAReq is NULL");
/* Assign inbound and outbound queue */
inq = (bit8)(queueNum & MPI_IB_NUM_MASK);
outq = (bit8)((queueNum & MPI_OB_NUM_MASK) >> MPI_OB_SHIFT);
SA_ASSERT((AGSA_MAX_INBOUND_Q > inq), "The IBQ Number is out of range.");
/* Find the outgoing port for the device */
pDevice = (agsaDeviceDesc_t *) (agDevHandle->sdkData);
SA_ASSERT((agNULL != pDevice), "(saSATAStart) pDevice is NULL");
pPort = pDevice->pPort;
SA_ASSERT((agNULL != pPort), "(saSATAStart) pPort is NULL");
/* SATA DIF is obsolete */
if (agSATAReq->option & AGSA_SATA_ENABLE_DIF)
{
return AGSA_RC_FAILURE;
}
/* find deviceID for IOMB */
deviceIndex = pDevice->DeviceMapIndex;
/* Get request from free IORequests */
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL != pRequest )
{
/* If free IOMB avaliable */
/* Remove the request from free list */
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
/* Add the request to the pendingSTARequests list of the device */
pRequest->valid = agTRUE;
saLlistIOAdd(&(pDevice->pendingIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
if ((agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION) ||
(agSATAReq->option & AGSA_SATA_ENABLE_DIF))
{
opCode = OPC_INB_SATA_DIF_ENC_OPSTART;
size = IOMB_SIZE128;
}
else
{
opCode = OPC_INB_SATA_HOST_OPSTART;
if (agRequestType == AGSA_SATA_PROTOCOL_NON_PKT ||
agRequestType == AGSA_SATA_PROTOCOL_H2D_PKT ||
agRequestType == AGSA_SATA_PROTOCOL_D2H_PKT)
size = IOMB_SIZE128;
else
size = IOMB_SIZE64;
}
/* If LL IO request entry avaliable */
/* set up pRequest */
pRequest->pIORequestContext = agIORequest;
pRequest->pDevice = pDevice;
pRequest->pPort = pPort;
pRequest->requestType = agRequestType;
pRequest->startTick = saRoot->timeTick;
pRequest->completionCB = (ossaSSPCompletedCB_t)agCB;
/* Set request to the sdkData of agIORequest */
agIORequest->sdkData = pRequest;
/* save tag and IOrequest pointer to IOMap */
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif /* SA_LL_IBQ_PROTECT */
/* get a free inbound queue entry */
circularQ = &saRoot->inboundQueue[inq];
retVal = mpiMsgFreeGet(circularQ, size, &pMessage);
if (AGSA_RC_FAILURE == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif /* SA_LL_IBQ_PROTECT */
/* if not sending return to free list rare */
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG3(("saSATAStart, error when get free IOMB\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "8a");
ret = AGSA_RC_FAILURE;
goto ext;
}
/* return busy if inbound queue is full */
if (AGSA_RC_BUSY == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif /* SA_LL_IBQ_PROTECT */
/* if not sending return to free list rare */
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSATAStart, no more IOMB\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "8a");
ret = AGSA_RC_BUSY;
goto ext;
}
}
else /* If no LL IO request entry available */
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSATAStart, No request from free list\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "8a");
ret = AGSA_RC_BUSY;
goto ext;
}
payload = (bit32 *)pMessage;
SA_DBG4(("saSATAStart: Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
switch ( agRequestType )
{
case AGSA_SATA_PROTOCOL_FPDMA_READ:
case AGSA_SATA_PROTOCOL_FPDMA_WRITE:
case AGSA_SATA_PROTOCOL_FPDMA_READ_M:
case AGSA_SATA_PROTOCOL_FPDMA_WRITE_M:
pSgl = &(agSATAReq->agSgl);
AtapDir = agRequestType & (AGSA_DIR_MASK | AGSA_SATA_ATAP_MASK);
if (agRequestType & AGSA_MSG)
{
/* set M bit */
AtapDir |= AGSA_MSG_BIT;
}
break;
case AGSA_SATA_PROTOCOL_DMA_READ:
case AGSA_SATA_PROTOCOL_DMA_WRITE:
case AGSA_SATA_PROTOCOL_DMA_READ_M:
case AGSA_SATA_PROTOCOL_DMA_WRITE_M:
case AGSA_SATA_PROTOCOL_PIO_READ_M:
case AGSA_SATA_PROTOCOL_PIO_WRITE_M:
case AGSA_SATA_PROTOCOL_PIO_READ:
case AGSA_SATA_PROTOCOL_PIO_WRITE:
case AGSA_SATA_PROTOCOL_H2D_PKT:
case AGSA_SATA_PROTOCOL_D2H_PKT:
agTag = 0; /* agTag not valid for these requests */
pSgl = &(agSATAReq->agSgl);
AtapDir = agRequestType & (AGSA_DIR_MASK | AGSA_SATA_ATAP_MASK);
if (agRequestType & AGSA_MSG)
{
/* set M bit */
AtapDir |= AGSA_MSG_BIT;
}
break;
case AGSA_SATA_PROTOCOL_NON_DATA:
case AGSA_SATA_PROTOCOL_NON_DATA_M:
case AGSA_SATA_PROTOCOL_NON_PKT:
agTag = 0; /* agTag not valid for these requests */
AtapDir = agRequestType & (AGSA_DIR_MASK | AGSA_SATA_ATAP_MASK);
if (agRequestType & AGSA_MSG)
{
/* set M bit */
AtapDir |= AGSA_MSG_BIT;
}
break;
case AGSA_SATA_PROTOCOL_SRST_ASSERT:
agTag = 0; /* agTag not valid for these requests */
AtapDir = AGSA_SATA_ATAP_SRST_ASSERT;
break;
case AGSA_SATA_PROTOCOL_SRST_DEASSERT:
agTag = 0; /* agTag not valid for these requests */
AtapDir = AGSA_SATA_ATAP_SRST_DEASSERT;
break;
case AGSA_SATA_PROTOCOL_DEV_RESET:
case AGSA_SATA_PROTOCOL_DEV_RESET_M: /* TestBase */
agTag = 0; /* agTag not valid for these requests */
AtapDir = AGSA_SATA_ATAP_PKT_DEVRESET;
if (agRequestType & AGSA_MSG)
{
/* set M bit */
AtapDir |= AGSA_MSG_BIT; /* TestBase */
}
break;
default:
SA_DBG1(("saSATAStart: (Unknown agRequestType) 0x%X \n",agRequestType));
SA_ASSERT((0), "saSATAStart: (Unknown agRequestType)");
break;
}
if ((AGSA_SATA_PROTOCOL_SRST_ASSERT == agRequestType) ||
(AGSA_SATA_PROTOCOL_SRST_DEASSERT == agRequestType) ||
(AGSA_SATA_PROTOCOL_DEV_RESET == agRequestType))
{
SA_DBG3(("saSATAStart:AGSA_SATA_PROTOCOL_SRST_DEASSERT AGSA_SATA_PROTOCOL_SRST_ASSERT\n"));
si_memset((void *)payload, 0, sizeof(agsaSATAStartCmd_t));
/* build IOMB DW 1 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t, tag), pRequest->HTag);
/* DWORD 2 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,deviceId ), deviceIndex);
/* DWORD 3 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,dataLen ), 0 );
/* DWORD 4 */
OSSA_WRITE_LE_32(agRoot,
payload,
OSSA_OFFSET_OF(agsaSATAStartCmd_t,optNCQTagataProt ),
(((agSATAReq->option & SATA_FIS_MASK) << SHIFT24) |
(agTag << SHIFT16) |
AtapDir));
si_memcpy((void *)(payload+4), (void *)&agSATAReq->fis.fisRegHostToDev, sizeof(agsaFisRegHostToDevice_t));
}
else
{
/* build IOMB DW 1 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t, tag), pRequest->HTag);
/* DWORD 2 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,deviceId ), deviceIndex);
/* DWORD 3 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,dataLen ), agSATAReq->dataLength );
/* Since we are writing the payload in order, check for any special modes now. */
if (agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION)
{
SA_ASSERT((opCode == OPC_INB_SATA_DIF_ENC_OPSTART), "opcode");
SA_DBG4(("saSATAStart: 1 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
AtapDir |= AGSA_ENCRYPT_BIT;
}
if (agSATAReq->option & AGSA_SATA_ENABLE_DIF)
{
SA_ASSERT((opCode == OPC_INB_SATA_DIF_ENC_OPSTART), "opcode");
AtapDir |= AGSA_DIF_BIT;
}
#ifdef CCBUILD_TEST_EPL
if(agSATAReq->encrypt.enableEncryptionPerLA)
AtapDir |= (1 << SHIFT4); // enable EPL
#endif
/* DWORD 4 */
OSSA_WRITE_LE_32(agRoot,
payload,
OSSA_OFFSET_OF(agsaSATAStartCmd_t,optNCQTagataProt ),
(((agSATAReq->option & SATA_FIS_MASK) << SHIFT24) |
(agTag << SHIFT16) |
AtapDir));
/* DWORD 5 6 7 8 9 */
si_memcpy((void *)(payload+4), (void *)&agSATAReq->fis.fisRegHostToDev, sizeof(agsaFisRegHostToDevice_t));
/* DWORD 10 reserved */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,reserved1 ), 0 );
/* DWORD 11 reserved */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,reserved2 ), 0 );
SA_DBG4(("saSATAStart: 2 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
}
if (agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION)
{
/* Write 10 dwords of zeroes as payload, skipping all DIF fields */
SA_DBG4(("saSATAStart: 2a Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
if (opCode == OPC_INB_SATA_DIF_ENC_OPSTART)
{
/* DW 11 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_EPL_DESCL ),0 );
/* DW 12 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,resSKIPBYTES ),0 );
/* DW 13 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_DPL_DESCL_NDPLR ),0 );
/* DW 14 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_EDPL_DESCH ),0 );
/* DW 15 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,DIF_flags ),0 );
/* DW 16 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,udt ),0 );
/* DW 17 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,udtReplacementLo ),0 );
/* DW 18 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,udtReplacementHi ),0 );
/* DW 19 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,DIF_seed ),0 );
}
if (agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION)
{
SA_ASSERT((opCode == OPC_INB_SATA_DIF_ENC_OPSTART), "opcode");
SA_DBG4(("saSATAStart: 3 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
/* Configure DWORD 20 */
encryptFlags = 0;
if (agSATAReq->encrypt.keyTagCheck == agTRUE)
{
encryptFlags |= AGSA_ENCRYPT_KEY_TAG_BIT;
}
if( agSATAReq->encrypt.cipherMode == agsaEncryptCipherModeXTS )
{
encryptFlags |= AGSA_ENCRYPT_XTS_Mode << SHIFT4;
}
encryptFlags |= agSATAReq->encrypt.dekInfo.dekTable << SHIFT2;
encryptFlags |= (agSATAReq->encrypt.dekInfo.dekIndex & 0xFFFFFF) << SHIFT8;
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,encryptFlagsLo ),encryptFlags );
/* Configure DWORD 21*/
/* This information is available in the sectorSizeIndex */
encryptFlags = agSATAReq->encrypt.sectorSizeIndex;
/*
* Set Region0 sectors count
*/
if(agSATAReq->encrypt.enableEncryptionPerLA)
{
encryptFlags |= (agSATAReq->encrypt.EncryptionPerLRegion0SecCount << SHIFT16);
}
encryptFlags |= (agSATAReq->encrypt.kekIndex) << SHIFT5;
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,encryptFlagsHi ),encryptFlags );
/* Configure DWORD 22*/
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagLo ), agSATAReq->encrypt.keyTag_W0 );
/* Configure DWORD 23 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagHi ), agSATAReq->encrypt.keyTag_W1 );
/* Configure DWORD 24 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W0 ), agSATAReq->encrypt.tweakVal_W0 );
/* Configure DWORD 25 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W1 ), agSATAReq->encrypt.tweakVal_W1 );
/* Configure DWORD 26 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W2 ), agSATAReq->encrypt.tweakVal_W2 );
/* Configure DWORD 27 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W3 ), agSATAReq->encrypt.tweakVal_W3 );
}
else
{
/* Write 8 dwords of zeros as payload, skipping all encryption fields */
if (opCode == OPC_INB_SATA_DIF_ENC_OPSTART)
{
/* Configure DWORD 22*/
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagLo ), 0 );
/* Configure DWORD 23 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagHi ), 0 );
/* Configure DWORD 24 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W0 ), 0 );
/* Configure DWORD 25 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W1 ), 0 );
/* Configure DWORD 26 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W2 ), 0 );
/* Configure DWORD 27 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W3 ), 0 );
}
}
SA_DBG4(("saSATAStart: 4 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
/* DWORD 11 13 14*/
if(agSATAReq->encrypt.enableEncryptionPerLA)
{
/* DWORD 11 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_EPL_DESCL),
agSATAReq->encrypt.EncryptionPerLAAddrLo);
/* DWORD 13 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_DPL_DESCL_NDPLR), 0);
/* DWORD 14 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_EDPL_DESCH),
agSATAReq->encrypt.EncryptionPerLAAddrHi);
}
else
{
/* DWORD 11 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_EPL_DESCL),0);
/* DW 13 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_DPL_DESCL_NDPLR), 0);
/* DWORD 14 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_EDPL_DESCH ),0 );
}
/* Configure DWORD 28 for encryption*/
if (pSgl)
{
/* Configure DWORD 28 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrLow0 ), pSgl->sgLower );
/* Configure DWORD 29 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrHi0 ), pSgl->sgUpper );
/* Configure DWORD 30 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Len0 ), pSgl->len );
/* Configure DWORD 31 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,E0 ), pSgl->extReserved );
}
else
{
/* Configure DWORD 28 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrLow0 ), 0 );
/* Configure DWORD 29 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrHi0 ), 0 );
/* Configure DWORD 30 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Len0 ), 0 );
/* Configure DWORD 31 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,E0 ), 0 );
}
}
else
{
SA_ASSERT((opCode == OPC_INB_SATA_HOST_OPSTART), "opcode");
if (pSgl)
{
/* Configure DWORD 12 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrLow0 ), pSgl->sgLower );
/* Configure DWORD 13 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrHi0 ), pSgl->sgUpper );
/* Configure DWORD 14 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,Len0 ), pSgl->len );
/* Configure DWORD 15 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,E0 ), pSgl->extReserved );
}
else
{
/* Configure DWORD 12 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrLow0 ), 0 );
/* Configure DWORD 13 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrHi0 ), 0 );
/* Configure DWORD 14 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,Len0 ), 0 );
/* Configure DWORD 15 */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,E0 ), 0 );
}
/* support ATAPI packet command */
if ((agRequestType == AGSA_SATA_PROTOCOL_NON_PKT ||
agRequestType == AGSA_SATA_PROTOCOL_H2D_PKT ||
agRequestType == AGSA_SATA_PROTOCOL_D2H_PKT))
{
/*DWORD 16 - 19 as SCSI CDB for support ATAPI Packet command*/
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB ),
(bit32)(agSATAReq->scsiCDB[0]|(agSATAReq->scsiCDB[1]<<8)|(agSATAReq->scsiCDB[2]<<16)|(agSATAReq->scsiCDB[3]<<24)));
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB )+ 4,
(bit32)(agSATAReq->scsiCDB[4]|(agSATAReq->scsiCDB[5]<<8)|(agSATAReq->scsiCDB[6]<<16)|(agSATAReq->scsiCDB[7]<<24)));
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB )+ 8,
(bit32)(agSATAReq->scsiCDB[8]|(agSATAReq->scsiCDB[9]<<8)|(agSATAReq->scsiCDB[10]<<16)|(agSATAReq->scsiCDB[11]<<24)));
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB )+ 12,
(bit32)(agSATAReq->scsiCDB[12]|(agSATAReq->scsiCDB[13]<<8)|(agSATAReq->scsiCDB[14]<<16)|(agSATAReq->scsiCDB[15]<<24)));
}
}
/* send IOMB to SPC */
ret = mpiMsgProduce(circularQ,
(void *)pMessage,
MPI_CATEGORY_SAS_SATA,
opCode,
outq,
(bit8)circularQ->priority);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif /* SA_LL_IBQ_PROTECT */
#ifdef SALL_API_TEST
if (AGSA_RC_FAILURE != ret)
{
saRoot->LLCounters.IOCounter.numSataStarted++;
}
#endif
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "8a");
ext:
OSSA_INP_LEAVE(agRoot);
return ret;
}
/******************************************************************************/
/*! \brief Abort SATA command
*
* Abort SATA command
*
* \param agRoot handles for this instance of SAS/SATA hardware
* \param queueNum inbound/outbound queue number
* \param agIORequest the IO Request descriptor
* \param agIOtoBeAborted
*
* \return If command is aborted successfully
* - \e AGSA_RC_SUCCESS command is aborted successfully
* - \e AGSA_RC_FAILURE command is not aborted successfully
*/
/*******************************************************************************/
GLOBAL bit32 saSATAAbort(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 queueNum,
agsaDevHandle_t *agDevHandle,
bit32 flag,
void *abortParam,
ossaGenericAbortCB_t agCB
)
{
bit32 ret = AGSA_RC_SUCCESS, retVal;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaIORequestDesc_t *pRequestABT = agNULL;
agsaDeviceDesc_t *pDevice = agNULL;
agsaDeviceDesc_t *pDeviceABT = NULL;
agsaPort_t *pPort = agNULL;
mpiICQueue_t *circularQ;
void *pMessage;
agsaSATAAbortCmd_t *payload;
agsaIORequest_t *agIOToBeAborted;
bit8 inq, outq;
bit32 flag_copy = flag;
smTraceFuncEnter(hpDBG_VERY_LOUD,"8b");
/* sanity check */
SA_ASSERT((agNULL != agRoot), "");
SA_ASSERT((agNULL != agIORequest), "");
SA_DBG3(("saSATAAbort: Aborting request %p ITtoBeAborted %p\n", agIORequest, abortParam));
/* Assign inbound and outbound Ring Buffer */
inq = (bit8)(queueNum & MPI_IB_NUM_MASK);
outq = (bit8)((queueNum & MPI_OB_NUM_MASK) >> MPI_OB_SHIFT);
SA_ASSERT((AGSA_MAX_INBOUND_Q > inq), "The IBQ Number is out of range.");
if( ABORT_SINGLE == (flag & ABORT_MASK) )
{
agIOToBeAborted = (agsaIORequest_t *)abortParam;
/* Get LL IORequest entry for saSATAAbort() */
pRequest = (agsaIORequestDesc_t *) (agIOToBeAborted->sdkData);
if (agNULL == pRequest)
{
/* no pRequest found - can not Abort */
SA_DBG1(("saSATAAbort: pRequest AGSA_RC_FAILURE\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "8b");
return AGSA_RC_FAILURE;
}
/* Find the device the request sent to */
pDevice = pRequest->pDevice;
/* Get LL IORequest entry */
pRequestABT = (agsaIORequestDesc_t *) (agIOToBeAborted->sdkData);
/* Find the device the request sent to */
if (agNULL == pRequestABT)
{
/* no pRequestABT - can not find pDeviceABT */
SA_DBG1(("saSATAAbort: pRequestABT AGSA_RC_FAILURE\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "8b");
return AGSA_RC_FAILURE;
}
pDeviceABT = pRequestABT->pDevice;
if (agNULL == pDeviceABT)
{
/* no deviceID - can not build IOMB */
SA_DBG1(("saSATAAbort: pDeviceABT AGSA_RC_FAILURE\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "8b");
return AGSA_RC_FAILURE;
}
if (agNULL != pDevice)
{
/* Find the port the request was sent to */
pPort = pDevice->pPort;
}
/* Get request from free IORequests */
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
}
else
{
if (ABORT_ALL == (flag & ABORT_MASK))
{
/* abort all */
/* Find the outgoing port for the device */
pDevice = (agsaDeviceDesc_t *) (agDevHandle->sdkData);
pPort = pDevice->pPort;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
}
else
{
/* only support 00 and 01 for flag */
SA_DBG1(("saSATAAbort: flag AGSA_RC_FAILURE\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "8b");
return AGSA_RC_FAILURE;
}
}
/* If no LL IO request entry avalable */
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSATAAbort, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "8b");
return AGSA_RC_BUSY;
}
/* If free IOMB avaliable */
/* Remove the request from free list */
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
SA_ASSERT((!pRequest->valid), "The pRequest is in use");
/* Add the request to the pendingIORequests list of the device */
pRequest->valid = agTRUE;
saLlistIOAdd(&(pDevice->pendingIORequests), &(pRequest->linkNode));
/* set up pRequest */
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->pIORequestContext = agIORequest;
pRequest->requestType = AGSA_SATA_REQTYPE;
pRequest->pDevice = pDevice;
pRequest->pPort = pPort;
pRequest->completionCB = (void*)agCB;
/* pRequest->abortCompletionCB = agCB; */
pRequest->startTick = saRoot->timeTick;
/* Set request to the sdkData of agIORequest */
agIORequest->sdkData = pRequest;
/* save tag and IOrequest pointer to IOMap */
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif /* SA_LL_IBQ_PROTECT */
/* If LL IO request entry avaliable */
/* Get a free inbound queue entry */
circularQ = &saRoot->inboundQueue[inq];
retVal = mpiMsgFreeGet(circularQ, IOMB_SIZE64, &pMessage);
/* if message size is too large return failure */
if (AGSA_RC_FAILURE == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif /* SA_LL_IBQ_PROTECT */
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSATAAbort, error when get free IOMB\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "8b");
return AGSA_RC_FAILURE;
}
/* return busy if inbound queue is full */
if (AGSA_RC_BUSY == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif /* SA_LL_IBQ_PROTECT */
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSATASAbort, no more IOMB\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "8b");
return AGSA_RC_BUSY;
}
/* setup payload */
payload = (agsaSATAAbortCmd_t*)pMessage;
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, tag), pRequest->HTag);
if( ABORT_SINGLE == (flag & ABORT_MASK) )
{
/* If no device */
if ( agNULL == pDeviceABT )
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif /* SA_LL_IBQ_PROTECT */
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSATAAbort,no device\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "8b");
return AGSA_RC_FAILURE;
}
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, deviceId), pDeviceABT->DeviceMapIndex);
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, HTagAbort), pRequestABT->HTag);
}
else
{
/* abort all */
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, deviceId), pDevice->DeviceMapIndex);
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, HTagAbort), 0);
}
if(flag & ABORT_TSDK_QUARANTINE)
{
if(smIS_SPCV(agRoot))
{
flag_copy &= ABORT_SCOPE;
flag_copy |= ABORT_QUARANTINE_SPCV;
}
}
OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, abortAll), flag_copy);
SA_DBG1(("saSATAAbort, HTag 0x%x HTagABT 0x%x deviceId 0x%x\n", payload->tag, payload->HTagAbort, payload->deviceId));
/* post the IOMB to SPC */
ret = mpiMsgProduce(circularQ, (void *)pMessage, MPI_CATEGORY_SAS_SATA, OPC_INB_SATA_ABORT, outq, (bit8)circularQ->priority);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif /* SA_LL_IBQ_PROTECT */
#ifdef SALL_API_TEST
if (AGSA_RC_FAILURE != ret)
{
saRoot->LLCounters.IOCounter.numSataAborted++;
}
#endif
siCountActiveIORequestsOnDevice( agRoot, payload->deviceId );
smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "8b");
return ret;
}
/******************************************************************************/
/*! \brief Routine to handle for received SATA with data payload event
*
* The handle for received SATA with data payload event
*
* \param agRoot handles for this instance of SAS/SATA hardware
* \param pRequest the IO request descriptor
* \param agFirstDword pointer to the first Dword
* \param pResp pointer to the rest of SATA response
* \param lengthResp total length of SATA Response frame
*
* \return -void-
*/
/*******************************************************************************/
GLOBAL void siEventSATAResponseWtDataRcvd(
agsaRoot_t *agRoot,
agsaIORequestDesc_t *pRequest,
bit32 *agFirstDword,
bit32 *pResp,
bit32 lengthResp
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaDeviceDesc_t *pDevice;
#if defined(SALLSDK_DEBUG)
agsaFrameHandle_t frameHandle;
/* get frame handle */
frameHandle = (agsaFrameHandle_t)(pResp);
#endif /* SALLSDK_DEBUG */
smTraceFuncEnter(hpDBG_VERY_LOUD,"8c");
/* If the request is still valid */
if ( agTRUE == pRequest->valid )
{
/* get device */
pDevice = pRequest->pDevice;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* Delete the request from the pendingIORequests */
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
(*(ossaSATACompletedCB_t)(pRequest->completionCB))(agRoot,
pRequest->pIORequestContext,
OSSA_IO_SUCCESS,
agFirstDword,
lengthResp,
(void *)pResp);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "8c");
return;
}
/******************************************************************************/
/*! \brief copy a SATA signature to another
*
* copy a SATA signature to another
*
* \param pDstSignature pointer to the destination signature
* \param pSrcSignature pointer to the source signature
*
* \return If they match
* - \e agTRUE match
* - \e agFALSE doesn't match
*/
/*******************************************************************************/
GLOBAL void siSATASignatureCpy(
bit8 *pDstSignature,
bit8 *pSrcSignature
)
{
bit32 i;
for ( i = 0; i < 5; i ++ )
{
pDstSignature[i] = pSrcSignature[i];
}
return;
}