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