sasata.c revision 285809
1/******************************************************************************* 2*Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved. 3* 4*Redistribution and use in source and binary forms, with or without modification, are permitted provided 5*that the following conditions are met: 6*1. Redistributions of source code must retain the above copyright notice, this list of conditions and the 7*following disclaimer. 8*2. Redistributions in binary form must reproduce the above copyright notice, 9*this list of conditions and the following disclaimer in the documentation and/or other materials provided 10*with the distribution. 11* 12*THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED 13*WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 14*FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 15*FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 16*NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 17*BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 18*LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 19*SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE 20 21********************************************************************************/ 22/*******************************************************************************/ 23/*! \file sasata.c 24 * \brief The file implements the functions to SATA IO 25 * 26 */ 27/******************************************************************************/ 28#include <sys/cdefs.h> 29__FBSDID("$FreeBSD$"); 30#include <dev/pms/config.h> 31 32#include <dev/pms/RefTisa/sallsdk/spc/saglobal.h> 33#ifdef SA_ENABLE_TRACE_FUNCTIONS 34#ifdef siTraceFileID 35#undef siTraceFileID 36#endif 37#define siTraceFileID 'M' 38#endif 39 40/******************************************************************************/ 41/*! \brief Start SATA command 42 * 43 * Start SATA command 44 * 45 * \param agRoot handles for this instance of SAS/SATA hardware 46 * \param queueNum 47 * \param agIORequest 48 * \param agDevHandle 49 * \param agRequestType 50 * \param agSATAReq 51 * \param agTag 52 * \param agCB 53 * 54 * \return If command is started successfully 55 * - \e AGSA_RC_SUCCESS command is started successfully 56 * - \e AGSA_RC_FAILURE command is not started successfully 57 */ 58/*******************************************************************************/ 59GLOBAL bit32 saSATAStart( 60 agsaRoot_t *agRoot, 61 agsaIORequest_t *agIORequest, 62 bit32 queueNum, 63 agsaDevHandle_t *agDevHandle, 64 bit32 agRequestType, 65 agsaSATAInitiatorRequest_t *agSATAReq, 66 bit8 agTag, 67 ossaSATACompletedCB_t agCB 68 ) 69 70{ 71 agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData); 72 mpiICQueue_t *circularQ = agNULL; 73 agsaDeviceDesc_t *pDevice = agNULL; 74 agsaPort_t *pPort = agNULL; 75 agsaIORequestDesc_t *pRequest = agNULL; 76 void *pMessage = agNULL; 77 agsaSgl_t *pSgl = agNULL; 78 bit32 *payload = agNULL; 79 bit32 deviceIndex = 0; 80 bit32 ret = AGSA_RC_SUCCESS, retVal = 0; 81 bit32 AtapDir = 0; 82 bit32 encryptFlags = 0; 83 bit16 size = 0; 84 bit16 opCode = 0; 85 bit8 inq = 0, outq = 0; 86 87 OSSA_INP_ENTER(agRoot); 88 smTraceFuncEnter(hpDBG_VERY_LOUD, "8a"); 89 90 SA_DBG3(("saSATAStart: in\n")); 91 /* sanity check */ 92 SA_ASSERT((agNULL != agRoot), "(saSATAStart) agRoot is NULL"); 93 SA_ASSERT((agNULL != agIORequest), "(saSATAStart) agIORequest is NULL"); 94 SA_ASSERT((agNULL != agDevHandle), "(saSATAStart) agDevHandle is NULL"); 95 SA_ASSERT((agNULL != agSATAReq), "(saSATAStart) agSATAReq is NULL"); 96 97 /* Assign inbound and outbound queue */ 98 inq = (bit8)(queueNum & MPI_IB_NUM_MASK); 99 outq = (bit8)((queueNum & MPI_OB_NUM_MASK) >> MPI_OB_SHIFT); 100 SA_ASSERT((AGSA_MAX_INBOUND_Q > inq), "The IBQ Number is out of range."); 101 102 /* Find the outgoing port for the device */ 103 pDevice = (agsaDeviceDesc_t *) (agDevHandle->sdkData); 104 SA_ASSERT((agNULL != pDevice), "(saSATAStart) pDevice is NULL"); 105 106 pPort = pDevice->pPort; 107 SA_ASSERT((agNULL != pPort), "(saSATAStart) pPort is NULL"); 108 109 /* SATA DIF is obsolete */ 110 if (agSATAReq->option & AGSA_SATA_ENABLE_DIF) 111 { 112 return AGSA_RC_FAILURE; 113 } 114 115 /* find deviceID for IOMB */ 116 deviceIndex = pDevice->DeviceMapIndex; 117 118 /* Get request from free IORequests */ 119 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK); 120 pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests)); 121 if ( agNULL != pRequest ) 122 { 123 /* If free IOMB avaliable */ 124 /* Remove the request from free list */ 125 saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode)); 126 127 /* Add the request to the pendingSTARequests list of the device */ 128 pRequest->valid = agTRUE; 129 saLlistIOAdd(&(pDevice->pendingIORequests), &(pRequest->linkNode)); 130 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 131 132 if ((agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION) || 133 (agSATAReq->option & AGSA_SATA_ENABLE_DIF)) 134 { 135 opCode = OPC_INB_SATA_DIF_ENC_OPSTART; 136 size = IOMB_SIZE128; 137 } 138 else 139 { 140 opCode = OPC_INB_SATA_HOST_OPSTART; 141 if (agRequestType == AGSA_SATA_PROTOCOL_NON_PKT || 142 agRequestType == AGSA_SATA_PROTOCOL_H2D_PKT || 143 agRequestType == AGSA_SATA_PROTOCOL_D2H_PKT) 144 size = IOMB_SIZE128; 145 else 146 size = IOMB_SIZE64; 147 } 148 /* If LL IO request entry avaliable */ 149 /* set up pRequest */ 150 pRequest->pIORequestContext = agIORequest; 151 pRequest->pDevice = pDevice; 152 pRequest->pPort = pPort; 153 pRequest->requestType = agRequestType; 154 pRequest->startTick = saRoot->timeTick; 155 pRequest->completionCB = (ossaSSPCompletedCB_t)agCB; 156 /* Set request to the sdkData of agIORequest */ 157 agIORequest->sdkData = pRequest; 158 159 /* save tag and IOrequest pointer to IOMap */ 160 saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag; 161 saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest; 162 163#ifdef SA_LL_IBQ_PROTECT 164 ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq); 165#endif /* SA_LL_IBQ_PROTECT */ 166 167 /* get a free inbound queue entry */ 168 circularQ = &saRoot->inboundQueue[inq]; 169 retVal = mpiMsgFreeGet(circularQ, size, &pMessage); 170 171 if (AGSA_RC_FAILURE == retVal) 172 { 173#ifdef SA_LL_IBQ_PROTECT 174 ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq); 175#endif /* SA_LL_IBQ_PROTECT */ 176 /* if not sending return to free list rare */ 177 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK); 178 saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode)); 179 pRequest->valid = agFALSE; 180 saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode)); 181 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 182 183 SA_DBG3(("saSATAStart, error when get free IOMB\n")); 184 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "8a"); 185 ret = AGSA_RC_FAILURE; 186 goto ext; 187 } 188 189 /* return busy if inbound queue is full */ 190 if (AGSA_RC_BUSY == retVal) 191 { 192#ifdef SA_LL_IBQ_PROTECT 193 ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq); 194#endif /* SA_LL_IBQ_PROTECT */ 195 /* if not sending return to free list rare */ 196 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK); 197 saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode)); 198 pRequest->valid = agFALSE; 199 saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode)); 200 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 201 202 SA_DBG1(("saSATAStart, no more IOMB\n")); 203 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "8a"); 204 ret = AGSA_RC_BUSY; 205 goto ext; 206 } 207 208 } 209 else /* If no LL IO request entry available */ 210 { 211 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 212 SA_DBG1(("saSATAStart, No request from free list\n")); 213 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "8a"); 214 ret = AGSA_RC_BUSY; 215 goto ext; 216 } 217 218 payload = (bit32 *)pMessage; 219 SA_DBG4(("saSATAStart: Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage))); 220 221 222 switch ( agRequestType ) 223 { 224 case AGSA_SATA_PROTOCOL_FPDMA_READ: 225 case AGSA_SATA_PROTOCOL_FPDMA_WRITE: 226 case AGSA_SATA_PROTOCOL_FPDMA_READ_M: 227 case AGSA_SATA_PROTOCOL_FPDMA_WRITE_M: 228 pSgl = &(agSATAReq->agSgl); 229 AtapDir = agRequestType & (AGSA_DIR_MASK | AGSA_SATA_ATAP_MASK); 230 if (agRequestType & AGSA_MSG) 231 { 232 /* set M bit */ 233 AtapDir |= AGSA_MSG_BIT; 234 } 235 break; 236 case AGSA_SATA_PROTOCOL_DMA_READ: 237 case AGSA_SATA_PROTOCOL_DMA_WRITE: 238 case AGSA_SATA_PROTOCOL_DMA_READ_M: 239 case AGSA_SATA_PROTOCOL_DMA_WRITE_M: 240 case AGSA_SATA_PROTOCOL_PIO_READ_M: 241 case AGSA_SATA_PROTOCOL_PIO_WRITE_M: 242 case AGSA_SATA_PROTOCOL_PIO_READ: 243 case AGSA_SATA_PROTOCOL_PIO_WRITE: 244 case AGSA_SATA_PROTOCOL_H2D_PKT: 245 case AGSA_SATA_PROTOCOL_D2H_PKT: 246 agTag = 0; /* agTag not valid for these requests */ 247 pSgl = &(agSATAReq->agSgl); 248 AtapDir = agRequestType & (AGSA_DIR_MASK | AGSA_SATA_ATAP_MASK); 249 if (agRequestType & AGSA_MSG) 250 { 251 /* set M bit */ 252 AtapDir |= AGSA_MSG_BIT; 253 } 254 break; 255 256 case AGSA_SATA_PROTOCOL_NON_DATA: 257 case AGSA_SATA_PROTOCOL_NON_DATA_M: 258 case AGSA_SATA_PROTOCOL_NON_PKT: 259 agTag = 0; /* agTag not valid for these requests */ 260 AtapDir = agRequestType & (AGSA_DIR_MASK | AGSA_SATA_ATAP_MASK); 261 if (agRequestType & AGSA_MSG) 262 { 263 /* set M bit */ 264 AtapDir |= AGSA_MSG_BIT; 265 } 266 break; 267 268 case AGSA_SATA_PROTOCOL_SRST_ASSERT: 269 agTag = 0; /* agTag not valid for these requests */ 270 AtapDir = AGSA_SATA_ATAP_SRST_ASSERT; 271 break; 272 273 case AGSA_SATA_PROTOCOL_SRST_DEASSERT: 274 agTag = 0; /* agTag not valid for these requests */ 275 AtapDir = AGSA_SATA_ATAP_SRST_DEASSERT; 276 break; 277 278 case AGSA_SATA_PROTOCOL_DEV_RESET: 279 case AGSA_SATA_PROTOCOL_DEV_RESET_M: /* TestBase */ 280 agTag = 0; /* agTag not valid for these requests */ 281 AtapDir = AGSA_SATA_ATAP_PKT_DEVRESET; 282 if (agRequestType & AGSA_MSG) 283 { 284 /* set M bit */ 285 AtapDir |= AGSA_MSG_BIT; /* TestBase */ 286 } 287 break; 288 289 default: 290 SA_DBG1(("saSATAStart: (Unknown agRequestType) 0x%X \n",agRequestType)); 291 SA_ASSERT((0), "saSATAStart: (Unknown agRequestType)"); 292 293 break; 294 } 295 296 if ((AGSA_SATA_PROTOCOL_SRST_ASSERT == agRequestType) || 297 (AGSA_SATA_PROTOCOL_SRST_DEASSERT == agRequestType) || 298 (AGSA_SATA_PROTOCOL_DEV_RESET == agRequestType)) 299 { 300 301 SA_DBG3(("saSATAStart:AGSA_SATA_PROTOCOL_SRST_DEASSERT AGSA_SATA_PROTOCOL_SRST_ASSERT\n")); 302 303 si_memset((void *)payload, 0, sizeof(agsaSATAStartCmd_t)); 304 /* build IOMB DW 1 */ 305 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t, tag), pRequest->HTag); 306 /* DWORD 2 */ 307 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,deviceId ), deviceIndex); 308 /* DWORD 3 */ 309 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,dataLen ), 0 ); 310 /* DWORD 4 */ 311 OSSA_WRITE_LE_32(agRoot, 312 payload, 313 OSSA_OFFSET_OF(agsaSATAStartCmd_t,optNCQTagataProt ), 314 (((agSATAReq->option & SATA_FIS_MASK) << SHIFT24) | 315 (agTag << SHIFT16) | 316 AtapDir)); 317 318 si_memcpy((void *)(payload+4), (void *)&agSATAReq->fis.fisRegHostToDev, sizeof(agsaFisRegHostToDevice_t)); 319 } 320 else 321 { 322 /* build IOMB DW 1 */ 323 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t, tag), pRequest->HTag); 324 /* DWORD 2 */ 325 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,deviceId ), deviceIndex); 326 /* DWORD 3 */ 327 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,dataLen ), agSATAReq->dataLength ); 328 329 /* Since we are writing the payload in order, check for any special modes now. */ 330 if (agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION) 331 { 332 SA_ASSERT((opCode == OPC_INB_SATA_DIF_ENC_OPSTART), "opcode"); 333 SA_DBG4(("saSATAStart: 1 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage))); 334 AtapDir |= AGSA_ENCRYPT_BIT; 335 } 336 337 if (agSATAReq->option & AGSA_SATA_ENABLE_DIF) 338 { 339 SA_ASSERT((opCode == OPC_INB_SATA_DIF_ENC_OPSTART), "opcode"); 340 AtapDir |= AGSA_DIF_BIT; 341 } 342#ifdef CCBUILD_TEST_EPL 343 if(agSATAReq->encrypt.enableEncryptionPerLA) 344 AtapDir |= (1 << SHIFT4); // enable EPL 345#endif 346 /* DWORD 4 */ 347 OSSA_WRITE_LE_32(agRoot, 348 payload, 349 OSSA_OFFSET_OF(agsaSATAStartCmd_t,optNCQTagataProt ), 350 (((agSATAReq->option & SATA_FIS_MASK) << SHIFT24) | 351 (agTag << SHIFT16) | 352 AtapDir)); 353 354 /* DWORD 5 6 7 8 9 */ 355 si_memcpy((void *)(payload+4), (void *)&agSATAReq->fis.fisRegHostToDev, sizeof(agsaFisRegHostToDevice_t)); 356 /* DWORD 10 reserved */ 357 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,reserved1 ), 0 ); 358 359 /* DWORD 11 reserved */ 360 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,reserved2 ), 0 ); 361 362 SA_DBG4(("saSATAStart: 2 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage))); 363 } 364 if (agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION) 365 { 366 /* Write 10 dwords of zeroes as payload, skipping all DIF fields */ 367 SA_DBG4(("saSATAStart: 2a Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage))); 368 if (opCode == OPC_INB_SATA_DIF_ENC_OPSTART) 369 { 370 /* DW 11 */ 371 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_EPL_DESCL ),0 ); 372 /* DW 12 */ 373 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,resSKIPBYTES ),0 ); 374 /* DW 13 */ 375 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_DPL_DESCL_NDPLR ),0 ); 376 /* DW 14 */ 377 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_EDPL_DESCH ),0 ); 378 /* DW 15 */ 379 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,DIF_flags ),0 ); 380 /* DW 16 */ 381 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,udt ),0 ); 382 /* DW 17 */ 383 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,udtReplacementLo ),0 ); 384 /* DW 18 */ 385 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,udtReplacementHi ),0 ); 386 /* DW 19 */ 387 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,DIF_seed ),0 ); 388 } 389 390 if (agSATAReq->option & AGSA_SATA_ENABLE_ENCRYPTION) 391 { 392 SA_ASSERT((opCode == OPC_INB_SATA_DIF_ENC_OPSTART), "opcode"); 393 394 SA_DBG4(("saSATAStart: 3 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage))); 395 /* Configure DWORD 20 */ 396 encryptFlags = 0; 397 398 if (agSATAReq->encrypt.keyTagCheck == agTRUE) 399 { 400 encryptFlags |= AGSA_ENCRYPT_KEY_TAG_BIT; 401 } 402 403 if( agSATAReq->encrypt.cipherMode == agsaEncryptCipherModeXTS ) 404 { 405 encryptFlags |= AGSA_ENCRYPT_XTS_Mode << SHIFT4; 406 } 407 408 encryptFlags |= agSATAReq->encrypt.dekInfo.dekTable << SHIFT2; 409 410 encryptFlags |= (agSATAReq->encrypt.dekInfo.dekIndex & 0xFFFFFF) << SHIFT8; 411 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,encryptFlagsLo ),encryptFlags ); 412 413 /* Configure DWORD 21*/ 414 /* This information is available in the sectorSizeIndex */ 415 encryptFlags = agSATAReq->encrypt.sectorSizeIndex; 416 /* 417 * Set Region0 sectors count 418 */ 419 if(agSATAReq->encrypt.enableEncryptionPerLA) 420 { 421 encryptFlags |= (agSATAReq->encrypt.EncryptionPerLRegion0SecCount << SHIFT16); 422 } 423 424 encryptFlags |= (agSATAReq->encrypt.kekIndex) << SHIFT5; 425 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,encryptFlagsHi ),encryptFlags ); 426 427 /* Configure DWORD 22*/ 428 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagLo ), agSATAReq->encrypt.keyTag_W0 ); 429 /* Configure DWORD 23 */ 430 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagHi ), agSATAReq->encrypt.keyTag_W1 ); 431 /* Configure DWORD 24 */ 432 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W0 ), agSATAReq->encrypt.tweakVal_W0 ); 433 /* Configure DWORD 25 */ 434 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W1 ), agSATAReq->encrypt.tweakVal_W1 ); 435 /* Configure DWORD 26 */ 436 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W2 ), agSATAReq->encrypt.tweakVal_W2 ); 437 /* Configure DWORD 27 */ 438 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W3 ), agSATAReq->encrypt.tweakVal_W3 ); 439 } 440 else 441 { 442 /* Write 8 dwords of zeros as payload, skipping all encryption fields */ 443 if (opCode == OPC_INB_SATA_DIF_ENC_OPSTART) 444 { 445 /* Configure DWORD 22*/ 446 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagLo ), 0 ); 447 /* Configure DWORD 23 */ 448 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,keyTagHi ), 0 ); 449 /* Configure DWORD 24 */ 450 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W0 ), 0 ); 451 /* Configure DWORD 25 */ 452 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W1 ), 0 ); 453 /* Configure DWORD 26 */ 454 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W2 ), 0 ); 455 /* Configure DWORD 27 */ 456 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,tweakVal_W3 ), 0 ); 457 } 458 } 459 460 SA_DBG4(("saSATAStart: 4 Payload offset 0x%X\n", (unsigned int)(payload - (bit32 *)pMessage))); 461 462 /* DWORD 11 13 14*/ 463 if(agSATAReq->encrypt.enableEncryptionPerLA) 464 { 465 /* DWORD 11 */ 466 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_EPL_DESCL), 467 agSATAReq->encrypt.EncryptionPerLAAddrLo); 468 /* DWORD 13 */ 469 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_DPL_DESCL_NDPLR), 0); 470 /* DWORD 14 */ 471 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_EDPL_DESCH), 472 agSATAReq->encrypt.EncryptionPerLAAddrHi); 473 } 474 else 475 { 476 /* DWORD 11 */ 477 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_EPL_DESCL),0); 478 /* DW 13 */ 479 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t, Res_DPL_DESCL_NDPLR), 0); 480 /* DWORD 14 */ 481 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Res_EDPL_DESCH ),0 ); 482 } 483 484 /* Configure DWORD 28 for encryption*/ 485 if (pSgl) 486 { 487 /* Configure DWORD 28 */ 488 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrLow0 ), pSgl->sgLower ); 489 /* Configure DWORD 29 */ 490 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrHi0 ), pSgl->sgUpper ); 491 /* Configure DWORD 30 */ 492 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Len0 ), pSgl->len ); 493 /* Configure DWORD 31 */ 494 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,E0 ), pSgl->extReserved ); 495 } 496 else 497 { 498 /* Configure DWORD 28 */ 499 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrLow0 ), 0 ); 500 /* Configure DWORD 29 */ 501 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,AddrHi0 ), 0 ); 502 /* Configure DWORD 30 */ 503 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,Len0 ), 0 ); 504 /* Configure DWORD 31 */ 505 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAEncryptStartCmd_t,E0 ), 0 ); 506 } 507 508 } 509 else 510 { 511 SA_ASSERT((opCode == OPC_INB_SATA_HOST_OPSTART), "opcode"); 512 if (pSgl) 513 { 514 /* Configure DWORD 12 */ 515 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrLow0 ), pSgl->sgLower ); 516 /* Configure DWORD 13 */ 517 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrHi0 ), pSgl->sgUpper ); 518 /* Configure DWORD 14 */ 519 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,Len0 ), pSgl->len ); 520 /* Configure DWORD 15 */ 521 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,E0 ), pSgl->extReserved ); 522 } 523 else 524 { 525 /* Configure DWORD 12 */ 526 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrLow0 ), 0 ); 527 /* Configure DWORD 13 */ 528 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,AddrHi0 ), 0 ); 529 /* Configure DWORD 14 */ 530 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,Len0 ), 0 ); 531 /* Configure DWORD 15 */ 532 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,E0 ), 0 ); 533 } 534 /* support ATAPI packet command */ 535 if ((agRequestType == AGSA_SATA_PROTOCOL_NON_PKT || 536 agRequestType == AGSA_SATA_PROTOCOL_H2D_PKT || 537 agRequestType == AGSA_SATA_PROTOCOL_D2H_PKT)) 538 { 539 /*DWORD 16 - 19 as SCSI CDB for support ATAPI Packet command*/ 540 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB ), 541 (bit32)(agSATAReq->scsiCDB[0]|(agSATAReq->scsiCDB[1]<<8)|(agSATAReq->scsiCDB[2]<<16)|(agSATAReq->scsiCDB[3]<<24))); 542 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB )+ 4, 543 (bit32)(agSATAReq->scsiCDB[4]|(agSATAReq->scsiCDB[5]<<8)|(agSATAReq->scsiCDB[6]<<16)|(agSATAReq->scsiCDB[7]<<24))); 544 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB )+ 8, 545 (bit32)(agSATAReq->scsiCDB[8]|(agSATAReq->scsiCDB[9]<<8)|(agSATAReq->scsiCDB[10]<<16)|(agSATAReq->scsiCDB[11]<<24))); 546 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAStartCmd_t,ATAPICDB )+ 12, 547 (bit32)(agSATAReq->scsiCDB[12]|(agSATAReq->scsiCDB[13]<<8)|(agSATAReq->scsiCDB[14]<<16)|(agSATAReq->scsiCDB[15]<<24))); 548 } 549 } 550 551 /* send IOMB to SPC */ 552 ret = mpiMsgProduce(circularQ, 553 (void *)pMessage, 554 MPI_CATEGORY_SAS_SATA, 555 opCode, 556 outq, 557 (bit8)circularQ->priority); 558 559#ifdef SA_LL_IBQ_PROTECT 560 ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq); 561#endif /* SA_LL_IBQ_PROTECT */ 562 563#ifdef SALL_API_TEST 564 if (AGSA_RC_FAILURE != ret) 565 { 566 saRoot->LLCounters.IOCounter.numSataStarted++; 567 } 568#endif 569 570 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "8a"); 571 572ext: 573 OSSA_INP_LEAVE(agRoot); 574 return ret; 575} 576 577/******************************************************************************/ 578/*! \brief Abort SATA command 579 * 580 * Abort SATA command 581 * 582 * \param agRoot handles for this instance of SAS/SATA hardware 583 * \param queueNum inbound/outbound queue number 584 * \param agIORequest the IO Request descriptor 585 * \param agIOtoBeAborted 586 * 587 * \return If command is aborted successfully 588 * - \e AGSA_RC_SUCCESS command is aborted successfully 589 * - \e AGSA_RC_FAILURE command is not aborted successfully 590 */ 591/*******************************************************************************/ 592GLOBAL bit32 saSATAAbort( 593 agsaRoot_t *agRoot, 594 agsaIORequest_t *agIORequest, 595 bit32 queueNum, 596 agsaDevHandle_t *agDevHandle, 597 bit32 flag, 598 void *abortParam, 599 ossaGenericAbortCB_t agCB 600 ) 601{ 602 bit32 ret = AGSA_RC_SUCCESS, retVal; 603 agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData); 604 agsaIORequestDesc_t *pRequest; 605 agsaIORequestDesc_t *pRequestABT = agNULL; 606 agsaDeviceDesc_t *pDevice = agNULL; 607 agsaDeviceDesc_t *pDeviceABT = NULL; 608 agsaPort_t *pPort = agNULL; 609 mpiICQueue_t *circularQ; 610 void *pMessage; 611 agsaSATAAbortCmd_t *payload; 612 agsaIORequest_t *agIOToBeAborted; 613 bit8 inq, outq; 614 bit32 flag_copy = flag; 615 616 617 smTraceFuncEnter(hpDBG_VERY_LOUD,"8b"); 618 619 /* sanity check */ 620 SA_ASSERT((agNULL != agRoot), ""); 621 SA_ASSERT((agNULL != agIORequest), ""); 622 623 SA_DBG3(("saSATAAbort: Aborting request %p ITtoBeAborted %p\n", agIORequest, abortParam)); 624 625 /* Assign inbound and outbound Ring Buffer */ 626 inq = (bit8)(queueNum & MPI_IB_NUM_MASK); 627 outq = (bit8)((queueNum & MPI_OB_NUM_MASK) >> MPI_OB_SHIFT); 628 SA_ASSERT((AGSA_MAX_INBOUND_Q > inq), "The IBQ Number is out of range."); 629 630 if( ABORT_SINGLE == (flag & ABORT_MASK) ) 631 { 632 agIOToBeAborted = (agsaIORequest_t *)abortParam; 633 /* Get LL IORequest entry for saSATAAbort() */ 634 pRequest = (agsaIORequestDesc_t *) (agIOToBeAborted->sdkData); 635 if (agNULL == pRequest) 636 { 637 /* no pRequest found - can not Abort */ 638 SA_DBG1(("saSATAAbort: pRequest AGSA_RC_FAILURE\n")); 639 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "8b"); 640 return AGSA_RC_FAILURE; 641 } 642 /* Find the device the request sent to */ 643 pDevice = pRequest->pDevice; 644 /* Get LL IORequest entry */ 645 pRequestABT = (agsaIORequestDesc_t *) (agIOToBeAborted->sdkData); 646 /* Find the device the request sent to */ 647 if (agNULL == pRequestABT) 648 { 649 /* no pRequestABT - can not find pDeviceABT */ 650 SA_DBG1(("saSATAAbort: pRequestABT AGSA_RC_FAILURE\n")); 651 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "8b"); 652 return AGSA_RC_FAILURE; 653 } 654 pDeviceABT = pRequestABT->pDevice; 655 656 if (agNULL == pDeviceABT) 657 { 658 /* no deviceID - can not build IOMB */ 659 SA_DBG1(("saSATAAbort: pDeviceABT AGSA_RC_FAILURE\n")); 660 661 smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "8b"); 662 return AGSA_RC_FAILURE; 663 } 664 665 if (agNULL != pDevice) 666 { 667 /* Find the port the request was sent to */ 668 pPort = pDevice->pPort; 669 } 670 671 /* Get request from free IORequests */ 672 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK); 673 pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests)); 674 } 675 else 676 { 677 if (ABORT_ALL == (flag & ABORT_MASK)) 678 { 679 /* abort all */ 680 /* Find the outgoing port for the device */ 681 pDevice = (agsaDeviceDesc_t *) (agDevHandle->sdkData); 682 pPort = pDevice->pPort; 683 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK); 684 pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests)); 685 } 686 else 687 { 688 /* only support 00 and 01 for flag */ 689 SA_DBG1(("saSATAAbort: flag AGSA_RC_FAILURE\n")); 690 smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "8b"); 691 return AGSA_RC_FAILURE; 692 } 693 } 694 695 /* If no LL IO request entry avalable */ 696 if ( agNULL == pRequest ) 697 { 698 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 699 SA_DBG1(("saSATAAbort, No request from free list\n" )); 700 smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "8b"); 701 return AGSA_RC_BUSY; 702 } 703 704 /* If free IOMB avaliable */ 705 /* Remove the request from free list */ 706 saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode)); 707 708 SA_ASSERT((!pRequest->valid), "The pRequest is in use"); 709 /* Add the request to the pendingIORequests list of the device */ 710 pRequest->valid = agTRUE; 711 saLlistIOAdd(&(pDevice->pendingIORequests), &(pRequest->linkNode)); 712 /* set up pRequest */ 713 714 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 715 716 pRequest->pIORequestContext = agIORequest; 717 pRequest->requestType = AGSA_SATA_REQTYPE; 718 pRequest->pDevice = pDevice; 719 pRequest->pPort = pPort; 720 pRequest->completionCB = (void*)agCB; 721/* pRequest->abortCompletionCB = agCB; */ 722 pRequest->startTick = saRoot->timeTick; 723 724 /* Set request to the sdkData of agIORequest */ 725 agIORequest->sdkData = pRequest; 726 727 /* save tag and IOrequest pointer to IOMap */ 728 saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag; 729 saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest; 730 731#ifdef SA_LL_IBQ_PROTECT 732 ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq); 733#endif /* SA_LL_IBQ_PROTECT */ 734 735 /* If LL IO request entry avaliable */ 736 /* Get a free inbound queue entry */ 737 circularQ = &saRoot->inboundQueue[inq]; 738 retVal = mpiMsgFreeGet(circularQ, IOMB_SIZE64, &pMessage); 739 740 /* if message size is too large return failure */ 741 if (AGSA_RC_FAILURE == retVal) 742 { 743#ifdef SA_LL_IBQ_PROTECT 744 ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq); 745#endif /* SA_LL_IBQ_PROTECT */ 746 747 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK); 748 saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode)); 749 pRequest->valid = agFALSE; 750 saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode)); 751 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 752 753 SA_DBG1(("saSATAAbort, error when get free IOMB\n")); 754 smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "8b"); 755 return AGSA_RC_FAILURE; 756 } 757 758 /* return busy if inbound queue is full */ 759 if (AGSA_RC_BUSY == retVal) 760 { 761#ifdef SA_LL_IBQ_PROTECT 762 ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq); 763#endif /* SA_LL_IBQ_PROTECT */ 764 765 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK); 766 saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode)); 767 pRequest->valid = agFALSE; 768 saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode)); 769 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 770 771 SA_DBG1(("saSATASAbort, no more IOMB\n")); 772 smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "8b"); 773 return AGSA_RC_BUSY; 774 } 775 776 777 /* setup payload */ 778 payload = (agsaSATAAbortCmd_t*)pMessage; 779 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, tag), pRequest->HTag); 780 781 if( ABORT_SINGLE == (flag & ABORT_MASK) ) 782 { 783 /* If no device */ 784 if ( agNULL == pDeviceABT ) 785 { 786 #ifdef SA_LL_IBQ_PROTECT 787 ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq); 788 #endif /* SA_LL_IBQ_PROTECT */ 789 790 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK); 791 saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode)); 792 pRequest->valid = agFALSE; 793 saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode)); 794 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 795 796 SA_DBG1(("saSATAAbort,no device\n" )); 797 smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "8b"); 798 return AGSA_RC_FAILURE; 799 } 800 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, deviceId), pDeviceABT->DeviceMapIndex); 801 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, HTagAbort), pRequestABT->HTag); 802 } 803 else 804 { 805 /* abort all */ 806 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, deviceId), pDevice->DeviceMapIndex); 807 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, HTagAbort), 0); 808 } 809 810 if(flag & ABORT_TSDK_QUARANTINE) 811 { 812 if(smIS_SPCV(agRoot)) 813 { 814 flag_copy &= ABORT_SCOPE; 815 flag_copy |= ABORT_QUARANTINE_SPCV; 816 } 817 } 818 OSSA_WRITE_LE_32(agRoot, payload, OSSA_OFFSET_OF(agsaSATAAbortCmd_t, abortAll), flag_copy); 819 820 821 822 SA_DBG1(("saSATAAbort, HTag 0x%x HTagABT 0x%x deviceId 0x%x\n", payload->tag, payload->HTagAbort, payload->deviceId)); 823 824 /* post the IOMB to SPC */ 825 ret = mpiMsgProduce(circularQ, (void *)pMessage, MPI_CATEGORY_SAS_SATA, OPC_INB_SATA_ABORT, outq, (bit8)circularQ->priority); 826 827#ifdef SA_LL_IBQ_PROTECT 828 ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq); 829#endif /* SA_LL_IBQ_PROTECT */ 830 831#ifdef SALL_API_TEST 832 if (AGSA_RC_FAILURE != ret) 833 { 834 saRoot->LLCounters.IOCounter.numSataAborted++; 835 } 836#endif 837 838 siCountActiveIORequestsOnDevice( agRoot, payload->deviceId ); 839 840 smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "8b"); 841 842 return ret; 843} 844 845/******************************************************************************/ 846/*! \brief Routine to handle for received SATA with data payload event 847 * 848 * The handle for received SATA with data payload event 849 * 850 * \param agRoot handles for this instance of SAS/SATA hardware 851 * \param pRequest the IO request descriptor 852 * \param agFirstDword pointer to the first Dword 853 * \param pResp pointer to the rest of SATA response 854 * \param lengthResp total length of SATA Response frame 855 * 856 * \return -void- 857 */ 858/*******************************************************************************/ 859GLOBAL void siEventSATAResponseWtDataRcvd( 860 agsaRoot_t *agRoot, 861 agsaIORequestDesc_t *pRequest, 862 bit32 *agFirstDword, 863 bit32 *pResp, 864 bit32 lengthResp 865 ) 866{ 867 agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData); 868 agsaDeviceDesc_t *pDevice; 869#if defined(SALLSDK_DEBUG) 870 agsaFrameHandle_t frameHandle; 871 /* get frame handle */ 872 frameHandle = (agsaFrameHandle_t)(pResp); 873#endif /* SALLSDK_DEBUG */ 874 875 smTraceFuncEnter(hpDBG_VERY_LOUD,"8c"); 876 877 /* If the request is still valid */ 878 if ( agTRUE == pRequest->valid ) 879 { 880 /* get device */ 881 pDevice = pRequest->pDevice; 882 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK); 883 884 /* Delete the request from the pendingIORequests */ 885 saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode)); 886 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 887 888 (*(ossaSATACompletedCB_t)(pRequest->completionCB))(agRoot, 889 pRequest->pIORequestContext, 890 OSSA_IO_SUCCESS, 891 agFirstDword, 892 lengthResp, 893 (void *)pResp); 894 895 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK); 896 pRequest->valid = agFALSE; 897 /* return the request to free pool */ 898 saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode)); 899 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK); 900 } 901 902 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "8c"); 903 904 return; 905} 906 907/******************************************************************************/ 908/*! \brief copy a SATA signature to another 909 * 910 * copy a SATA signature to another 911 * 912 * \param pDstSignature pointer to the destination signature 913 * \param pSrcSignature pointer to the source signature 914 * 915 * \return If they match 916 * - \e agTRUE match 917 * - \e agFALSE doesn't match 918 */ 919/*******************************************************************************/ 920GLOBAL void siSATASignatureCpy( 921 bit8 *pDstSignature, 922 bit8 *pSrcSignature 923 ) 924{ 925 bit32 i; 926 927 for ( i = 0; i < 5; i ++ ) 928 { 929 pDstSignature[i] = pSrcSignature[i]; 930 } 931 932 return; 933} 934 935 936 937