14e1bc9a0SAchim Leubner /*******************************************************************************
24e1bc9a0SAchim Leubner *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
34e1bc9a0SAchim Leubner *
44e1bc9a0SAchim Leubner *Redistribution and use in source and binary forms, with or without modification, are permitted provided
54e1bc9a0SAchim Leubner *that the following conditions are met:
64e1bc9a0SAchim Leubner *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
74e1bc9a0SAchim Leubner *following disclaimer.
84e1bc9a0SAchim Leubner *2. Redistributions in binary form must reproduce the above copyright notice,
94e1bc9a0SAchim Leubner *this list of conditions and the following disclaimer in the documentation and/or other materials provided
104e1bc9a0SAchim Leubner *with the distribution.
114e1bc9a0SAchim Leubner *
124e1bc9a0SAchim Leubner *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
134e1bc9a0SAchim Leubner *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
144e1bc9a0SAchim Leubner *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
154e1bc9a0SAchim Leubner *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
164e1bc9a0SAchim Leubner *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
174e1bc9a0SAchim Leubner *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
184e1bc9a0SAchim Leubner *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
194e1bc9a0SAchim Leubner *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
204e1bc9a0SAchim Leubner
214e1bc9a0SAchim Leubner ********************************************************************************/
224e1bc9a0SAchim Leubner /*******************************************************************************/
234e1bc9a0SAchim Leubner /*! \file sasata.c
244e1bc9a0SAchim Leubner * \brief The file implements the functions to SATA IO
254e1bc9a0SAchim Leubner *
264e1bc9a0SAchim Leubner */
274e1bc9a0SAchim Leubner /******************************************************************************/
284e1bc9a0SAchim Leubner #include <sys/cdefs.h>
294e1bc9a0SAchim Leubner #include <dev/pms/config.h>
304e1bc9a0SAchim Leubner
314e1bc9a0SAchim Leubner #include <dev/pms/RefTisa/sallsdk/spc/saglobal.h>
324e1bc9a0SAchim Leubner #ifdef SA_ENABLE_TRACE_FUNCTIONS
334e1bc9a0SAchim Leubner #ifdef siTraceFileID
344e1bc9a0SAchim Leubner #undef siTraceFileID
354e1bc9a0SAchim Leubner #endif
364e1bc9a0SAchim Leubner #define siTraceFileID 'M'
374e1bc9a0SAchim Leubner #endif
384e1bc9a0SAchim Leubner
394e1bc9a0SAchim Leubner /******************************************************************************/
404e1bc9a0SAchim Leubner /*! \brief Start SATA command
414e1bc9a0SAchim Leubner *
424e1bc9a0SAchim Leubner * Start SATA command
434e1bc9a0SAchim Leubner *
444e1bc9a0SAchim Leubner * \param agRoot handles for this instance of SAS/SATA hardware
454e1bc9a0SAchim Leubner * \param queueNum
464e1bc9a0SAchim Leubner * \param agIORequest
474e1bc9a0SAchim Leubner * \param agDevHandle
484e1bc9a0SAchim Leubner * \param agRequestType
494e1bc9a0SAchim Leubner * \param agSATAReq
504e1bc9a0SAchim Leubner * \param agTag
514e1bc9a0SAchim Leubner * \param agCB
524e1bc9a0SAchim Leubner *
534e1bc9a0SAchim Leubner * \return If command is started successfully
544e1bc9a0SAchim Leubner * - \e AGSA_RC_SUCCESS command is started successfully
554e1bc9a0SAchim Leubner * - \e AGSA_RC_FAILURE command is not started successfully
564e1bc9a0SAchim Leubner */
574e1bc9a0SAchim Leubner /*******************************************************************************/
saSATAStart(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 queueNum,agsaDevHandle_t * agDevHandle,bit32 agRequestType,agsaSATAInitiatorRequest_t * agSATAReq,bit8 agTag,ossaSATACompletedCB_t agCB)584e1bc9a0SAchim Leubner GLOBAL bit32 saSATAStart(
594e1bc9a0SAchim Leubner agsaRoot_t *agRoot,
604e1bc9a0SAchim Leubner agsaIORequest_t *agIORequest,
614e1bc9a0SAchim Leubner bit32 queueNum,
624e1bc9a0SAchim Leubner agsaDevHandle_t *agDevHandle,
634e1bc9a0SAchim Leubner bit32 agRequestType,
644e1bc9a0SAchim Leubner agsaSATAInitiatorRequest_t *agSATAReq,
654e1bc9a0SAchim Leubner bit8 agTag,
664e1bc9a0SAchim Leubner ossaSATACompletedCB_t agCB
674e1bc9a0SAchim Leubner )
684e1bc9a0SAchim Leubner
694e1bc9a0SAchim Leubner {
704e1bc9a0SAchim Leubner agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
714e1bc9a0SAchim Leubner mpiICQueue_t *circularQ = agNULL;
724e1bc9a0SAchim Leubner agsaDeviceDesc_t *pDevice = agNULL;
734e1bc9a0SAchim Leubner agsaPort_t *pPort = agNULL;
744e1bc9a0SAchim Leubner agsaIORequestDesc_t *pRequest = agNULL;
754e1bc9a0SAchim Leubner void *pMessage = agNULL;
764e1bc9a0SAchim Leubner agsaSgl_t *pSgl = agNULL;
774e1bc9a0SAchim Leubner bit32 *payload = agNULL;
784e1bc9a0SAchim Leubner bit32 deviceIndex = 0;
794e1bc9a0SAchim Leubner bit32 ret = AGSA_RC_SUCCESS, retVal = 0;
804e1bc9a0SAchim Leubner bit32 AtapDir = 0;
814e1bc9a0SAchim Leubner bit32 encryptFlags = 0;
824e1bc9a0SAchim Leubner bit16 size = 0;
834e1bc9a0SAchim Leubner bit16 opCode = 0;
844e1bc9a0SAchim Leubner bit8 inq = 0, outq = 0;
854e1bc9a0SAchim Leubner
864e1bc9a0SAchim Leubner OSSA_INP_ENTER(agRoot);
874e1bc9a0SAchim Leubner smTraceFuncEnter(hpDBG_VERY_LOUD, "8a");
884e1bc9a0SAchim Leubner
894e1bc9a0SAchim Leubner SA_DBG3(("saSATAStart: in\n"));
904e1bc9a0SAchim Leubner /* sanity check */
914e1bc9a0SAchim Leubner SA_ASSERT((agNULL != agRoot), "(saSATAStart) agRoot is NULL");
924e1bc9a0SAchim Leubner SA_ASSERT((agNULL != agIORequest), "(saSATAStart) agIORequest is NULL");
934e1bc9a0SAchim Leubner SA_ASSERT((agNULL != agDevHandle), "(saSATAStart) agDevHandle is NULL");
944e1bc9a0SAchim Leubner SA_ASSERT((agNULL != agSATAReq), "(saSATAStart) agSATAReq is NULL");
954e1bc9a0SAchim Leubner
964e1bc9a0SAchim Leubner /* Assign inbound and outbound queue */
974e1bc9a0SAchim Leubner inq = (bit8)(queueNum & MPI_IB_NUM_MASK);
984e1bc9a0SAchim Leubner outq = (bit8)((queueNum & MPI_OB_NUM_MASK) >> MPI_OB_SHIFT);
994e1bc9a0SAchim Leubner SA_ASSERT((AGSA_MAX_INBOUND_Q > inq), "The IBQ Number is out of range.");
1004e1bc9a0SAchim Leubner
1014e1bc9a0SAchim Leubner /* Find the outgoing port for the device */
1024e1bc9a0SAchim Leubner pDevice = (agsaDeviceDesc_t *) (agDevHandle->sdkData);
1034e1bc9a0SAchim Leubner SA_ASSERT((agNULL != pDevice), "(saSATAStart) pDevice is NULL");
1044e1bc9a0SAchim Leubner
1054e1bc9a0SAchim Leubner pPort = pDevice->pPort;
1064e1bc9a0SAchim Leubner SA_ASSERT((agNULL != pPort), "(saSATAStart) pPort is NULL");
1074e1bc9a0SAchim Leubner
1084e1bc9a0SAchim Leubner /* SATA DIF is obsolete */
1094e1bc9a0SAchim Leubner if (agSATAReq->option & AGSA_SATA_ENABLE_DIF)
1104e1bc9a0SAchim Leubner {
1114e1bc9a0SAchim Leubner return AGSA_RC_FAILURE;
1124e1bc9a0SAchim Leubner }
1134e1bc9a0SAchim Leubner
1144e1bc9a0SAchim Leubner /* find deviceID for IOMB */
1154e1bc9a0SAchim Leubner deviceIndex = pDevice->DeviceMapIndex;
1164e1bc9a0SAchim Leubner
1174e1bc9a0SAchim Leubner /* Get request from free IORequests */
1184e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
1194e1bc9a0SAchim Leubner pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
1204e1bc9a0SAchim Leubner if ( agNULL != pRequest )
1214e1bc9a0SAchim Leubner {
1224e1bc9a0SAchim Leubner /* If free IOMB avaliable */
1234e1bc9a0SAchim Leubner /* Remove the request from free list */
1244e1bc9a0SAchim Leubner saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
1254e1bc9a0SAchim Leubner
1264e1bc9a0SAchim Leubner /* Add the request to the pendingSTARequests list of the device */
1274e1bc9a0SAchim Leubner pRequest->valid = agTRUE;
1284e1bc9a0SAchim Leubner saLlistIOAdd(&(pDevice->pendingIORequests), &(pRequest->linkNode));
1294e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
1304e1bc9a0SAchim Leubner
1314e1bc9a0SAchim Leubner if ((agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION) ||
1324e1bc9a0SAchim Leubner (agSATAReq->option & AGSA_SATA_ENABLE_DIF))
1334e1bc9a0SAchim Leubner {
1344e1bc9a0SAchim Leubner opCode = OPC_INB_SATA_DIF_ENC_OPSTART;
1354e1bc9a0SAchim Leubner size = IOMB_SIZE128;
1364e1bc9a0SAchim Leubner }
1374e1bc9a0SAchim Leubner else
1384e1bc9a0SAchim Leubner {
1394e1bc9a0SAchim Leubner opCode = OPC_INB_SATA_HOST_OPSTART;
1404e1bc9a0SAchim Leubner if (agRequestType == AGSA_SATA_PROTOCOL_NON_PKT ||
1414e1bc9a0SAchim Leubner agRequestType == AGSA_SATA_PROTOCOL_H2D_PKT ||
1424e1bc9a0SAchim Leubner agRequestType == AGSA_SATA_PROTOCOL_D2H_PKT)
1434e1bc9a0SAchim Leubner size = IOMB_SIZE128;
1444e1bc9a0SAchim Leubner else
1454e1bc9a0SAchim Leubner size = IOMB_SIZE64;
1464e1bc9a0SAchim Leubner }
1474e1bc9a0SAchim Leubner /* If LL IO request entry avaliable */
1484e1bc9a0SAchim Leubner /* set up pRequest */
1494e1bc9a0SAchim Leubner pRequest->pIORequestContext = agIORequest;
1504e1bc9a0SAchim Leubner pRequest->pDevice = pDevice;
1514e1bc9a0SAchim Leubner pRequest->pPort = pPort;
1524e1bc9a0SAchim Leubner pRequest->requestType = agRequestType;
1534e1bc9a0SAchim Leubner pRequest->startTick = saRoot->timeTick;
1544e1bc9a0SAchim Leubner pRequest->completionCB = (ossaSSPCompletedCB_t)agCB;
1554e1bc9a0SAchim Leubner /* Set request to the sdkData of agIORequest */
1564e1bc9a0SAchim Leubner agIORequest->sdkData = pRequest;
1574e1bc9a0SAchim Leubner
1584e1bc9a0SAchim Leubner /* save tag and IOrequest pointer to IOMap */
1594e1bc9a0SAchim Leubner saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
1604e1bc9a0SAchim Leubner saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
1614e1bc9a0SAchim Leubner
1624e1bc9a0SAchim Leubner #ifdef SA_LL_IBQ_PROTECT
1634e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
1644e1bc9a0SAchim Leubner #endif /* SA_LL_IBQ_PROTECT */
1654e1bc9a0SAchim Leubner
1664e1bc9a0SAchim Leubner /* get a free inbound queue entry */
1674e1bc9a0SAchim Leubner circularQ = &saRoot->inboundQueue[inq];
1684e1bc9a0SAchim Leubner retVal = mpiMsgFreeGet(circularQ, size, &pMessage);
1694e1bc9a0SAchim Leubner
1704e1bc9a0SAchim Leubner if (AGSA_RC_FAILURE == retVal)
1714e1bc9a0SAchim Leubner {
1724e1bc9a0SAchim Leubner #ifdef SA_LL_IBQ_PROTECT
1734e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
1744e1bc9a0SAchim Leubner #endif /* SA_LL_IBQ_PROTECT */
1754e1bc9a0SAchim Leubner /* if not sending return to free list rare */
1764e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
1774e1bc9a0SAchim Leubner saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
1784e1bc9a0SAchim Leubner pRequest->valid = agFALSE;
1794e1bc9a0SAchim Leubner saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
1804e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
1814e1bc9a0SAchim Leubner
1824e1bc9a0SAchim Leubner SA_DBG3(("saSATAStart, error when get free IOMB\n"));
1834e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "8a");
1844e1bc9a0SAchim Leubner ret = AGSA_RC_FAILURE;
1854e1bc9a0SAchim Leubner goto ext;
1864e1bc9a0SAchim Leubner }
1874e1bc9a0SAchim Leubner
1884e1bc9a0SAchim Leubner /* return busy if inbound queue is full */
1894e1bc9a0SAchim Leubner if (AGSA_RC_BUSY == retVal)
1904e1bc9a0SAchim Leubner {
1914e1bc9a0SAchim Leubner #ifdef SA_LL_IBQ_PROTECT
1924e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
1934e1bc9a0SAchim Leubner #endif /* SA_LL_IBQ_PROTECT */
1944e1bc9a0SAchim Leubner /* if not sending return to free list rare */
1954e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
1964e1bc9a0SAchim Leubner saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
1974e1bc9a0SAchim Leubner pRequest->valid = agFALSE;
1984e1bc9a0SAchim Leubner saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
1994e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
2004e1bc9a0SAchim Leubner
2014e1bc9a0SAchim Leubner SA_DBG1(("saSATAStart, no more IOMB\n"));
2024e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "8a");
2034e1bc9a0SAchim Leubner ret = AGSA_RC_BUSY;
2044e1bc9a0SAchim Leubner goto ext;
2054e1bc9a0SAchim Leubner }
2064e1bc9a0SAchim Leubner
2074e1bc9a0SAchim Leubner }
2084e1bc9a0SAchim Leubner else /* If no LL IO request entry available */
2094e1bc9a0SAchim Leubner {
2104e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
2114e1bc9a0SAchim Leubner SA_DBG1(("saSATAStart, No request from free list\n"));
2124e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "8a");
2134e1bc9a0SAchim Leubner ret = AGSA_RC_BUSY;
2144e1bc9a0SAchim Leubner goto ext;
2154e1bc9a0SAchim Leubner }
2164e1bc9a0SAchim Leubner
2174e1bc9a0SAchim Leubner payload = (bit32 *)pMessage;
2184e1bc9a0SAchim Leubner SA_DBG4(("saSATAStart: Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
2194e1bc9a0SAchim Leubner
2204e1bc9a0SAchim Leubner
2214e1bc9a0SAchim Leubner switch ( agRequestType )
2224e1bc9a0SAchim Leubner {
2234e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_FPDMA_READ:
2244e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_FPDMA_WRITE:
2254e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_FPDMA_READ_M:
2264e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_FPDMA_WRITE_M:
2274e1bc9a0SAchim Leubner pSgl = &(agSATAReq->agSgl);
2284e1bc9a0SAchim Leubner AtapDir = agRequestType & (AGSA_DIR_MASK | AGSA_SATA_ATAP_MASK);
2294e1bc9a0SAchim Leubner if (agRequestType & AGSA_MSG)
2304e1bc9a0SAchim Leubner {
2314e1bc9a0SAchim Leubner /* set M bit */
2324e1bc9a0SAchim Leubner AtapDir |= AGSA_MSG_BIT;
2334e1bc9a0SAchim Leubner }
2344e1bc9a0SAchim Leubner break;
2354e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_DMA_READ:
2364e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_DMA_WRITE:
2374e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_DMA_READ_M:
2384e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_DMA_WRITE_M:
2394e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_PIO_READ_M:
2404e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_PIO_WRITE_M:
2414e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_PIO_READ:
2424e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_PIO_WRITE:
2434e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_H2D_PKT:
2444e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_D2H_PKT:
2454e1bc9a0SAchim Leubner agTag = 0; /* agTag not valid for these requests */
2464e1bc9a0SAchim Leubner pSgl = &(agSATAReq->agSgl);
2474e1bc9a0SAchim Leubner AtapDir = agRequestType & (AGSA_DIR_MASK | AGSA_SATA_ATAP_MASK);
2484e1bc9a0SAchim Leubner if (agRequestType & AGSA_MSG)
2494e1bc9a0SAchim Leubner {
2504e1bc9a0SAchim Leubner /* set M bit */
2514e1bc9a0SAchim Leubner AtapDir |= AGSA_MSG_BIT;
2524e1bc9a0SAchim Leubner }
2534e1bc9a0SAchim Leubner break;
2544e1bc9a0SAchim Leubner
2554e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_NON_DATA:
2564e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_NON_DATA_M:
2574e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_NON_PKT:
2584e1bc9a0SAchim Leubner agTag = 0; /* agTag not valid for these requests */
2594e1bc9a0SAchim Leubner AtapDir = agRequestType & (AGSA_DIR_MASK | AGSA_SATA_ATAP_MASK);
2604e1bc9a0SAchim Leubner if (agRequestType & AGSA_MSG)
2614e1bc9a0SAchim Leubner {
2624e1bc9a0SAchim Leubner /* set M bit */
2634e1bc9a0SAchim Leubner AtapDir |= AGSA_MSG_BIT;
2644e1bc9a0SAchim Leubner }
2654e1bc9a0SAchim Leubner break;
2664e1bc9a0SAchim Leubner
2674e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_SRST_ASSERT:
2684e1bc9a0SAchim Leubner agTag = 0; /* agTag not valid for these requests */
2694e1bc9a0SAchim Leubner AtapDir = AGSA_SATA_ATAP_SRST_ASSERT;
2704e1bc9a0SAchim Leubner break;
2714e1bc9a0SAchim Leubner
2724e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_SRST_DEASSERT:
2734e1bc9a0SAchim Leubner agTag = 0; /* agTag not valid for these requests */
2744e1bc9a0SAchim Leubner AtapDir = AGSA_SATA_ATAP_SRST_DEASSERT;
2754e1bc9a0SAchim Leubner break;
2764e1bc9a0SAchim Leubner
2774e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_DEV_RESET:
2784e1bc9a0SAchim Leubner case AGSA_SATA_PROTOCOL_DEV_RESET_M: /* TestBase */
2794e1bc9a0SAchim Leubner agTag = 0; /* agTag not valid for these requests */
2804e1bc9a0SAchim Leubner AtapDir = AGSA_SATA_ATAP_PKT_DEVRESET;
2814e1bc9a0SAchim Leubner if (agRequestType & AGSA_MSG)
2824e1bc9a0SAchim Leubner {
2834e1bc9a0SAchim Leubner /* set M bit */
2844e1bc9a0SAchim Leubner AtapDir |= AGSA_MSG_BIT; /* TestBase */
2854e1bc9a0SAchim Leubner }
2864e1bc9a0SAchim Leubner break;
2874e1bc9a0SAchim Leubner
2884e1bc9a0SAchim Leubner default:
2894e1bc9a0SAchim Leubner SA_DBG1(("saSATAStart: (Unknown agRequestType) 0x%X \n",agRequestType));
2904e1bc9a0SAchim Leubner SA_ASSERT((0), "saSATAStart: (Unknown agRequestType)");
2914e1bc9a0SAchim Leubner
2924e1bc9a0SAchim Leubner break;
2934e1bc9a0SAchim Leubner }
2944e1bc9a0SAchim Leubner
2954e1bc9a0SAchim Leubner if ((AGSA_SATA_PROTOCOL_SRST_ASSERT == agRequestType) ||
2964e1bc9a0SAchim Leubner (AGSA_SATA_PROTOCOL_SRST_DEASSERT == agRequestType) ||
2974e1bc9a0SAchim Leubner (AGSA_SATA_PROTOCOL_DEV_RESET == agRequestType))
2984e1bc9a0SAchim Leubner {
2994e1bc9a0SAchim Leubner
3004e1bc9a0SAchim Leubner SA_DBG3(("saSATAStart:AGSA_SATA_PROTOCOL_SRST_DEASSERT AGSA_SATA_PROTOCOL_SRST_ASSERT\n"));
3014e1bc9a0SAchim Leubner
3024e1bc9a0SAchim Leubner si_memset((void *)payload, 0, sizeof(agsaSATAStartCmd_t));
3034e1bc9a0SAchim Leubner /* build IOMB DW 1 */
3044e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t, tag), pRequest->HTag);
3054e1bc9a0SAchim Leubner /* DWORD 2 */
3064e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,deviceId ), deviceIndex);
3074e1bc9a0SAchim Leubner /* DWORD 3 */
3084e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,dataLen ), 0 );
3094e1bc9a0SAchim Leubner /* DWORD 4 */
3104e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot,
3114e1bc9a0SAchim Leubner payload,
3124e1bc9a0SAchim Leubner OSSA_OFFSET_OF(agsaSATAStartCmd_t,optNCQTagataProt ),
3134e1bc9a0SAchim Leubner (((agSATAReq->option & SATA_FIS_MASK) << SHIFT24) |
3144e1bc9a0SAchim Leubner (agTag << SHIFT16) |
3154e1bc9a0SAchim Leubner AtapDir));
3164e1bc9a0SAchim Leubner
3174e1bc9a0SAchim Leubner si_memcpy((void *)(payload+4), (void *)&agSATAReq->fis.fisRegHostToDev, sizeof(agsaFisRegHostToDevice_t));
3184e1bc9a0SAchim Leubner }
3194e1bc9a0SAchim Leubner else
3204e1bc9a0SAchim Leubner {
3214e1bc9a0SAchim Leubner /* build IOMB DW 1 */
3224e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t, tag), pRequest->HTag);
3234e1bc9a0SAchim Leubner /* DWORD 2 */
3244e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,deviceId ), deviceIndex);
3254e1bc9a0SAchim Leubner /* DWORD 3 */
3264e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,dataLen ), agSATAReq->dataLength );
3274e1bc9a0SAchim Leubner
3284e1bc9a0SAchim Leubner /* Since we are writing the payload in order, check for any special modes now. */
3294e1bc9a0SAchim Leubner if (agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION)
3304e1bc9a0SAchim Leubner {
3314e1bc9a0SAchim Leubner SA_ASSERT((opCode == OPC_INB_SATA_DIF_ENC_OPSTART), "opcode");
3324e1bc9a0SAchim Leubner SA_DBG4(("saSATAStart: 1 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
3334e1bc9a0SAchim Leubner AtapDir |= AGSA_ENCRYPT_BIT;
3344e1bc9a0SAchim Leubner }
3354e1bc9a0SAchim Leubner
3364e1bc9a0SAchim Leubner if (agSATAReq->option & AGSA_SATA_ENABLE_DIF)
3374e1bc9a0SAchim Leubner {
3384e1bc9a0SAchim Leubner SA_ASSERT((opCode == OPC_INB_SATA_DIF_ENC_OPSTART), "opcode");
3394e1bc9a0SAchim Leubner AtapDir |= AGSA_DIF_BIT;
3404e1bc9a0SAchim Leubner }
3414e1bc9a0SAchim Leubner #ifdef CCBUILD_TEST_EPL
3424e1bc9a0SAchim Leubner if(agSATAReq->encrypt.enableEncryptionPerLA)
3434e1bc9a0SAchim Leubner AtapDir |= (1 << SHIFT4); // enable EPL
3444e1bc9a0SAchim Leubner #endif
3454e1bc9a0SAchim Leubner /* DWORD 4 */
3464e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot,
3474e1bc9a0SAchim Leubner payload,
3484e1bc9a0SAchim Leubner OSSA_OFFSET_OF(agsaSATAStartCmd_t,optNCQTagataProt ),
3494e1bc9a0SAchim Leubner (((agSATAReq->option & SATA_FIS_MASK) << SHIFT24) |
3504e1bc9a0SAchim Leubner (agTag << SHIFT16) |
3514e1bc9a0SAchim Leubner AtapDir));
3524e1bc9a0SAchim Leubner
3534e1bc9a0SAchim Leubner /* DWORD 5 6 7 8 9 */
3544e1bc9a0SAchim Leubner si_memcpy((void *)(payload+4), (void *)&agSATAReq->fis.fisRegHostToDev, sizeof(agsaFisRegHostToDevice_t));
3554e1bc9a0SAchim Leubner /* DWORD 10 reserved */
3564e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,reserved1 ), 0 );
3574e1bc9a0SAchim Leubner
3584e1bc9a0SAchim Leubner /* DWORD 11 reserved */
3594e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,reserved2 ), 0 );
3604e1bc9a0SAchim Leubner
3614e1bc9a0SAchim Leubner SA_DBG4(("saSATAStart: 2 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
3624e1bc9a0SAchim Leubner }
3634e1bc9a0SAchim Leubner if (agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION)
3644e1bc9a0SAchim Leubner {
3654e1bc9a0SAchim Leubner /* Write 10 dwords of zeroes as payload, skipping all DIF fields */
3664e1bc9a0SAchim Leubner SA_DBG4(("saSATAStart: 2a Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
3674e1bc9a0SAchim Leubner if (opCode == OPC_INB_SATA_DIF_ENC_OPSTART)
3684e1bc9a0SAchim Leubner {
3694e1bc9a0SAchim Leubner /* DW 11 */
3704e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_EPL_DESCL ),0 );
3714e1bc9a0SAchim Leubner /* DW 12 */
3724e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,resSKIPBYTES ),0 );
3734e1bc9a0SAchim Leubner /* DW 13 */
3744e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_DPL_DESCL_NDPLR ),0 );
3754e1bc9a0SAchim Leubner /* DW 14 */
3764e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_EDPL_DESCH ),0 );
3774e1bc9a0SAchim Leubner /* DW 15 */
3784e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,DIF_flags ),0 );
3794e1bc9a0SAchim Leubner /* DW 16 */
3804e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,udt ),0 );
3814e1bc9a0SAchim Leubner /* DW 17 */
3824e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,udtReplacementLo ),0 );
3834e1bc9a0SAchim Leubner /* DW 18 */
3844e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,udtReplacementHi ),0 );
3854e1bc9a0SAchim Leubner /* DW 19 */
3864e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,DIF_seed ),0 );
3874e1bc9a0SAchim Leubner }
3884e1bc9a0SAchim Leubner
3894e1bc9a0SAchim Leubner if (agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION)
3904e1bc9a0SAchim Leubner {
3914e1bc9a0SAchim Leubner SA_ASSERT((opCode == OPC_INB_SATA_DIF_ENC_OPSTART), "opcode");
3924e1bc9a0SAchim Leubner
3934e1bc9a0SAchim Leubner SA_DBG4(("saSATAStart: 3 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
3944e1bc9a0SAchim Leubner /* Configure DWORD 20 */
3954e1bc9a0SAchim Leubner encryptFlags = 0;
3964e1bc9a0SAchim Leubner
3974e1bc9a0SAchim Leubner if (agSATAReq->encrypt.keyTagCheck == agTRUE)
3984e1bc9a0SAchim Leubner {
3994e1bc9a0SAchim Leubner encryptFlags |= AGSA_ENCRYPT_KEY_TAG_BIT;
4004e1bc9a0SAchim Leubner }
4014e1bc9a0SAchim Leubner
4024e1bc9a0SAchim Leubner if( agSATAReq->encrypt.cipherMode == agsaEncryptCipherModeXTS )
4034e1bc9a0SAchim Leubner {
4044e1bc9a0SAchim Leubner encryptFlags |= AGSA_ENCRYPT_XTS_Mode << SHIFT4;
4054e1bc9a0SAchim Leubner }
4064e1bc9a0SAchim Leubner
4074e1bc9a0SAchim Leubner encryptFlags |= agSATAReq->encrypt.dekInfo.dekTable << SHIFT2;
4084e1bc9a0SAchim Leubner
4094e1bc9a0SAchim Leubner encryptFlags |= (agSATAReq->encrypt.dekInfo.dekIndex & 0xFFFFFF) << SHIFT8;
4104e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,encryptFlagsLo ),encryptFlags );
4114e1bc9a0SAchim Leubner
4124e1bc9a0SAchim Leubner /* Configure DWORD 21*/
4134e1bc9a0SAchim Leubner /* This information is available in the sectorSizeIndex */
4144e1bc9a0SAchim Leubner encryptFlags = agSATAReq->encrypt.sectorSizeIndex;
4154e1bc9a0SAchim Leubner /*
4164e1bc9a0SAchim Leubner * Set Region0 sectors count
4174e1bc9a0SAchim Leubner */
4184e1bc9a0SAchim Leubner if(agSATAReq->encrypt.enableEncryptionPerLA)
4194e1bc9a0SAchim Leubner {
4204e1bc9a0SAchim Leubner encryptFlags |= (agSATAReq->encrypt.EncryptionPerLRegion0SecCount << SHIFT16);
4214e1bc9a0SAchim Leubner }
4224e1bc9a0SAchim Leubner
4234e1bc9a0SAchim Leubner encryptFlags |= (agSATAReq->encrypt.kekIndex) << SHIFT5;
4244e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,encryptFlagsHi ),encryptFlags );
4254e1bc9a0SAchim Leubner
4264e1bc9a0SAchim Leubner /* Configure DWORD 22*/
4274e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagLo ), agSATAReq->encrypt.keyTag_W0 );
4284e1bc9a0SAchim Leubner /* Configure DWORD 23 */
4294e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagHi ), agSATAReq->encrypt.keyTag_W1 );
4304e1bc9a0SAchim Leubner /* Configure DWORD 24 */
4314e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W0 ), agSATAReq->encrypt.tweakVal_W0 );
4324e1bc9a0SAchim Leubner /* Configure DWORD 25 */
4334e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W1 ), agSATAReq->encrypt.tweakVal_W1 );
4344e1bc9a0SAchim Leubner /* Configure DWORD 26 */
4354e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W2 ), agSATAReq->encrypt.tweakVal_W2 );
4364e1bc9a0SAchim Leubner /* Configure DWORD 27 */
4374e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W3 ), agSATAReq->encrypt.tweakVal_W3 );
4384e1bc9a0SAchim Leubner }
4394e1bc9a0SAchim Leubner else
4404e1bc9a0SAchim Leubner {
4414e1bc9a0SAchim Leubner /* Write 8 dwords of zeros as payload, skipping all encryption fields */
4424e1bc9a0SAchim Leubner if (opCode == OPC_INB_SATA_DIF_ENC_OPSTART)
4434e1bc9a0SAchim Leubner {
4444e1bc9a0SAchim Leubner /* Configure DWORD 22*/
4454e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagLo ), 0 );
4464e1bc9a0SAchim Leubner /* Configure DWORD 23 */
4474e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagHi ), 0 );
4484e1bc9a0SAchim Leubner /* Configure DWORD 24 */
4494e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W0 ), 0 );
4504e1bc9a0SAchim Leubner /* Configure DWORD 25 */
4514e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W1 ), 0 );
4524e1bc9a0SAchim Leubner /* Configure DWORD 26 */
4534e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W2 ), 0 );
4544e1bc9a0SAchim Leubner /* Configure DWORD 27 */
4554e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W3 ), 0 );
4564e1bc9a0SAchim Leubner }
4574e1bc9a0SAchim Leubner }
4584e1bc9a0SAchim Leubner
4594e1bc9a0SAchim Leubner SA_DBG4(("saSATAStart: 4 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage)));
4604e1bc9a0SAchim Leubner
4614e1bc9a0SAchim Leubner /* DWORD 11 13 14*/
4624e1bc9a0SAchim Leubner if(agSATAReq->encrypt.enableEncryptionPerLA)
4634e1bc9a0SAchim Leubner {
4644e1bc9a0SAchim Leubner /* DWORD 11 */
4654e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_EPL_DESCL),
4664e1bc9a0SAchim Leubner agSATAReq->encrypt.EncryptionPerLAAddrLo);
4674e1bc9a0SAchim Leubner /* DWORD 13 */
4684e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_DPL_DESCL_NDPLR), 0);
4694e1bc9a0SAchim Leubner /* DWORD 14 */
4704e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_EDPL_DESCH),
4714e1bc9a0SAchim Leubner agSATAReq->encrypt.EncryptionPerLAAddrHi);
4724e1bc9a0SAchim Leubner }
4734e1bc9a0SAchim Leubner else
4744e1bc9a0SAchim Leubner {
4754e1bc9a0SAchim Leubner /* DWORD 11 */
4764e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_EPL_DESCL),0);
4774e1bc9a0SAchim Leubner /* DW 13 */
4784e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_DPL_DESCL_NDPLR), 0);
4794e1bc9a0SAchim Leubner /* DWORD 14 */
4804e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_EDPL_DESCH ),0 );
4814e1bc9a0SAchim Leubner }
4824e1bc9a0SAchim Leubner
4834e1bc9a0SAchim Leubner /* Configure DWORD 28 for encryption*/
4844e1bc9a0SAchim Leubner if (pSgl)
4854e1bc9a0SAchim Leubner {
4864e1bc9a0SAchim Leubner /* Configure DWORD 28 */
4874e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrLow0 ), pSgl->sgLower );
4884e1bc9a0SAchim Leubner /* Configure DWORD 29 */
4894e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrHi0 ), pSgl->sgUpper );
4904e1bc9a0SAchim Leubner /* Configure DWORD 30 */
4914e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Len0 ), pSgl->len );
4924e1bc9a0SAchim Leubner /* Configure DWORD 31 */
4934e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,E0 ), pSgl->extReserved );
4944e1bc9a0SAchim Leubner }
4954e1bc9a0SAchim Leubner else
4964e1bc9a0SAchim Leubner {
4974e1bc9a0SAchim Leubner /* Configure DWORD 28 */
4984e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrLow0 ), 0 );
4994e1bc9a0SAchim Leubner /* Configure DWORD 29 */
5004e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrHi0 ), 0 );
5014e1bc9a0SAchim Leubner /* Configure DWORD 30 */
5024e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Len0 ), 0 );
5034e1bc9a0SAchim Leubner /* Configure DWORD 31 */
5044e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,E0 ), 0 );
5054e1bc9a0SAchim Leubner }
5064e1bc9a0SAchim Leubner
5074e1bc9a0SAchim Leubner }
5084e1bc9a0SAchim Leubner else
5094e1bc9a0SAchim Leubner {
5104e1bc9a0SAchim Leubner SA_ASSERT((opCode == OPC_INB_SATA_HOST_OPSTART), "opcode");
5114e1bc9a0SAchim Leubner if (pSgl)
5124e1bc9a0SAchim Leubner {
5134e1bc9a0SAchim Leubner /* Configure DWORD 12 */
5144e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrLow0 ), pSgl->sgLower );
5154e1bc9a0SAchim Leubner /* Configure DWORD 13 */
5164e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrHi0 ), pSgl->sgUpper );
5174e1bc9a0SAchim Leubner /* Configure DWORD 14 */
5184e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,Len0 ), pSgl->len );
5194e1bc9a0SAchim Leubner /* Configure DWORD 15 */
5204e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,E0 ), pSgl->extReserved );
5214e1bc9a0SAchim Leubner }
5224e1bc9a0SAchim Leubner else
5234e1bc9a0SAchim Leubner {
5244e1bc9a0SAchim Leubner /* Configure DWORD 12 */
5254e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrLow0 ), 0 );
5264e1bc9a0SAchim Leubner /* Configure DWORD 13 */
5274e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrHi0 ), 0 );
5284e1bc9a0SAchim Leubner /* Configure DWORD 14 */
5294e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,Len0 ), 0 );
5304e1bc9a0SAchim Leubner /* Configure DWORD 15 */
5314e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,E0 ), 0 );
5324e1bc9a0SAchim Leubner }
5334e1bc9a0SAchim Leubner /* support ATAPI packet command */
5344e1bc9a0SAchim Leubner if ((agRequestType == AGSA_SATA_PROTOCOL_NON_PKT ||
5354e1bc9a0SAchim Leubner agRequestType == AGSA_SATA_PROTOCOL_H2D_PKT ||
5364e1bc9a0SAchim Leubner agRequestType == AGSA_SATA_PROTOCOL_D2H_PKT))
5374e1bc9a0SAchim Leubner {
5384e1bc9a0SAchim Leubner /*DWORD 16 - 19 as SCSI CDB for support ATAPI Packet command*/
5394e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB ),
5404e1bc9a0SAchim Leubner (bit32)(agSATAReq->scsiCDB[0]|(agSATAReq->scsiCDB[1]<<8)|(agSATAReq->scsiCDB[2]<<16)|(agSATAReq->scsiCDB[3]<<24)));
5414e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB )+ 4,
5424e1bc9a0SAchim Leubner (bit32)(agSATAReq->scsiCDB[4]|(agSATAReq->scsiCDB[5]<<8)|(agSATAReq->scsiCDB[6]<<16)|(agSATAReq->scsiCDB[7]<<24)));
5434e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB )+ 8,
5444e1bc9a0SAchim Leubner (bit32)(agSATAReq->scsiCDB[8]|(agSATAReq->scsiCDB[9]<<8)|(agSATAReq->scsiCDB[10]<<16)|(agSATAReq->scsiCDB[11]<<24)));
5454e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB )+ 12,
5464e1bc9a0SAchim Leubner (bit32)(agSATAReq->scsiCDB[12]|(agSATAReq->scsiCDB[13]<<8)|(agSATAReq->scsiCDB[14]<<16)|(agSATAReq->scsiCDB[15]<<24)));
5474e1bc9a0SAchim Leubner }
5484e1bc9a0SAchim Leubner }
5494e1bc9a0SAchim Leubner
5504e1bc9a0SAchim Leubner /* send IOMB to SPC */
5514e1bc9a0SAchim Leubner ret = mpiMsgProduce(circularQ,
5524e1bc9a0SAchim Leubner (void *)pMessage,
5534e1bc9a0SAchim Leubner MPI_CATEGORY_SAS_SATA,
5544e1bc9a0SAchim Leubner opCode,
5554e1bc9a0SAchim Leubner outq,
5564e1bc9a0SAchim Leubner (bit8)circularQ->priority);
5574e1bc9a0SAchim Leubner
5584e1bc9a0SAchim Leubner #ifdef SA_LL_IBQ_PROTECT
5594e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
5604e1bc9a0SAchim Leubner #endif /* SA_LL_IBQ_PROTECT */
5614e1bc9a0SAchim Leubner
5624e1bc9a0SAchim Leubner #ifdef SALL_API_TEST
5634e1bc9a0SAchim Leubner if (AGSA_RC_FAILURE != ret)
5644e1bc9a0SAchim Leubner {
5654e1bc9a0SAchim Leubner saRoot->LLCounters.IOCounter.numSataStarted++;
5664e1bc9a0SAchim Leubner }
5674e1bc9a0SAchim Leubner #endif
5684e1bc9a0SAchim Leubner
5694e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "8a");
5704e1bc9a0SAchim Leubner
5714e1bc9a0SAchim Leubner ext:
5724e1bc9a0SAchim Leubner OSSA_INP_LEAVE(agRoot);
5734e1bc9a0SAchim Leubner return ret;
5744e1bc9a0SAchim Leubner }
5754e1bc9a0SAchim Leubner
5764e1bc9a0SAchim Leubner /******************************************************************************/
5774e1bc9a0SAchim Leubner /*! \brief Abort SATA command
5784e1bc9a0SAchim Leubner *
5794e1bc9a0SAchim Leubner * Abort SATA command
5804e1bc9a0SAchim Leubner *
5814e1bc9a0SAchim Leubner * \param agRoot handles for this instance of SAS/SATA hardware
5824e1bc9a0SAchim Leubner * \param queueNum inbound/outbound queue number
5834e1bc9a0SAchim Leubner * \param agIORequest the IO Request descriptor
5844e1bc9a0SAchim Leubner * \param agIOtoBeAborted
5854e1bc9a0SAchim Leubner *
5864e1bc9a0SAchim Leubner * \return If command is aborted successfully
5874e1bc9a0SAchim Leubner * - \e AGSA_RC_SUCCESS command is aborted successfully
5884e1bc9a0SAchim Leubner * - \e AGSA_RC_FAILURE command is not aborted successfully
5894e1bc9a0SAchim Leubner */
5904e1bc9a0SAchim Leubner /*******************************************************************************/
saSATAAbort(agsaRoot_t * agRoot,agsaIORequest_t * agIORequest,bit32 queueNum,agsaDevHandle_t * agDevHandle,bit32 flag,void * abortParam,ossaGenericAbortCB_t agCB)5914e1bc9a0SAchim Leubner GLOBAL bit32 saSATAAbort(
5924e1bc9a0SAchim Leubner agsaRoot_t *agRoot,
5934e1bc9a0SAchim Leubner agsaIORequest_t *agIORequest,
5944e1bc9a0SAchim Leubner bit32 queueNum,
5954e1bc9a0SAchim Leubner agsaDevHandle_t *agDevHandle,
5964e1bc9a0SAchim Leubner bit32 flag,
5974e1bc9a0SAchim Leubner void *abortParam,
5984e1bc9a0SAchim Leubner ossaGenericAbortCB_t agCB
5994e1bc9a0SAchim Leubner )
6004e1bc9a0SAchim Leubner {
6014e1bc9a0SAchim Leubner bit32 ret = AGSA_RC_SUCCESS, retVal;
6024e1bc9a0SAchim Leubner agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
6034e1bc9a0SAchim Leubner agsaIORequestDesc_t *pRequest;
6044e1bc9a0SAchim Leubner agsaIORequestDesc_t *pRequestABT = agNULL;
6054e1bc9a0SAchim Leubner agsaDeviceDesc_t *pDevice = agNULL;
6064e1bc9a0SAchim Leubner agsaDeviceDesc_t *pDeviceABT = NULL;
6074e1bc9a0SAchim Leubner agsaPort_t *pPort = agNULL;
6084e1bc9a0SAchim Leubner mpiICQueue_t *circularQ;
6094e1bc9a0SAchim Leubner void *pMessage;
6104e1bc9a0SAchim Leubner agsaSATAAbortCmd_t *payload;
6114e1bc9a0SAchim Leubner agsaIORequest_t *agIOToBeAborted;
6124e1bc9a0SAchim Leubner bit8 inq, outq;
6134e1bc9a0SAchim Leubner bit32 flag_copy = flag;
6144e1bc9a0SAchim Leubner
6154e1bc9a0SAchim Leubner
6164e1bc9a0SAchim Leubner smTraceFuncEnter(hpDBG_VERY_LOUD,"8b");
6174e1bc9a0SAchim Leubner
6184e1bc9a0SAchim Leubner /* sanity check */
6194e1bc9a0SAchim Leubner SA_ASSERT((agNULL != agRoot), "");
6204e1bc9a0SAchim Leubner SA_ASSERT((agNULL != agIORequest), "");
6214e1bc9a0SAchim Leubner
6224e1bc9a0SAchim Leubner SA_DBG3(("saSATAAbort: Aborting request %p ITtoBeAborted %p\n", agIORequest, abortParam));
6234e1bc9a0SAchim Leubner
6244e1bc9a0SAchim Leubner /* Assign inbound and outbound Ring Buffer */
6254e1bc9a0SAchim Leubner inq = (bit8)(queueNum & MPI_IB_NUM_MASK);
6264e1bc9a0SAchim Leubner outq = (bit8)((queueNum & MPI_OB_NUM_MASK) >> MPI_OB_SHIFT);
6274e1bc9a0SAchim Leubner SA_ASSERT((AGSA_MAX_INBOUND_Q > inq), "The IBQ Number is out of range.");
6284e1bc9a0SAchim Leubner
6294e1bc9a0SAchim Leubner if( ABORT_SINGLE == (flag & ABORT_MASK) )
6304e1bc9a0SAchim Leubner {
6314e1bc9a0SAchim Leubner agIOToBeAborted = (agsaIORequest_t *)abortParam;
6324e1bc9a0SAchim Leubner /* Get LL IORequest entry for saSATAAbort() */
6334e1bc9a0SAchim Leubner pRequest = (agsaIORequestDesc_t *) (agIOToBeAborted->sdkData);
6344e1bc9a0SAchim Leubner if (agNULL == pRequest)
6354e1bc9a0SAchim Leubner {
6364e1bc9a0SAchim Leubner /* no pRequest found - can not Abort */
6374e1bc9a0SAchim Leubner SA_DBG1(("saSATAAbort: pRequest AGSA_RC_FAILURE\n"));
6384e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "8b");
6394e1bc9a0SAchim Leubner return AGSA_RC_FAILURE;
6404e1bc9a0SAchim Leubner }
6414e1bc9a0SAchim Leubner /* Find the device the request sent to */
6424e1bc9a0SAchim Leubner pDevice = pRequest->pDevice;
6434e1bc9a0SAchim Leubner /* Get LL IORequest entry */
6444e1bc9a0SAchim Leubner pRequestABT = (agsaIORequestDesc_t *) (agIOToBeAborted->sdkData);
6454e1bc9a0SAchim Leubner /* Find the device the request sent to */
6464e1bc9a0SAchim Leubner if (agNULL == pRequestABT)
6474e1bc9a0SAchim Leubner {
6484e1bc9a0SAchim Leubner /* no pRequestABT - can not find pDeviceABT */
6494e1bc9a0SAchim Leubner SA_DBG1(("saSATAAbort: pRequestABT AGSA_RC_FAILURE\n"));
6504e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "8b");
6514e1bc9a0SAchim Leubner return AGSA_RC_FAILURE;
6524e1bc9a0SAchim Leubner }
6534e1bc9a0SAchim Leubner pDeviceABT = pRequestABT->pDevice;
6544e1bc9a0SAchim Leubner
6554e1bc9a0SAchim Leubner if (agNULL == pDeviceABT)
6564e1bc9a0SAchim Leubner {
6574e1bc9a0SAchim Leubner /* no deviceID - can not build IOMB */
6584e1bc9a0SAchim Leubner SA_DBG1(("saSATAAbort: pDeviceABT AGSA_RC_FAILURE\n"));
6594e1bc9a0SAchim Leubner
6604e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "8b");
6614e1bc9a0SAchim Leubner return AGSA_RC_FAILURE;
6624e1bc9a0SAchim Leubner }
6634e1bc9a0SAchim Leubner
6644e1bc9a0SAchim Leubner if (agNULL != pDevice)
6654e1bc9a0SAchim Leubner {
6664e1bc9a0SAchim Leubner /* Find the port the request was sent to */
6674e1bc9a0SAchim Leubner pPort = pDevice->pPort;
6684e1bc9a0SAchim Leubner }
6694e1bc9a0SAchim Leubner
6704e1bc9a0SAchim Leubner /* Get request from free IORequests */
6714e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
6724e1bc9a0SAchim Leubner pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
6734e1bc9a0SAchim Leubner }
6744e1bc9a0SAchim Leubner else
6754e1bc9a0SAchim Leubner {
6764e1bc9a0SAchim Leubner if (ABORT_ALL == (flag & ABORT_MASK))
6774e1bc9a0SAchim Leubner {
6784e1bc9a0SAchim Leubner /* abort all */
6794e1bc9a0SAchim Leubner /* Find the outgoing port for the device */
6804e1bc9a0SAchim Leubner pDevice = (agsaDeviceDesc_t *) (agDevHandle->sdkData);
6814e1bc9a0SAchim Leubner pPort = pDevice->pPort;
6824e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
6834e1bc9a0SAchim Leubner pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
6844e1bc9a0SAchim Leubner }
6854e1bc9a0SAchim Leubner else
6864e1bc9a0SAchim Leubner {
6874e1bc9a0SAchim Leubner /* only support 00 and 01 for flag */
6884e1bc9a0SAchim Leubner SA_DBG1(("saSATAAbort: flag AGSA_RC_FAILURE\n"));
6894e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "8b");
6904e1bc9a0SAchim Leubner return AGSA_RC_FAILURE;
6914e1bc9a0SAchim Leubner }
6924e1bc9a0SAchim Leubner }
6934e1bc9a0SAchim Leubner
6944e1bc9a0SAchim Leubner /* If no LL IO request entry avalable */
6954e1bc9a0SAchim Leubner if ( agNULL == pRequest )
6964e1bc9a0SAchim Leubner {
6974e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
6984e1bc9a0SAchim Leubner SA_DBG1(("saSATAAbort, No request from free list\n" ));
6994e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "8b");
7004e1bc9a0SAchim Leubner return AGSA_RC_BUSY;
7014e1bc9a0SAchim Leubner }
7024e1bc9a0SAchim Leubner
7034e1bc9a0SAchim Leubner /* If free IOMB avaliable */
7044e1bc9a0SAchim Leubner /* Remove the request from free list */
7054e1bc9a0SAchim Leubner saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
7064e1bc9a0SAchim Leubner
7074e1bc9a0SAchim Leubner SA_ASSERT((!pRequest->valid), "The pRequest is in use");
7084e1bc9a0SAchim Leubner /* Add the request to the pendingIORequests list of the device */
7094e1bc9a0SAchim Leubner pRequest->valid = agTRUE;
7104e1bc9a0SAchim Leubner saLlistIOAdd(&(pDevice->pendingIORequests), &(pRequest->linkNode));
7114e1bc9a0SAchim Leubner /* set up pRequest */
7124e1bc9a0SAchim Leubner
7134e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
7144e1bc9a0SAchim Leubner
7154e1bc9a0SAchim Leubner pRequest->pIORequestContext = agIORequest;
7164e1bc9a0SAchim Leubner pRequest->requestType = AGSA_SATA_REQTYPE;
7174e1bc9a0SAchim Leubner pRequest->pDevice = pDevice;
7184e1bc9a0SAchim Leubner pRequest->pPort = pPort;
7194e1bc9a0SAchim Leubner pRequest->completionCB = (void*)agCB;
7204e1bc9a0SAchim Leubner /* pRequest->abortCompletionCB = agCB; */
7214e1bc9a0SAchim Leubner pRequest->startTick = saRoot->timeTick;
7224e1bc9a0SAchim Leubner
7234e1bc9a0SAchim Leubner /* Set request to the sdkData of agIORequest */
7244e1bc9a0SAchim Leubner agIORequest->sdkData = pRequest;
7254e1bc9a0SAchim Leubner
7264e1bc9a0SAchim Leubner /* save tag and IOrequest pointer to IOMap */
7274e1bc9a0SAchim Leubner saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
7284e1bc9a0SAchim Leubner saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
7294e1bc9a0SAchim Leubner
7304e1bc9a0SAchim Leubner #ifdef SA_LL_IBQ_PROTECT
7314e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
7324e1bc9a0SAchim Leubner #endif /* SA_LL_IBQ_PROTECT */
7334e1bc9a0SAchim Leubner
7344e1bc9a0SAchim Leubner /* If LL IO request entry avaliable */
7354e1bc9a0SAchim Leubner /* Get a free inbound queue entry */
7364e1bc9a0SAchim Leubner circularQ = &saRoot->inboundQueue[inq];
7374e1bc9a0SAchim Leubner retVal = mpiMsgFreeGet(circularQ, IOMB_SIZE64, &pMessage);
7384e1bc9a0SAchim Leubner
7394e1bc9a0SAchim Leubner /* if message size is too large return failure */
7404e1bc9a0SAchim Leubner if (AGSA_RC_FAILURE == retVal)
7414e1bc9a0SAchim Leubner {
7424e1bc9a0SAchim Leubner #ifdef SA_LL_IBQ_PROTECT
7434e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
7444e1bc9a0SAchim Leubner #endif /* SA_LL_IBQ_PROTECT */
7454e1bc9a0SAchim Leubner
7464e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
7474e1bc9a0SAchim Leubner saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
7484e1bc9a0SAchim Leubner pRequest->valid = agFALSE;
7494e1bc9a0SAchim Leubner saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
7504e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
7514e1bc9a0SAchim Leubner
7524e1bc9a0SAchim Leubner SA_DBG1(("saSATAAbort, error when get free IOMB\n"));
7534e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "8b");
7544e1bc9a0SAchim Leubner return AGSA_RC_FAILURE;
7554e1bc9a0SAchim Leubner }
7564e1bc9a0SAchim Leubner
7574e1bc9a0SAchim Leubner /* return busy if inbound queue is full */
7584e1bc9a0SAchim Leubner if (AGSA_RC_BUSY == retVal)
7594e1bc9a0SAchim Leubner {
7604e1bc9a0SAchim Leubner #ifdef SA_LL_IBQ_PROTECT
7614e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
7624e1bc9a0SAchim Leubner #endif /* SA_LL_IBQ_PROTECT */
7634e1bc9a0SAchim Leubner
7644e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
7654e1bc9a0SAchim Leubner saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
7664e1bc9a0SAchim Leubner pRequest->valid = agFALSE;
7674e1bc9a0SAchim Leubner saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
7684e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
7694e1bc9a0SAchim Leubner
7704e1bc9a0SAchim Leubner SA_DBG1(("saSATASAbort, no more IOMB\n"));
7714e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "8b");
7724e1bc9a0SAchim Leubner return AGSA_RC_BUSY;
7734e1bc9a0SAchim Leubner }
7744e1bc9a0SAchim Leubner
7754e1bc9a0SAchim Leubner
7764e1bc9a0SAchim Leubner /* setup payload */
7774e1bc9a0SAchim Leubner payload = (agsaSATAAbortCmd_t*)pMessage;
7784e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, tag), pRequest->HTag);
7794e1bc9a0SAchim Leubner
7804e1bc9a0SAchim Leubner if( ABORT_SINGLE == (flag & ABORT_MASK) )
7814e1bc9a0SAchim Leubner {
7824e1bc9a0SAchim Leubner /* If no device */
7834e1bc9a0SAchim Leubner if ( agNULL == pDeviceABT )
7844e1bc9a0SAchim Leubner {
7854e1bc9a0SAchim Leubner #ifdef SA_LL_IBQ_PROTECT
7864e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
7874e1bc9a0SAchim Leubner #endif /* SA_LL_IBQ_PROTECT */
7884e1bc9a0SAchim Leubner
7894e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
7904e1bc9a0SAchim Leubner saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
7914e1bc9a0SAchim Leubner pRequest->valid = agFALSE;
7924e1bc9a0SAchim Leubner saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
7934e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
7944e1bc9a0SAchim Leubner
7954e1bc9a0SAchim Leubner SA_DBG1(("saSATAAbort,no device\n" ));
7964e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "8b");
7974e1bc9a0SAchim Leubner return AGSA_RC_FAILURE;
7984e1bc9a0SAchim Leubner }
7994e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, deviceId), pDeviceABT->DeviceMapIndex);
8004e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, HTagAbort), pRequestABT->HTag);
8014e1bc9a0SAchim Leubner }
8024e1bc9a0SAchim Leubner else
8034e1bc9a0SAchim Leubner {
8044e1bc9a0SAchim Leubner /* abort all */
8054e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, deviceId), pDevice->DeviceMapIndex);
8064e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, HTagAbort), 0);
8074e1bc9a0SAchim Leubner }
8084e1bc9a0SAchim Leubner
8094e1bc9a0SAchim Leubner if(flag & ABORT_TSDK_QUARANTINE)
8104e1bc9a0SAchim Leubner {
8114e1bc9a0SAchim Leubner if(smIS_SPCV(agRoot))
8124e1bc9a0SAchim Leubner {
8134e1bc9a0SAchim Leubner flag_copy &= ABORT_SCOPE;
8144e1bc9a0SAchim Leubner flag_copy |= ABORT_QUARANTINE_SPCV;
8154e1bc9a0SAchim Leubner }
8164e1bc9a0SAchim Leubner }
8174e1bc9a0SAchim Leubner OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, abortAll), flag_copy);
8184e1bc9a0SAchim Leubner
8194e1bc9a0SAchim Leubner
8204e1bc9a0SAchim Leubner
8214e1bc9a0SAchim Leubner SA_DBG1(("saSATAAbort, HTag 0x%x HTagABT 0x%x deviceId 0x%x\n", payload->tag, payload->HTagAbort, payload->deviceId));
8224e1bc9a0SAchim Leubner
8234e1bc9a0SAchim Leubner /* post the IOMB to SPC */
8244e1bc9a0SAchim Leubner ret = mpiMsgProduce(circularQ, (void *)pMessage, MPI_CATEGORY_SAS_SATA, OPC_INB_SATA_ABORT, outq, (bit8)circularQ->priority);
8254e1bc9a0SAchim Leubner
8264e1bc9a0SAchim Leubner #ifdef SA_LL_IBQ_PROTECT
8274e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
8284e1bc9a0SAchim Leubner #endif /* SA_LL_IBQ_PROTECT */
8294e1bc9a0SAchim Leubner
8304e1bc9a0SAchim Leubner #ifdef SALL_API_TEST
8314e1bc9a0SAchim Leubner if (AGSA_RC_FAILURE != ret)
8324e1bc9a0SAchim Leubner {
8334e1bc9a0SAchim Leubner saRoot->LLCounters.IOCounter.numSataAborted++;
8344e1bc9a0SAchim Leubner }
8354e1bc9a0SAchim Leubner #endif
8364e1bc9a0SAchim Leubner
8374e1bc9a0SAchim Leubner siCountActiveIORequestsOnDevice( agRoot, payload->deviceId );
8384e1bc9a0SAchim Leubner
8394e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "8b");
8404e1bc9a0SAchim Leubner
8414e1bc9a0SAchim Leubner return ret;
8424e1bc9a0SAchim Leubner }
8434e1bc9a0SAchim Leubner
8444e1bc9a0SAchim Leubner /******************************************************************************/
8454e1bc9a0SAchim Leubner /*! \brief Routine to handle for received SATA with data payload event
8464e1bc9a0SAchim Leubner *
8474e1bc9a0SAchim Leubner * The handle for received SATA with data payload event
8484e1bc9a0SAchim Leubner *
8494e1bc9a0SAchim Leubner * \param agRoot handles for this instance of SAS/SATA hardware
8504e1bc9a0SAchim Leubner * \param pRequest the IO request descriptor
8514e1bc9a0SAchim Leubner * \param agFirstDword pointer to the first Dword
8524e1bc9a0SAchim Leubner * \param pResp pointer to the rest of SATA response
8534e1bc9a0SAchim Leubner * \param lengthResp total length of SATA Response frame
8544e1bc9a0SAchim Leubner *
8554e1bc9a0SAchim Leubner * \return -void-
8564e1bc9a0SAchim Leubner */
8574e1bc9a0SAchim Leubner /*******************************************************************************/
siEventSATAResponseWtDataRcvd(agsaRoot_t * agRoot,agsaIORequestDesc_t * pRequest,bit32 * agFirstDword,bit32 * pResp,bit32 lengthResp)8584e1bc9a0SAchim Leubner GLOBAL void siEventSATAResponseWtDataRcvd(
8594e1bc9a0SAchim Leubner agsaRoot_t *agRoot,
8604e1bc9a0SAchim Leubner agsaIORequestDesc_t *pRequest,
8614e1bc9a0SAchim Leubner bit32 *agFirstDword,
8624e1bc9a0SAchim Leubner bit32 *pResp,
8634e1bc9a0SAchim Leubner bit32 lengthResp
8644e1bc9a0SAchim Leubner )
8654e1bc9a0SAchim Leubner {
8664e1bc9a0SAchim Leubner agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
8674e1bc9a0SAchim Leubner agsaDeviceDesc_t *pDevice;
8684e1bc9a0SAchim Leubner #if defined(SALLSDK_DEBUG)
8694e1bc9a0SAchim Leubner agsaFrameHandle_t frameHandle;
8704e1bc9a0SAchim Leubner /* get frame handle */
8714e1bc9a0SAchim Leubner frameHandle = (agsaFrameHandle_t)(pResp);
8724e1bc9a0SAchim Leubner #endif /* SALLSDK_DEBUG */
8734e1bc9a0SAchim Leubner
8744e1bc9a0SAchim Leubner smTraceFuncEnter(hpDBG_VERY_LOUD,"8c");
8754e1bc9a0SAchim Leubner
8764e1bc9a0SAchim Leubner /* If the request is still valid */
8774e1bc9a0SAchim Leubner if ( agTRUE == pRequest->valid )
8784e1bc9a0SAchim Leubner {
8794e1bc9a0SAchim Leubner /* get device */
8804e1bc9a0SAchim Leubner pDevice = pRequest->pDevice;
8814e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
8824e1bc9a0SAchim Leubner
8834e1bc9a0SAchim Leubner /* Delete the request from the pendingIORequests */
8844e1bc9a0SAchim Leubner saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
8854e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
8864e1bc9a0SAchim Leubner
8874e1bc9a0SAchim Leubner (*(ossaSATACompletedCB_t)(pRequest->completionCB))(agRoot,
8884e1bc9a0SAchim Leubner pRequest->pIORequestContext,
8894e1bc9a0SAchim Leubner OSSA_IO_SUCCESS,
8904e1bc9a0SAchim Leubner agFirstDword,
8914e1bc9a0SAchim Leubner lengthResp,
8924e1bc9a0SAchim Leubner (void *)pResp);
8934e1bc9a0SAchim Leubner
8944e1bc9a0SAchim Leubner ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
8954e1bc9a0SAchim Leubner pRequest->valid = agFALSE;
8964e1bc9a0SAchim Leubner /* return the request to free pool */
8974e1bc9a0SAchim Leubner saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
8984e1bc9a0SAchim Leubner ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
8994e1bc9a0SAchim Leubner }
9004e1bc9a0SAchim Leubner
9014e1bc9a0SAchim Leubner smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "8c");
9024e1bc9a0SAchim Leubner
9034e1bc9a0SAchim Leubner return;
9044e1bc9a0SAchim Leubner }
9054e1bc9a0SAchim Leubner
9064e1bc9a0SAchim Leubner /******************************************************************************/
9074e1bc9a0SAchim Leubner /*! \brief copy a SATA signature to another
9084e1bc9a0SAchim Leubner *
9094e1bc9a0SAchim Leubner * copy a SATA signature to another
9104e1bc9a0SAchim Leubner *
9114e1bc9a0SAchim Leubner * \param pDstSignature pointer to the destination signature
9124e1bc9a0SAchim Leubner * \param pSrcSignature pointer to the source signature
9134e1bc9a0SAchim Leubner *
9144e1bc9a0SAchim Leubner * \return If they match
9154e1bc9a0SAchim Leubner * - \e agTRUE match
9164e1bc9a0SAchim Leubner * - \e agFALSE doesn't match
9174e1bc9a0SAchim Leubner */
9184e1bc9a0SAchim Leubner /*******************************************************************************/
siSATASignatureCpy(bit8 * pDstSignature,bit8 * pSrcSignature)9194e1bc9a0SAchim Leubner GLOBAL void siSATASignatureCpy(
9204e1bc9a0SAchim Leubner bit8 *pDstSignature,
9214e1bc9a0SAchim Leubner bit8 *pSrcSignature
9224e1bc9a0SAchim Leubner )
9234e1bc9a0SAchim Leubner {
9244e1bc9a0SAchim Leubner bit32 i;
9254e1bc9a0SAchim Leubner
9264e1bc9a0SAchim Leubner for ( i = 0; i < 5; i ++ )
9274e1bc9a0SAchim Leubner {
9284e1bc9a0SAchim Leubner pDstSignature[i] = pSrcSignature[i];
9294e1bc9a0SAchim Leubner }
9304e1bc9a0SAchim Leubner
9314e1bc9a0SAchim Leubner return;
9324e1bc9a0SAchim Leubner }
9334e1bc9a0SAchim Leubner
9344e1bc9a0SAchim Leubner
9354e1bc9a0SAchim Leubner
936