1 /*******************************************************************************
2 *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
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
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.
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
21 ********************************************************************************/
22 #include <sys/cdefs.h>
23 __FBSDID("$FreeBSD$");
24 #include <dev/pms/config.h>
26 #include <dev/pms/freebsd/driver/common/osenv.h>
27 #include <dev/pms/freebsd/driver/common/ostypes.h>
28 #include <dev/pms/freebsd/driver/common/osdebug.h>
30 #include <dev/pms/RefTisa/tisa/api/titypes.h>
32 #include <dev/pms/RefTisa/sallsdk/api/sa.h>
33 #include <dev/pms/RefTisa/sallsdk/api/saapi.h>
34 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
36 #include <dev/pms/RefTisa/sat/api/sm.h>
37 #include <dev/pms/RefTisa/sat/api/smapi.h>
38 #include <dev/pms/RefTisa/sat/api/tdsmapi.h>
40 #include <dev/pms/RefTisa/sat/src/smdefs.h>
41 #include <dev/pms/RefTisa/sat/src/smproto.h>
42 #include <dev/pms/RefTisa/sat/src/smtypes.h>
44 extern smRoot_t *gsmRoot;
46 /******************************** completion ***********************************************************/
51 agsaIORequest_t *agIORequest,
58 smRoot_t *smRoot = agNULL;
59 // smIntRoot_t *smIntRoot = agNULL;
60 // smIntContext_t *smAllShared = agNULL;
61 smIORequestBody_t *smIORequestBody;
62 smSatIOContext_t *satIOContext;
63 smDeviceData_t *pSatDevData;
64 smDeviceHandle_t *smDeviceHandle = agNULL;
65 smDeviceData_t *oneDeviceData = agNULL;
67 SM_DBG2(("smllSATACompleted: start\n"));
69 if (agIORequest == agNULL)
71 SM_DBG1(("smllSATACompleted: agIORequest is NULL!!!\n"));
75 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
77 if (smIORequestBody == agNULL)
79 SM_DBG1(("smllSATACompleted: smIORequestBody is NULL!!!\n"));
84 if (smIORequestBody->ioCompleted == agTRUE)
86 smDeviceHandle = smIORequestBody->smDevHandle;
87 if (smDeviceHandle == agNULL)
89 SM_DBG1(("smllSATACompleted: smDeviceHandle is NULL!!!\n"));
92 oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData;
93 SM_DBG1(("smllSATACompleted: Error!!!!!! double completion!!!, ID %d!!!\n", smIORequestBody->id));
94 if (oneDeviceData == agNULL)
96 SM_DBG1(("smllSATACompleted: oneDeviceData is NULL!!!\n"));
99 SM_DBG1(("smllSATACompleted: did %d!!!\n", oneDeviceData->id));
103 smIORequestBody->ioCompleted = agTRUE;
104 satIOContext = &(smIORequestBody->transport.SATA.satIOContext);
106 if (satIOContext == agNULL)
108 SM_DBG1(("smllSATACompleted: satIOContext is NULL!!!\n"));
112 pSatDevData = satIOContext->pSatDevData;
114 if (pSatDevData == agNULL)
116 SM_DBG1(("smllSATACompleted: pSatDevData is NULL loc 1, wrong!!!\n"));
117 if (satIOContext->satIntIoContext == agNULL)
119 SM_DBG1(("smllSATACompleted: external command!!!\n"));
123 SM_DBG1(("smllSATACompleted: internal command!!!\n"));
128 smDeviceHandle = smIORequestBody->smDevHandle;
130 if (smDeviceHandle == agNULL)
132 SM_DBG1(("smllSATACompleted: smDeviceHandle is NULL!!!!\n"));
136 oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData;
138 if (oneDeviceData != pSatDevData)
140 SM_DBG1(("smllSATACompleted: diff device handle!!!\n"));
141 if (satIOContext->satIntIoContext == agNULL)
143 SM_DBG1(("smllSATACompleted: external command!!!\n"));
147 SM_DBG1(("smllSATACompleted: internal command!!!\n"));
152 if (oneDeviceData == agNULL)
154 SM_DBG1(("smllSATACompleted: oneDeviceData is NULL!!!!\n"));
155 if (satIOContext->satIntIoContext == agNULL)
157 SM_DBG1(("smllSATACompleted: external command!!!\n"));
161 SM_DBG1(("smllSATACompleted: internal command!!!\n"));
166 smRoot = oneDeviceData->smRoot;
168 /* release tag value for SATA */
169 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) ||
170 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) )
172 smsatTagRelease(smRoot, pSatDevData, satIOContext->sataTag);
173 SM_DBG3(("smllSATACompleted: ncq tag 0x%x\n",satIOContext->sataTag));
176 /* just for debugging */
177 if (agIOStatus == OSSA_IO_DS_NON_OPERATIONAL)
179 SM_DBG1(("smllSATACompleted: agIOStatus is OSSA_IO_DS_NON_OPERATIONAL!!!\n"));
181 if (agIOStatus == OSSA_IO_DS_IN_RECOVERY)
183 SM_DBG1(("smllSATACompleted: agIOStatus is OSSA_IO_DS_IN_RECOVERY!!!\n"));
185 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS)
187 SM_DBG1(("smllSATACompleted: agIOStatus is OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS!!!\n"));
190 satIOContext->satCompleteCB( agRoot,
202 /*****************************************************************************
203 *! \brief smsatPacketCB
205 * This routine is a callback function called from smllSATACompleted().
206 * This CB routine deals with normal Packet command I/O SATA request.
208 * \param agRoot: Handles for this instance of SAS/SATA hardware
209 * \param agIORequest: Pointer to the LL I/O request context for this I/O.
210 * \param agIOStatus: Status of completed I/O.
211 * \param agFirstDword:Pointer to the four bytes of FIS.
212 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS
214 * \param agParam: Additional info based on status.
215 * \param ioContext: Pointer to smSatIOContext_t.
219 *****************************************************************************/
224 agsaIORequest_t *agIORequest,
226 agsaFisHeader_t *agFirstDword,
232 smRoot_t *smRoot = agNULL;
233 smIntRoot_t *smIntRoot = agNULL;
234 smIntContext_t *smAllShared = agNULL;
235 smIORequestBody_t *smIORequestBody;
236 smIORequestBody_t *smOrgIORequestBody;
237 smSatIOContext_t *satIOContext;
238 smSatIOContext_t *satOrgIOContext;
239 smSatIOContext_t *satNewIOContext;
240 smSatInternalIo_t *satIntIo;
241 smSatInternalIo_t *satNewIntIo = agNULL;
242 smDeviceData_t *oneDeviceData;
243 bit32 interruptContext;
244 smScsiRspSense_t *pSense;
245 smIniScsiCmnd_t *scsiCmnd;
246 smIORequest_t *smOrgIORequest;
247 // bit32 ataStatus = 0;
250 bit32 status = SM_RC_SUCCESS;
251 // agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
254 bit16 bSenseCodeInfo = 0;
256 SM_DBG3(("smsatPacketCB: start\n"));
257 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
258 satIOContext = (smSatIOContext_t *) ioContext;
259 if (satIOContext == agNULL)
261 SM_DBG1(("smsatPacketCB: satIOContext is NULL\n"));
264 satIntIo = satIOContext->satIntIoContext;
265 oneDeviceData = satIOContext->pSatDevData;
266 interruptContext = satIOContext->interruptContext;
267 smRoot = oneDeviceData->smRoot;
268 smIntRoot = (smIntRoot_t *)smRoot->smData;
269 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
271 if (satIntIo == agNULL)
273 SM_DBG5(("smsatPacketCB: External smSatInternalIo_t satIntIoContext\n"));
274 satOrgIOContext = satIOContext;
275 smOrgIORequest = smIORequestBody->smIORequest;
276 pSense = satIOContext->pSense;
277 scsiCmnd = satIOContext->pScsiCmnd;
281 SM_DBG5(("smsatPacketCB: Internal smSatInternalIo_t satIntIoContext\n"));
282 satOrgIOContext = satIOContext->satOrgIOContext;
283 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
284 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
285 pSense = satOrgIOContext->pSense;
286 scsiCmnd = satOrgIOContext->pScsiCmnd;
289 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
291 smIORequestBody->ioCompleted = agTRUE;
292 smIORequestBody->ioStarted = agFALSE;
294 /* interal structure free */
295 smsatFreeIntIoResource( smRoot, oneDeviceData, satIntIo);
296 if( agIOStatus == OSSA_IO_SUCCESS && agIOInfoLen == 0 && agFirstDword == agNULL)
298 SM_DBG3(("smsatPacketCB: First, agIOStatus == OSSA_IO_SUCCESS, agFirstDword == agNULL, agIOInfoLen = %d\n", agIOInfoLen));
299 tdsmIOCompletedCB(smRoot,
306 else if (agIOStatus == OSSA_IO_SUCCESS && !(agIOInfoLen == 0 && agFirstDword == agNULL))
308 SM_DBG2(("smsatPacketCB: Second, agIOStatus == OSSA_IO_SUCCESS , agFirstDword %p agIOInfoLen = %d\n", agFirstDword, agIOInfoLen));
309 /*The SCSI command status is error, need to send REQUEST SENSE for getting more sense information*/
310 satNewIntIo = smsatAllocIntIoResource( smRoot,
315 if (satNewIntIo == agNULL)
317 /* memory allocation failure */
318 /* just translate the ATAPI error register to sense information */
319 smsatTranslateATAPIErrorsToSCSIErrors(
321 agFirstDword->D2H.status,
322 agFirstDword->D2H.error,
326 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext);
327 tdsmIOCompletedCB( smRoot,
330 SCSI_STAT_CHECK_CONDITION,
331 satOrgIOContext->pSmSenseData,
333 SM_DBG1(("smsatPacketCB: momory allocation fails\n"));
335 } /* end memory allocation */
337 satNewIOContext = smsatPrepareNewIO(satNewIntIo,
343 /* sends request sense to ATAPI device for acquiring sense information */
344 status = smsatRequestSenseForATAPI(smRoot,
345 &satNewIntIo->satIntSmIORequest,
346 satNewIOContext->psmDeviceHandle,
347 &satNewIntIo->satIntSmScsiXchg,
350 if (status != SM_RC_SUCCESS)
352 smsatFreeIntIoResource( smRoot,
355 /* just translate the ATAPI error register to sense information */
356 smsatTranslateATAPIErrorsToSCSIErrors(
358 agFirstDword->D2H.status,
359 agFirstDword->D2H.error,
363 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext);
364 tdsmIOCompletedCB(smRoot,
367 SCSI_STAT_CHECK_CONDITION,
368 satOrgIOContext->pSmSenseData,
370 SM_DBG1(("smsatPacketCB: failed to call satRequestSenseForATAPI()\n"));
373 else if (agIOStatus != OSSA_IO_SUCCESS )
375 SM_DBG2(("smsatPacketCB: agIOStatus != OSSA_IO_SUCCESS, status %d\n", agIOStatus));
376 smsatProcessAbnormalCompletion(
387 SM_DBG1(("smsatPacketCB: Unknown error \n"));
388 tdsmIOCompletedCB(smRoot,
396 /*****************************************************************************
397 *! \brief smsatRequestSenseForATAPICB
399 * This routine is a callback function called from smllSATACompleted().
400 * This CB routine deals with normal non-chained data I/O SATA request.
402 * \param agRoot: Handles for this instance of SAS/SATA hardware
403 * \param agIORequest: Pointer to the LL I/O request context for this I/O.
404 * \param agIOStatus: Status of completed I/O.
405 * \param agFirstDword:Pointer to the four bytes of FIS.
406 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS
408 * \param agParam: Additional info based on status.
409 * \param ioContext: Pointer to smSatIOContext_t.
413 *****************************************************************************/
415 smsatRequestSenseForATAPICB(
417 agsaIORequest_t *agIORequest,
419 agsaFisHeader_t *agFirstDword,
425 smRoot_t *smRoot = agNULL;
426 smIntRoot_t *smIntRoot = agNULL;
427 smIntContext_t *smAllShared = agNULL;
428 smIORequestBody_t *smIORequestBody;
429 smIORequestBody_t *smOrgIORequestBody;
430 smSatIOContext_t *satIOContext;
431 smSatIOContext_t *satOrgIOContext;
432 // smSatIOContext_t *satNewIOContext;
433 smSatInternalIo_t *satIntIo;
434 // smSatInternalIo_t *satNewIntIo = agNULL;
435 smDeviceData_t *oneDeviceData;
436 bit32 interruptContext;
438 smIniScsiCmnd_t *scsiCmnd;
439 smIORequest_t *smOrgIORequest;
441 SM_DBG3(("smsatRequestSenseForATAPICB: start\n"));
442 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
443 satIOContext = (smSatIOContext_t *) ioContext;
444 if (satIOContext == agNULL)
446 SM_DBG1(("smsatRequestSenseForATAPICB: satIOContext is NULL\n"));
449 satIntIo = satIOContext->satIntIoContext;
450 oneDeviceData = satIOContext->pSatDevData;
451 interruptContext = satIOContext->interruptContext;
452 smRoot = oneDeviceData->smRoot;
453 smIntRoot = (smIntRoot_t *)smRoot->smData;
454 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
455 if (satIntIo == agNULL)
457 SM_DBG5(("smsatRequestSenseForATAPICB: External smSatInternalIo_t satIntIoContext\n"));
458 satOrgIOContext = satIOContext;
459 smOrgIORequest = smIORequestBody->smIORequest;
460 scsiCmnd = satIOContext->pScsiCmnd;
464 SM_DBG5(("smsatRequestSenseForATAPICB: Internal smSatInternalIo_t satIntIoContext\n"));
465 satOrgIOContext = satIOContext->satOrgIOContext;
466 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
467 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
468 scsiCmnd = satOrgIOContext->pScsiCmnd;
471 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
472 smIORequestBody->ioCompleted = agTRUE;
473 smIORequestBody->ioStarted = agFALSE;
474 if ( (agIOStatus == OSSA_IO_SUCCESS && agIOInfoLen == 0 && agFirstDword == agNULL))
476 /* copy the request sense buffer to original IO buffer*/
479 sm_memcpy(satOrgIOContext->pSmSenseData->senseData, satIntIo->satIntDmaMem.virtPtr, SENSE_DATA_LENGTH);
481 satOrgIOContext->pSmSenseData->senseLen = SENSE_DATA_LENGTH;
482 /* interal structure free */
483 smsatFreeIntIoResource( smRoot, oneDeviceData, satIntIo);
485 /* notify the OS to complete this SRB */
486 tdsmIOCompletedCB( smRoot,
489 SCSI_STAT_CHECK_CONDITION,
490 satOrgIOContext->pSmSenseData,
493 else if (agIOStatus == OSSA_IO_UNDERFLOW )
495 /* copy the request sense buffer to original IO buffer*/
496 SM_DBG1(("smsatRequestSenseForATAPICB: OSSA_IO_UNDERFLOW agIOInfoLen = %d\n", agIOInfoLen));
497 dataLength = (bit8)(scsiCmnd->expDataLength - agIOInfoLen);
500 sm_memcpy(satOrgIOContext->pSmSenseData->senseData, satIntIo->satIntDmaMem.virtPtr, dataLength);
502 satOrgIOContext->pSmSenseData->senseLen = dataLength;
503 /* interal structure free */
504 smsatFreeIntIoResource( smRoot, oneDeviceData, satIntIo);
506 /* notify the OS to complete this SRB */
507 tdsmIOCompletedCB( smRoot,
510 SCSI_STAT_CHECK_CONDITION,
511 satOrgIOContext->pSmSenseData,
516 SM_DBG1(("smsatRequestSenseForATAPICB: failed, agIOStatus error = 0x%x agIOInfoLen = %d\n", agIOStatus, agIOInfoLen));
517 /* interal structure free */
518 smsatFreeIntIoResource( smRoot, oneDeviceData, satIntIo);
520 /* notify the OS to complete this SRB */
521 tdsmIOCompletedCB( smRoot,
528 SM_DBG3(("smsatRequestSenseForATAPICB: end\n"));
531 /*****************************************************************************
532 *! \brief smsatSetFeaturesPIOCB
534 * This routine is a callback function called from smllSATACompleted().
535 * This CB routine deals with normal non-chained data I/O SATA request.
537 * \param agRoot: Handles for this instance of SAS/SATA hardware
538 * \param agIORequest: Pointer to the LL I/O request context for this I/O.
539 * \param agIOStatus: Status of completed I/O.
540 * \param agFirstDword:Pointer to the four bytes of FIS.
541 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS
543 * \param agParam: Additional info based on status.
544 * \param ioContext: Pointer to smSatIOContext_t.
548 *****************************************************************************/
550 smsatSetFeaturesPIOCB(
552 agsaIORequest_t *agIORequest,
554 agsaFisHeader_t *agFirstDword,
560 smRoot_t *smRoot = agNULL;
561 smIntRoot_t *smIntRoot = agNULL;
562 smIntContext_t *smAllShared = agNULL;
563 smIORequestBody_t *smIORequestBody;
564 smIORequestBody_t *smOrgIORequestBody = agNULL;
565 smSatIOContext_t *satIOContext;
566 smSatIOContext_t *satOrgIOContext;
567 smSatIOContext_t *satNewIOContext;
568 smSatInternalIo_t *satIntIo;
569 smSatInternalIo_t *satNewIntIo = agNULL;
570 smDeviceData_t *oneDeviceData;
571 smIniScsiCmnd_t *scsiCmnd;
572 smIORequest_t *smOrgIORequest;
573 smDeviceHandle_t *smDeviceHandle;
574 bit32 status = SM_RC_FAILURE;
575 smIORequest_t *smIORequest;
577 SM_DBG2(("smsatSetFeaturesPIOCB: start\n"));
578 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
579 satIOContext = (smSatIOContext_t *) ioContext;
580 if (satIOContext == agNULL)
582 SM_DBG1(("smsatSetFeaturesPIOCB: satIOContext is NULL\n"));
585 satIntIo = satIOContext->satIntIoContext;
586 oneDeviceData = satIOContext->pSatDevData;
587 smDeviceHandle = satIOContext->psmDeviceHandle;
588 smRoot = oneDeviceData->smRoot;
589 smIntRoot = (smIntRoot_t *)smRoot->smData;
590 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
591 if (satIntIo == agNULL)
593 SM_DBG2(("smsatSetFeaturesPIOCB: External smSatInternalIo_t satIntIoContext\n"));
594 satOrgIOContext = satIOContext;
595 smOrgIORequest = smIORequestBody->smIORequest;
596 scsiCmnd = satIOContext->pScsiCmnd;
600 SM_DBG2(("smsatSetFeaturesPIOCB: Internal smSatInternalIo_t satIntIoContext\n"));
601 satOrgIOContext = satIOContext->satOrgIOContext;
602 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
603 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
604 scsiCmnd = satOrgIOContext->pScsiCmnd;
606 smIORequest = smOrgIORequestBody->smIORequest;
607 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
608 smIORequestBody->ioCompleted = agTRUE;
609 smIORequestBody->ioStarted = agFALSE;
610 /* interal structure free */
611 smsatFreeIntIoResource(smRoot,
614 if (smIORequest->tdData == smIORequest->smData)
616 SM_DBG1(("smsatSetFeaturesPIOCB: the same tdData and smData error!\n"));
618 /* check the agIOStatus */
619 if (agIOStatus == OSSA_IO_ABORTED ||
620 agIOStatus == OSSA_IO_NO_DEVICE ||
621 agIOStatus == OSSA_IO_PORT_IN_RESET ||
622 agIOStatus == OSSA_IO_DS_NON_OPERATIONAL ||
623 agIOStatus == OSSA_IO_DS_IN_RECOVERY ||
624 agIOStatus == OSSA_IO_DS_IN_ERROR ||
625 agIOStatus == OSSA_IO_DS_INVALID
628 SM_DBG1(("smsatSetFeaturesPIOCB: error status 0x%x\n", agIOStatus));
629 SM_DBG1(("smsatSetFeaturesPIOCB: did %d!!!\n", oneDeviceData->id));
630 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
633 /*if the ATAPI device support DMA, then enble this feature*/
634 if (oneDeviceData->satDMASupport)
636 satNewIntIo = smsatAllocIntIoResource(smRoot,
641 if (satNewIntIo == agNULL)
643 SM_DBG1(("smsatSetFeaturesPIOCB: memory allocation fails\n"));
644 /*Complete this identify packet device IO */
645 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
647 } /* end memory allocation */
649 satNewIOContext = smsatPrepareNewIO(satNewIntIo,
655 /* sends another ATA SET FEATURES based on DMA bit */
656 status = smsatSetFeaturesDMA(smRoot,
657 &satNewIntIo->satIntSmIORequest,
658 satNewIOContext->psmDeviceHandle,
659 &satNewIntIo->satIntSmScsiXchg,
662 if (status != SM_RC_SUCCESS)
664 smsatFreeIntIoResource(smRoot, oneDeviceData, satNewIntIo);
665 SM_DBG2(("satSetFeaturesPIOCB: failed to call smsatSetFeatures()\n"));
666 /*Complete this identify packet device IO */
667 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
672 /*Complete this identify packet device IO */
673 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
675 SM_DBG2(("smsatSetFeaturesPIOCB: exit, agIOStatus 0x%x\n", agIOStatus));
678 /*****************************************************************************
679 *! \brief smsatDeviceResetCB
681 * This routine is a callback function called from smllSATACompleted().
682 * This CB routine deals with normal non-chained data I/O SATA request.
684 * \param agRoot: Handles for this instance of SAS/SATA hardware
685 * \param agIORequest: Pointer to the LL I/O request context for this I/O.
686 * \param agIOStatus: Status of completed I/O.
687 * \param agFirstDword:Pointer to the four bytes of FIS.
688 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS
690 * \param agParam: Additional info based on status.
691 * \param ioContext: Pointer to smSatIOContext_t.
695 *****************************************************************************/
699 agsaIORequest_t *agIORequest,
701 agsaFisHeader_t *agFirstDword,
707 smRoot_t *smRoot = agNULL;
708 smIntRoot_t *smIntRoot = agNULL;
709 smIntContext_t *smAllShared = agNULL;
710 smIORequestBody_t *smIORequestBody;
711 smSatIOContext_t *satIOContext;
712 smSatIOContext_t *satOrgIOContext;
713 // smSatIOContext_t *satNewIOContext;
714 smSatInternalIo_t *satIntIo;
715 // smSatInternalIo_t *satNewIntIo = agNULL;
716 smDeviceData_t *oneDeviceData;
717 #ifdef TD_DEBUG_ENABLE
718 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL;
723 bit32 AbortTM = agFALSE;
724 smDeviceHandle_t *smDeviceHandle;
726 SM_DBG1(("smsatDeviceResetCB: start\n"));
727 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
728 satIOContext = (smSatIOContext_t *) ioContext;
729 satIntIo = satIOContext->satIntIoContext;
730 oneDeviceData = satIOContext->pSatDevData;
731 smRoot = oneDeviceData->smRoot;
732 smIntRoot = (smIntRoot_t *)smRoot->smData;
733 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
734 smDeviceHandle = oneDeviceData->smDevHandle;
735 if (satIntIo == agNULL)
737 SM_DBG6(("smsatDeviceResetCB: External, OS generated\n"));
738 satOrgIOContext = satIOContext;
742 SM_DBG6(("smsatDeviceResetCB: Internal, TD generated\n"));
743 satOrgIOContext = satIOContext->satOrgIOContext;
744 if (satOrgIOContext == agNULL)
746 SM_DBG6(("smsatDeviceResetCB: satOrgIOContext is NULL, wrong\n"));
751 SM_DBG6(("smsatDeviceResetCB: satOrgIOContext is NOT NULL\n"));
754 smIORequestBody->ioCompleted = agTRUE;
755 smIORequestBody->ioStarted = agFALSE;
756 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
758 SM_DBG1(("smsatDeviceResetCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
762 smIntrEventTypeTaskManagement,
764 oneDeviceData->satTmTaskTag);
765 oneDeviceData->satTmTaskTag = agNULL;
766 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
767 smsatFreeIntIoResource( smRoot,
772 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED ||
773 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION ||
774 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK ||
775 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS ||
776 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION ||
777 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED ||
778 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION ||
779 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR ||
780 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY
783 SM_DBG1(("smsatDeviceResetCB: OSSA_IO_OPEN_CNX_ERROR!!!\n"));
787 smIntrEventTypeTaskManagement,
789 oneDeviceData->satTmTaskTag);
790 oneDeviceData->satTmTaskTag = agNULL;
791 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
792 smsatFreeIntIoResource( smRoot,
797 if (agIOStatus != OSSA_IO_SUCCESS)
799 #ifdef TD_DEBUG_ENABLE
800 /* only agsaFisPioSetup_t is expected */
801 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup);
802 ataStatus = satPIOSetupHeader->status; /* ATA Status register */
803 ataError = satPIOSetupHeader->error; /* ATA Eror register */
805 SM_DBG1(("smsatDeviceResetCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError));
809 smIntrEventTypeTaskManagement,
811 oneDeviceData->satTmTaskTag);
812 oneDeviceData->satTmTaskTag = agNULL;
813 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
814 smsatFreeIntIoResource( smRoot,
820 if (satOrgIOContext->TMF == AG_ABORT_TASK)
824 if (AbortTM == agTRUE)
826 SM_DBG1(("smsatDeviceResetCB: calling satAbort!!!\n"));
827 smsatAbort(smRoot, agRoot, satOrgIOContext->satToBeAbortedIOContext);
829 oneDeviceData->satTmTaskTag = agNULL;
830 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
831 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
832 SM_DBG1(("smsatDeviceResetCB: satPendingIO %d satNCQMaxIO %d!!!\n", oneDeviceData->satPendingIO, oneDeviceData->satNCQMaxIO ));
833 SM_DBG1(("smsatDeviceResetCB: satPendingNCQIO %d satPendingNONNCQIO %d!!!\n", oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
834 smsatFreeIntIoResource( smRoot,
840 smIntrEventTypeTaskManagement,
842 oneDeviceData->satTmTaskTag);
845 SM_DBG3(("smsatDeviceResetCB: return\n"));
849 /*****************************************************************************
850 *! \brief smsatExecuteDeviceDiagnosticCB
852 * This routine is a callback function called from smllSATACompleted().
853 * This CB routine deals with normal non-chained data I/O SATA request.
855 * \param agRoot: Handles for this instance of SAS/SATA hardware
856 * \param agIORequest: Pointer to the LL I/O request context for this I/O.
857 * \param agIOStatus: Status of completed I/O.
858 * \param agFirstDword:Pointer to the four bytes of FIS.
859 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS
861 * \param agParam: Additional info based on status.
862 * \param ioContext: Pointer to smSatIOContext_t.
866 *****************************************************************************/
868 smsatExecuteDeviceDiagnosticCB(
870 agsaIORequest_t *agIORequest,
872 agsaFisHeader_t *agFirstDword,
878 smRoot_t *smRoot = agNULL;
879 smIntRoot_t *smIntRoot = agNULL;
880 smIntContext_t *smAllShared = agNULL;
881 smIORequestBody_t *smIORequestBody;
882 smSatIOContext_t *satIOContext;
883 smSatIOContext_t *satOrgIOContext;
884 // smSatIOContext_t *satNewIOContext;
885 smSatInternalIo_t *satIntIo;
886 // smSatInternalIo_t *satNewIntIo = agNULL;
887 smDeviceData_t *oneDeviceData;
889 SM_DBG6(("smsatSetFeaturesDMACB: start\n"));
890 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
891 satIOContext = (smSatIOContext_t *) ioContext;
892 satIntIo = satIOContext->satIntIoContext;
893 oneDeviceData = satIOContext->pSatDevData;
894 smRoot = oneDeviceData->smRoot;
895 smIntRoot = (smIntRoot_t *)smRoot->smData;
896 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
897 if (satIntIo == agNULL)
899 SM_DBG5(("smsatExecuteDeviceDiagnosticCB: External smSatInternalIo_t satIntIoContext\n"));
900 satOrgIOContext = satIOContext;
904 SM_DBG5(("smsatExecuteDeviceDiagnosticCB: Internal smSatInternalIo_t satIntIoContext\n"));
905 satOrgIOContext = satIOContext->satOrgIOContext;
906 if (satOrgIOContext == agNULL)
908 SM_DBG5(("smsatExecuteDeviceDiagnosticCB: satOrgIOContext is NULL\n"));
912 SM_DBG5(("smsatExecuteDeviceDiagnosticCB: satOrgIOContext is NOT NULL\n"));
915 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
916 smIORequestBody->ioCompleted = agTRUE;
917 smIORequestBody->ioStarted = agFALSE;
918 /* interal structure free */
919 smsatFreeIntIoResource(smRoot,oneDeviceData, satIntIo);
923 smsatTranslateATAPIErrorsToSCSIErrors(
928 bit16 *pSenseCodeInfo
931 if (pSenseKey == agNULL || pSenseCodeInfo == agNULL)
933 SM_DBG1(("TranslateATAErrorsToSCSIErros: pSenseKey == agNULL || pSenseCodeInfo == agNULL\n"));
936 if (bATAStatus & ERR_ATA_STATUS_MASK )
938 if(bATAError & NM_ATA_ERROR_MASK)
940 *pSenseKey = SCSI_SNSKEY_NOT_READY;
941 *pSenseCodeInfo = 0x3a00;
943 else if(bATAError & ABRT_ATA_ERROR_MASK)
945 *pSenseKey = SCSI_SNSKEY_ABORTED_COMMAND;
948 else if(bATAError & MCR_ATA_ERROR_MASK)
950 *pSenseKey = SCSI_SNSKEY_UNIT_ATTENTION;
951 *pSenseCodeInfo = 0x5a01;
953 else if(bATAError & IDNF_ATA_ERROR_MASK)
955 *pSenseKey = SCSI_SNSKEY_MEDIUM_ERROR;
956 *pSenseCodeInfo = 0x1401;
958 else if(bATAError & MC_ATA_ERROR_MASK)
960 *pSenseKey = SCSI_SNSKEY_UNIT_ATTENTION;
961 *pSenseCodeInfo = 0x2800;
963 else if(bATAError & UNC_ATA_ERROR_MASK)
966 *pSenseKey = SCSI_SNSKEY_MEDIUM_ERROR;
967 *pSenseCodeInfo = 0x1100;
971 else if(bATAError & ICRC_ATA_ERROR_MASK)
973 *pSenseKey = SCSI_SNSKEY_ABORTED_COMMAND;
974 *pSenseCodeInfo = 0x4703;
977 else if((bATAStatus & DF_ATA_STATUS_MASK))
979 *pSenseKey = SCSI_SNSKEY_HARDWARE_ERROR;
980 *pSenseCodeInfo = 0x4400;
984 SM_DBG1(("unhandled ata error: bATAStatus = 0x%x, bATAError = 0x%x\n", bATAStatus, bATAError));
989 smsatTranslateATAErrorsToSCSIErrors(
993 bit16 *pSenseCodeInfo
997 SM_DBG1(("TranslateATAErrorsToSCSIErros: bATAStatus=%d bATAError= %d \n",bATAStatus,bATAError));
999 if (pSenseKey == agNULL || pSenseCodeInfo == agNULL)
1001 SM_DBG1(("TranslateATAErrorsToSCSIErros: pSenseKey == agNULL || pSenseCodeInfo == agNULL\n"));
1005 if (bATAStatus & ERR_ATA_STATUS_MASK)
1007 if(bATAError & NM_ATA_ERROR_MASK)
1009 *pSenseKey = SCSI_SNSKEY_NOT_READY;
1010 *pSenseCodeInfo = SCSI_SNSCODE_MEDIUM_NOT_PRESENT;
1012 else if(bATAError & UNC_ATA_ERROR_MASK)
1014 *pSenseKey = SCSI_SNSKEY_MEDIUM_ERROR;
1015 *pSenseCodeInfo = SCSI_SNSCODE_UNRECOVERED_READ_ERROR;
1017 else if(bATAError & IDNF_ATA_ERROR_MASK)
1019 *pSenseKey = SCSI_SNSKEY_ILLEGAL_REQUEST;
1020 *pSenseCodeInfo = SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
1022 else if(bATAError & ABRT_ATA_ERROR_MASK)
1024 *pSenseKey = SCSI_SNSKEY_ABORTED_COMMAND;
1025 *pSenseCodeInfo = SCSI_SNSCODE_NO_ADDITIONAL_INFO;
1027 else if(bATAError & MC_ATA_ERROR_MASK)
1029 *pSenseKey = SCSI_SNSKEY_UNIT_ATTENTION;
1030 *pSenseCodeInfo = SCSI_SNSCODE_NOT_READY_TO_READY_CHANGE;
1032 else if(bATAError & MCR_ATA_ERROR_MASK)
1034 *pSenseKey = SCSI_SNSKEY_UNIT_ATTENTION;
1035 *pSenseCodeInfo = SCSI_SNSCODE_OPERATOR_MEDIUM_REMOVAL_REQUEST;
1037 else if(bATAError & ICRC_ATA_ERROR_MASK)
1039 *pSenseKey = SCSI_SNSKEY_ABORTED_COMMAND;
1040 *pSenseCodeInfo = SCSI_SNSCODE_INFORMATION_UNIT_CRC_ERROR;
1044 *pSenseKey = SCSI_SNSKEY_NO_SENSE;
1045 *pSenseCodeInfo = SCSI_SNSCODE_NO_ADDITIONAL_INFO;
1049 else if (bATAStatus & DF_ATA_STATUS_MASK) /* INTERNAL TARGET FAILURE */
1051 *pSenseKey = SCSI_SNSKEY_HARDWARE_ERROR;
1052 *pSenseCodeInfo = SCSI_SNSCODE_INTERNAL_TARGET_FAILURE;
1060 smsatNonChainedDataIOCB(
1062 agsaIORequest_t *agIORequest,
1064 agsaFisHeader_t *agFirstDword,
1070 smIORequestBody_t *smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
1071 smSatIOContext_t *satIOContext = (smSatIOContext_t *) ioContext;
1072 smSatInternalIo_t *SatIntIo = satIOContext->satIntIoContext;
1073 smDeviceData_t *oneDeviceData = satIOContext->pSatDevData;
1074 smRoot_t *smRoot = oneDeviceData->smRoot;
1075 smIntRoot_t *smIntRoot = (smIntRoot_t *)smRoot->smData;
1076 smIntContext_t *smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
1077 bit32 interruptContext = satIOContext->interruptContext;
1079 SM_DBG2(("smsatNonChainedDataIOCB: start\n"));
1081 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1083 smIORequestBody->ioCompleted = agTRUE;
1084 smIORequestBody->ioStarted = agFALSE;
1086 /* interal structure free */
1087 smsatFreeIntIoResource( smRoot,
1091 /* Process completion */
1092 if( (agIOStatus == OSSA_IO_SUCCESS) && (agIOInfoLen == 0))
1094 SM_DBG5(("smsatNonChainedDataIOCB: success\n"));
1095 SM_DBG5(("smsatNonChainedDataIOCB: success agIORequest %p\n", agIORequest));
1097 * Command was completed OK, this is the normal path.
1098 * Now call the OS-App Specific layer about this completion.
1100 tdsmIOCompletedCB( smRoot,
1101 smIORequestBody->smIORequest,
1109 SM_DBG1(("smsatNonChainedDataIOCB: calling smsatProcessAbnormalCompletion!!!\n"));
1110 /* More checking needed */
1111 smsatProcessAbnormalCompletion( agRoot,
1124 smsatChainedDataIOCB(
1126 agsaIORequest_t *agIORequest,
1128 agsaFisHeader_t *agFirstDword,
1135 smRoot_t *smRoot = agNULL;
1136 smIntRoot_t *smIntRoot = agNULL;
1137 smIntContext_t *smAllShared = agNULL;
1138 smIORequestBody_t *smIORequestBody;
1139 smIORequestBody_t *smOrgIORequestBody;
1140 smSatIOContext_t *satIOContext;
1141 smSatIOContext_t *satOrgIOContext;
1142 smSatIOContext_t *satNewIOContext;
1143 smSatInternalIo_t *satIntIo;
1144 smSatInternalIo_t *satNewIntIo = agNULL;
1145 // smDeviceData_t *satDevData;
1146 smDeviceData_t *oneDeviceData;
1147 smScsiRspSense_t *pSense;
1148 smIniScsiCmnd_t *scsiCmnd;
1149 smIORequest_t *smOrgIORequest;
1150 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
1151 bit32 ataStatus = 0;
1152 bit32 status = tiError;
1153 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
1156 SM_DBG6(("smsatChainedDataIOCB: start\n"));
1157 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
1158 satIOContext = (smSatIOContext_t *) ioContext;
1159 if (satIOContext == agNULL)
1161 SM_DBG1(("smsatChainedDataIOCB: satIOContext is NULL\n"));
1164 satIntIo = satIOContext->satIntIoContext;
1165 oneDeviceData = satIOContext->pSatDevData;
1166 hostToDevFis = satIOContext->pFis;
1167 smRoot = oneDeviceData->smRoot;
1168 smIntRoot = (smIntRoot_t *)smRoot->smData;
1169 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
1170 if (satIntIo == agNULL)
1172 SM_DBG5(("smsatChainedDataIOCB: External smSatInternalIo_t satIntIoContext\n"));
1173 satOrgIOContext = satIOContext;
1174 smOrgIORequest = smIORequestBody->smIORequest;
1175 pSense = satIOContext->pSense;
1176 scsiCmnd = satIOContext->pScsiCmnd;
1180 SM_DBG5(("smsatChainedDataIOCB: Internal smSatInternalIo_t satIntIoContext\n"));
1181 satOrgIOContext = satIOContext->satOrgIOContext;
1182 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
1183 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
1184 pSense = satOrgIOContext->pSense;
1185 scsiCmnd = satOrgIOContext->pScsiCmnd;
1187 smIORequestBody->ioCompleted = agTRUE;
1188 smIORequestBody->ioStarted = agFALSE;
1190 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
1192 SM_DBG1(("smsatChainedDataIOCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
1193 smsatSetSensePayload( pSense,
1194 SCSI_SNSKEY_NO_SENSE,
1196 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
1199 tdsmIOCompletedCB( smRoot,
1200 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1202 SCSI_STAT_CHECK_CONDITION,
1203 satOrgIOContext->pSmSenseData,
1204 satOrgIOContext->interruptContext );
1206 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1208 smsatFreeIntIoResource( smRoot,
1215 checking IO status, FIS type and error status
1217 if (agIOStatus != OSSA_IO_SUCCESS)
1219 /* agsaFisPioSetup_t or agsaFisRegDeviceToHost_t or agsaFisSetDevBits_t for read
1220 agsaFisRegDeviceToHost_t or agsaFisSetDevBits_t for write
1221 first, assumed to be Reg Device to Host FIS
1222 This is OK to just find fis type
1224 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
1225 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
1227 if( (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS) &&
1228 (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) &&
1229 (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS)
1232 SM_DBG1(("smsatChainedDataIOCB: FAILED, Wrong FIS type 0x%x!!!\n", statDevToHostFisHeader->fisType));
1236 if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
1237 (ataStatus & DF_ATA_STATUS_MASK)
1240 SM_DBG1(("smsatChainedDataIOCB: FAILED, error status and command 0x%x!!!\n", hostToDevFis->h.command));
1243 /* the function below handles abort case */
1244 smsatDelayedProcessAbnormalCompletion(agRoot,
1252 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1253 smsatFreeIntIoResource( smRoot,
1257 } /* end of error */
1259 switch (hostToDevFis->h.command)
1261 case SAT_READ_DMA: /* fall through */
1262 case SAT_READ_SECTORS: /* fall through */
1263 case SAT_READ_DMA_EXT: /* fall through */
1264 case SAT_READ_SECTORS_EXT: /* fall through */
1265 case SAT_READ_FPDMA_QUEUED: /* fall through */
1266 case SAT_WRITE_DMA: /* fall through */
1267 case SAT_WRITE_SECTORS:/* fall through */
1268 case SAT_WRITE_DMA_FUA_EXT: /* fall through */
1269 case SAT_WRITE_DMA_EXT: /* fall through */
1270 case SAT_WRITE_SECTORS_EXT: /* fall through */
1271 case SAT_WRITE_FPDMA_QUEUED:
1273 SM_DBG5(("smsatChainedDataIOCB: READ/WRITE success case\n"));
1275 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1277 /* done with internally genereated SAT_SMART_RETURN_STATUS */
1278 smsatFreeIntIoResource( smRoot,
1281 /* let's loop till TL */
1285 if (loopnum == 0) done
1287 (satOrgIOContext->LoopNum)--;
1288 if (satOrgIOContext->LoopNum == 0)
1290 /* done with read */
1291 tdsmIOCompletedCB( smRoot,
1292 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1296 satOrgIOContext->interruptContext );
1300 /* don't need to allocate payload memory here. Use the one allocated by OS layer */
1303 satNewIntIo = smsatAllocIntIoResource( smRoot,
1308 if (satNewIntIo == agNULL)
1310 tdsmIOCompletedCB( smRoot,
1311 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1315 satOrgIOContext->interruptContext );
1317 SM_DBG1(("smsatChainedDataIOCB: momory allocation fails!!!\n"));
1319 } /* end of memory allocation failure */
1322 * Need to initialize all the fields within satIOContext
1325 satNewIOContext = smsatPrepareNewIO(
1333 /* sending another ATA command */
1334 switch (scsiCmnd->cdb[0])
1336 case SCSIOPC_READ_6:
1337 /* no loop should occur with READ6 since it fits in one ATA command */
1339 case SCSIOPC_READ_10: /* fall through */
1340 case SCSIOPC_READ_12: /* fall through */
1341 case SCSIOPC_READ_16: /* fall through */
1342 status = smsatRead_1( smRoot,
1343 &satNewIntIo->satIntSmIORequest,
1344 satNewIOContext->psmDeviceHandle,
1345 &satNewIntIo->satIntSmScsiXchg,
1348 case SCSIOPC_WRITE_6:
1349 /* no loop should occur with WRITE6 since it fits in one ATA command */
1351 case SCSIOPC_WRITE_10: /* fall through */
1352 case SCSIOPC_WRITE_12: /* fall through */
1353 case SCSIOPC_WRITE_16: /* fall through */
1354 status = smsatWrite_1( smRoot,
1355 &satNewIntIo->satIntSmIORequest,
1356 satNewIOContext->psmDeviceHandle,
1357 &satNewIntIo->satIntSmScsiXchg,
1361 SM_DBG1(("smsatChainedDataIOCB: success but default case scsi cmd 0x%x ata cmd 0x%x!!!\n",scsiCmnd->cdb[0], hostToDevFis->h.command));
1368 if (status != SM_RC_SUCCESS)
1370 smsatFreeIntIoResource( smRoot,
1373 tdsmIOCompletedCB( smRoot,
1374 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1378 satOrgIOContext->interruptContext );
1379 SM_DBG1(("smsatChainedDataIOCB: calling satRead10_1 fails!!!\n"));
1387 SM_DBG1(("smsatChainedDataIOCB: success but default case command 0x%x!!!\n",hostToDevFis->h.command));
1388 tdsmIOCompletedCB( smRoot,
1389 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1393 satOrgIOContext->interruptContext );
1395 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1397 smsatFreeIntIoResource( smRoot,
1409 smsatNonChainedVerifyCB(
1411 agsaIORequest_t *agIORequest,
1413 agsaFisHeader_t *agFirstDword,
1415 agsaFrameHandle_t agFrameHandle,
1420 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
1421 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
1422 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
1423 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
1424 smRoot_t *smRoot = agNULL;
1425 smIntRoot_t *smIntRoot = agNULL;
1426 smIntContext_t *smAllShared = agNULL;
1427 smIORequestBody_t *smIORequestBody;
1428 smIORequestBody_t *smOrgIORequestBody;
1429 smSatIOContext_t *satIOContext;
1430 smSatIOContext_t *satOrgIOContext;
1431 smSatInternalIo_t *satIntIo;
1432 // satDeviceData_t *satDevData;
1433 smDeviceData_t *oneDeviceData;
1434 smScsiRspSense_t *pSense;
1435 smIORequest_t *smOrgIORequest;
1436 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
1437 bit32 ataStatus = 0;
1438 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
1440 SM_DBG2(("smsatNonChainedVerifyCB: start\n"));
1441 SM_DBG5(("smsatNonChainedVerifyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
1443 /* internally generate smIOContext */
1444 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
1445 satIOContext = (smSatIOContext_t *) ioContext;
1446 satIntIo = satIOContext->satIntIoContext;
1447 oneDeviceData = satIOContext->pSatDevData;
1448 hostToDevFis = satIOContext->pFis;
1449 smRoot = oneDeviceData->smRoot;
1450 smIntRoot = (smIntRoot_t *)smRoot->smData;
1451 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
1452 if (satIntIo == agNULL)
1454 SM_DBG4(("smsatNonChainedVerifyCB: External smSatInternalIo_t satIntIoContext\n"));
1455 satOrgIOContext = satIOContext;
1456 smOrgIORequest = smIORequestBody->smIORequest;
1457 pSense = satIOContext->pSense;
1461 SM_DBG4(("smsatNonChainedVerifyCB: Internal smSatInternalIo_t satIntIoContext\n"));
1462 satOrgIOContext = satIOContext->satOrgIOContext;
1463 if (satOrgIOContext == agNULL)
1465 SM_DBG4(("smsatNonChainedVerifyCB: satOrgIOContext is NULL, wrong\n"));
1470 SM_DBG4(("smsatNonChainedVerifyCB: satOrgIOContext is NOT NULL\n"));
1472 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
1473 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
1474 pSense = satOrgIOContext->pSense;
1477 smIORequestBody->ioCompleted = agTRUE;
1478 smIORequestBody->ioStarted = agFALSE;
1479 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
1481 SM_DBG1(("smsatNonChainedVerifyCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
1482 smsatSetSensePayload( pSense,
1483 SCSI_SNSKEY_NO_SENSE,
1485 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
1487 tdsmIOCompletedCB( smRoot,
1488 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1490 SCSI_STAT_CHECK_CONDITION,
1491 satOrgIOContext->pSmSenseData,
1492 satOrgIOContext->interruptContext );
1493 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1495 smsatFreeIntIoResource( smRoot,
1500 if (agIOStatus != OSSA_IO_SUCCESS)
1502 /* only agsaFisRegDeviceToHost_t is expected */
1503 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
1504 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
1507 if( agIOStatus != OSSA_IO_SUCCESS)
1509 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) ||
1510 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
1514 if( agIOStatus != OSSA_IO_SUCCESS)
1516 SM_DBG1(("smsatNonChainedVerifyCB: FAILED, NOT IO_SUCCESS!!!\n"));
1518 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
1520 SM_DBG1(("smsatNonChainedVerifyCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
1522 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
1523 (ataStatus & DF_ATA_STATUS_MASK)
1526 SM_DBG1(("smsatNonChainedVerifyCB: FAILED, FAILED, error status!!!\n"));
1529 /* Process abort case */
1530 if (agIOStatus == OSSA_IO_ABORTED)
1532 smsatProcessAbort(smRoot,
1537 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1539 smsatFreeIntIoResource( smRoot,
1546 switch (hostToDevFis->h.command)
1548 case SAT_READ_VERIFY_SECTORS:
1549 SM_DBG1(("smsatNonChainedVerifyCB: SAT_READ_VERIFY_SECTORS!!!\n"));
1551 case SAT_READ_VERIFY_SECTORS_EXT:
1552 SM_DBG1(("smsatNonChainedVerifyCB: SAT_READ_VERIFY_SECTORS_EXT!!!\n"));
1555 SM_DBG1(("smsatNonChainedVerifyCB: error default case command 0x%x!!!\n", hostToDevFis->h.command));
1559 smsatSetSensePayload( pSense,
1560 SCSI_SNSKEY_NO_SENSE,
1562 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
1565 tdsmIOCompletedCB( smRoot,
1566 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1568 SCSI_STAT_CHECK_CONDITION,
1569 satOrgIOContext->pSmSenseData,
1570 satOrgIOContext->interruptContext );
1572 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1574 smsatFreeIntIoResource( smRoot,
1578 } /* end error checking */
1581 /* process success from this point on */
1582 switch (hostToDevFis->h.command)
1584 case SAT_READ_VERIFY_SECTORS: /* fall through */
1585 case SAT_READ_VERIFY_SECTORS_EXT:
1586 SM_DBG5(("smsatNonChainedVerifyCB: SAT_WRITE_DMA_EXT success \n"));
1588 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1590 smsatFreeIntIoResource( smRoot,
1594 tdsmIOCompletedCB( smRoot,
1599 satOrgIOContext->interruptContext);
1602 SM_DBG1(("smsatNonChainedVerifyCB: success but error default case command 0x%x!!!\n", hostToDevFis->h.command));
1604 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1606 smsatFreeIntIoResource( smRoot,
1610 smsatSetSensePayload( pSense,
1611 SCSI_SNSKEY_NO_SENSE,
1613 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
1616 tdsmIOCompletedCB( smRoot,
1617 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1619 SCSI_STAT_CHECK_CONDITION,
1620 satOrgIOContext->pSmSenseData,
1621 satOrgIOContext->interruptContext );
1630 smsatChainedVerifyCB(
1632 agsaIORequest_t *agIORequest,
1634 agsaFisHeader_t *agFirstDword,
1636 agsaFrameHandle_t agFrameHandle,
1641 smRoot_t *smRoot = agNULL;
1642 smIntRoot_t *smIntRoot = agNULL;
1643 smIntContext_t *smAllShared = agNULL;
1644 smIORequestBody_t *smIORequestBody;
1645 smIORequestBody_t *smOrgIORequestBody;
1646 smSatIOContext_t *satIOContext;
1647 smSatIOContext_t *satOrgIOContext;
1648 smSatIOContext_t *satNewIOContext;
1649 smSatInternalIo_t *satIntIo;
1650 smSatInternalIo_t *satNewIntIo = agNULL;
1651 smDeviceData_t *oneDeviceData;
1652 smScsiRspSense_t *pSense;
1653 smIniScsiCmnd_t *scsiCmnd;
1654 smIORequest_t *smOrgIORequest;
1655 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
1656 bit32 ataStatus = 0;
1657 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
1658 bit32 status = tiError;
1661 SM_DBG2(("smsatChainedVerifyCB: start\n"));
1662 SM_DBG5(("smsatChainedVerifyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
1664 /* internally generate smIOContext */
1665 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
1666 satIOContext = (smSatIOContext_t *) ioContext;
1667 satIntIo = satIOContext->satIntIoContext;
1668 oneDeviceData = satIOContext->pSatDevData;
1669 hostToDevFis = satIOContext->pFis;
1670 smRoot = oneDeviceData->smRoot;
1671 smIntRoot = (smIntRoot_t *)smRoot->smData;
1672 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
1674 if (satIntIo == agNULL)
1676 SM_DBG4(("smsatChainedVerifyCB: External smSatInternalIo_t satIntIoContext\n"));
1677 satOrgIOContext = satIOContext;
1678 smOrgIORequest = smIORequestBody->smIORequest;
1679 pSense = satIOContext->pSense;
1680 scsiCmnd = satIOContext->pScsiCmnd;
1684 SM_DBG4(("smsatChainedVerifyCB: Internal smSatInternalIo_t satIntIoContext\n"));
1685 satOrgIOContext = satIOContext->satOrgIOContext;
1686 if (satOrgIOContext == agNULL)
1688 SM_DBG4(("smsatChainedVerifyCB: satOrgIOContext is NULL, wrong\n"));
1693 SM_DBG4(("smsatChainedVerifyCB: satOrgIOContext is NOT NULL\n"));
1695 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
1696 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
1697 pSense = satOrgIOContext->pSense;
1698 scsiCmnd = satOrgIOContext->pScsiCmnd;
1701 smIORequestBody->ioCompleted = agTRUE;
1702 smIORequestBody->ioStarted = agFALSE;
1704 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
1706 SM_DBG1(("smsatChainedVerifyCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
1707 smsatSetSensePayload( pSense,
1708 SCSI_SNSKEY_NO_SENSE,
1710 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
1713 tdsmIOCompletedCB( smRoot,
1714 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1716 SCSI_STAT_CHECK_CONDITION,
1717 satOrgIOContext->pSmSenseData,
1718 satOrgIOContext->interruptContext );
1720 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1722 smsatFreeIntIoResource( smRoot,
1728 if (agIOStatus != OSSA_IO_SUCCESS)
1730 /* only agsaFisRegDeviceToHost_t is expected */
1731 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
1732 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
1735 if( agIOStatus != OSSA_IO_SUCCESS)
1737 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) ||
1738 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
1742 if( agIOStatus != OSSA_IO_SUCCESS)
1744 SM_DBG1(("smsatChainedVerifyCB: FAILED, NOT IO_SUCCESS!!!\n"));
1746 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
1748 SM_DBG1(("smsatChainedVerifyCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
1750 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
1751 (ataStatus & DF_ATA_STATUS_MASK)
1754 SM_DBG1(("smsatChainedVerifyCB: FAILED, FAILED, error status!!!\n"));
1757 /* Process abort case */
1758 if (agIOStatus == OSSA_IO_ABORTED)
1760 smsatProcessAbort(smRoot,
1765 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1767 smsatFreeIntIoResource( smRoot,
1774 switch (hostToDevFis->h.command)
1776 case SAT_READ_VERIFY_SECTORS:
1777 SM_DBG1(("smsatChainedVerifyCB: SAT_READ_VERIFY_SECTORS!!!\n"));
1779 case SAT_READ_VERIFY_SECTORS_EXT:
1780 SM_DBG1(("smsatChainedVerifyCB: SAT_READ_VERIFY_SECTORS_EXT!!!\n"));
1783 SM_DBG1(("smsatChainedVerifyCB: error default case command 0x%x!!!\n", hostToDevFis->h.command));
1787 smsatSetSensePayload( pSense,
1788 SCSI_SNSKEY_NO_SENSE,
1790 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
1793 tdsmIOCompletedCB( smRoot,
1794 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1796 SCSI_STAT_CHECK_CONDITION,
1797 satOrgIOContext->pSmSenseData,
1798 satOrgIOContext->interruptContext );
1800 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1802 smsatFreeIntIoResource( smRoot,
1806 } /* end error checking */
1809 /* process success from this point on */
1810 switch (hostToDevFis->h.command)
1812 case SAT_READ_VERIFY_SECTORS: /* fall through */
1813 case SAT_READ_VERIFY_SECTORS_EXT:
1814 SM_DBG5(("smsatChainedVerifyCB: SAT_WRITE_DMA_EXT success \n"));
1816 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1818 smsatFreeIntIoResource( smRoot,
1822 /* let's loop till TL */
1826 if (loopnum == 0) done
1828 (satOrgIOContext->LoopNum)--;
1829 if (satOrgIOContext->LoopNum == 0)
1832 done with write and verify
1834 tdsmIOCompletedCB( smRoot,
1835 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1839 satOrgIOContext->interruptContext );
1843 if (satOrgIOContext->superIOFlag)
1845 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength;
1849 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength;
1852 satNewIntIo = smsatAllocIntIoResource( smRoot,
1857 if (satNewIntIo == agNULL)
1859 tdsmIOCompletedCB( smRoot,
1860 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1864 satOrgIOContext->interruptContext );
1866 SM_DBG1(("smsatChainedVerifyCB: momory allocation fails!!!\n"));
1868 } /* end of memory allocation failure */
1871 * Need to initialize all the fields within satIOContext
1874 satNewIOContext = smsatPrepareNewIO(
1881 status = smsatChainedVerify(smRoot,
1882 &satNewIntIo->satIntSmIORequest,
1883 satNewIOContext->psmDeviceHandle,
1884 &satNewIntIo->satIntSmScsiXchg,
1887 if (status != SM_RC_SUCCESS)
1889 smsatFreeIntIoResource( smRoot,
1892 tdsmIOCompletedCB( smRoot,
1893 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1897 satOrgIOContext->interruptContext );
1898 SM_DBG1(("smsatChainedVerifyCB: calling satChainedVerify fails!!!\n"));
1904 SM_DBG1(("smsatChainedVerifyCB: success but error default case command 0x%x!!!\n", hostToDevFis->h.command));
1906 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
1908 smsatFreeIntIoResource( smRoot,
1912 smsatSetSensePayload( pSense,
1913 SCSI_SNSKEY_NO_SENSE,
1915 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
1918 tdsmIOCompletedCB( smRoot,
1919 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
1921 SCSI_STAT_CHECK_CONDITION,
1922 satOrgIOContext->pSmSenseData,
1923 satOrgIOContext->interruptContext );
1932 smsatTestUnitReadyCB(
1934 agsaIORequest_t *agIORequest,
1936 agsaFisHeader_t *agFirstDword,
1938 agsaFrameHandle_t agFrameHandle,
1943 In the process of TestUnitReady
1944 Process SAT_GET_MEDIA_STATUS
1945 Process SAT_CHECK_POWER_MODE
1947 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
1948 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
1949 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
1950 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
1951 smRoot_t *smRoot = agNULL;
1952 smIntRoot_t *smIntRoot = agNULL;
1953 smIntContext_t *smAllShared = agNULL;
1954 smIORequestBody_t *smIORequestBody;
1955 smIORequestBody_t *smOrgIORequestBody;
1956 smSatIOContext_t *satIOContext;
1957 smSatIOContext_t *satOrgIOContext;
1958 smSatIOContext_t *satNewIOContext;
1959 smSatInternalIo_t *satIntIo;
1960 smSatInternalIo_t *satNewIntIo = agNULL;
1961 // satDeviceData_t *satDevData;
1962 smDeviceData_t *oneDeviceData;
1964 smScsiRspSense_t *pSense;
1965 smIniScsiCmnd_t *scsiCmnd;
1966 smIORequest_t *smOrgIORequest;
1968 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
1969 bit32 ataStatus = 0;
1973 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
1975 SM_DBG2(("smsatTestUnitReadyCB: start\n"));
1976 SM_DBG6(("smsatTestUnitReadyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
1978 /* internally generate smIOContext */
1979 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
1980 satIOContext = (smSatIOContext_t *) ioContext;
1981 satIntIo = satIOContext->satIntIoContext;
1982 oneDeviceData = satIOContext->pSatDevData;
1983 hostToDevFis = satIOContext->pFis;
1984 smRoot = oneDeviceData->smRoot;
1985 smIntRoot = (smIntRoot_t *)smRoot->smData;
1986 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
1988 if (satIntIo == agNULL)
1990 SM_DBG5(("smsatTestUnitReadyCB: no internal smSatInternalIo_t satIntIoContext\n"));
1991 pSense = satIOContext->pSense;
1992 scsiCmnd = satIOContext->pScsiCmnd;
1993 satOrgIOContext = satIOContext;
1994 smOrgIORequest = smIORequestBody->smIORequest;
1998 SM_DBG5(("smsatTestUnitReadyCB: yes internal smSatInternalIo_t satIntIoContext\n"));
2000 /* orginal smIOContext */
2001 smOrgIORequest = (smIORequest_t *)satIOContext->satIntIoContext->satOrgSmIORequest;
2002 smOrgIORequestBody = (smIORequestBody_t *)smOrgIORequest->tdData;
2003 satOrgIOContext = &(smOrgIORequestBody->transport.SATA.satIOContext);
2005 pSense = satOrgIOContext->pSense;
2006 scsiCmnd = satOrgIOContext->pScsiCmnd;
2009 smIORequestBody->ioCompleted = agTRUE;
2010 smIORequestBody->ioStarted = agFALSE;
2012 if (agIOStatus == OSSA_IO_ABORTED)
2014 tdsmIOCompletedCB( smRoot,
2019 satIOContext->interruptContext);
2021 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2023 smsatFreeIntIoResource( smRoot,
2030 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
2032 SM_DBG1(("smsatTestUnitReadyCB: agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
2033 smsatSetSensePayload( pSense,
2034 SCSI_SNSKEY_NOT_READY,
2036 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE,
2039 tdsmIOCompletedCB( smRoot,
2040 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2042 SCSI_STAT_CHECK_CONDITION,
2043 satOrgIOContext->pSmSenseData,
2044 satOrgIOContext->interruptContext );
2046 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2048 smsatFreeIntIoResource( smRoot,
2055 HW checks an error for us and the results is agIOStatus
2057 if (agIOStatus != OSSA_IO_SUCCESS)
2059 /* only agsaFisRegDeviceToHost_t is expected */
2060 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
2061 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
2062 ataError = statDevToHostFisHeader->error; /* ATA Eror register */
2063 if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
2065 SM_DBG1(("smsatTestUnitReadyCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
2067 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
2068 (ataStatus & DF_ATA_STATUS_MASK)
2071 SM_DBG1(("smsatTestUnitReadyCB: FAILED, FAILED, error status!!!\n"));
2074 /* Process abort case */
2075 if (agIOStatus == OSSA_IO_ABORTED)
2077 smsatProcessAbort(smRoot,
2082 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2084 smsatFreeIntIoResource( smRoot,
2090 switch (hostToDevFis->h.command)
2092 case SAT_GET_MEDIA_STATUS:
2093 SM_DBG1(("smsatTestUnitReadyCB: SAT_GET_MEDIA_STATUS failed!!! \n"));
2095 /* checking NM bit */
2096 if (ataError & SCSI_NM_MASK)
2098 smsatSetSensePayload( pSense,
2099 SCSI_SNSKEY_NOT_READY,
2101 SCSI_SNSCODE_MEDIUM_NOT_PRESENT,
2106 smsatSetSensePayload( pSense,
2107 SCSI_SNSKEY_NOT_READY,
2109 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE,
2113 tdsmIOCompletedCB( smRoot,
2114 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2116 SCSI_STAT_CHECK_CONDITION,
2117 satOrgIOContext->pSmSenseData,
2118 satOrgIOContext->interruptContext );
2120 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2122 smsatFreeIntIoResource( smRoot,
2126 case SAT_CHECK_POWER_MODE:
2127 SM_DBG1(("smsatTestUnitReadyCB: SAT_CHECK_POWER_MODE failed!!! \n"));
2128 smsatSetSensePayload( pSense,
2129 SCSI_SNSKEY_NOT_READY,
2131 SCSI_SNSCODE_LOGICAL_UNIT_DOES_NOT_RESPOND_TO_SELECTION,
2134 tdsmIOCompletedCB( smRoot,
2135 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2137 SCSI_STAT_CHECK_CONDITION,
2138 satOrgIOContext->pSmSenseData,
2139 satOrgIOContext->interruptContext );
2141 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2143 smsatFreeIntIoResource( smRoot,
2148 SM_DBG1(("smsatTestUnitReadyCB: default failed command %d!!!\n", hostToDevFis->h.command));
2150 smsatSetSensePayload( pSense,
2151 SCSI_SNSKEY_NOT_READY,
2153 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE,
2156 tdsmIOCompletedCB( smRoot,
2157 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2159 SCSI_STAT_CHECK_CONDITION,
2160 satOrgIOContext->pSmSenseData,
2161 satOrgIOContext->interruptContext );
2163 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2165 smsatFreeIntIoResource( smRoot,
2174 /* ATA command completes sucessfully */
2175 switch (hostToDevFis->h.command)
2177 case SAT_GET_MEDIA_STATUS:
2179 SM_DBG5(("smsatTestUnitReadyCB: SAT_GET_MEDIA_STATUS success\n"));
2181 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2183 smsatFreeIntIoResource( smRoot,
2187 satNewIntIo = smsatAllocIntIoResource( smRoot,
2192 if (satNewIntIo == agNULL)
2194 smsatSetSensePayload( pSense,
2195 SCSI_SNSKEY_NOT_READY,
2197 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE,
2200 tdsmIOCompletedCB( smRoot,
2203 SCSI_STAT_CHECK_CONDITION,
2204 satOrgIOContext->pSmSenseData,
2205 satOrgIOContext->interruptContext );
2207 SM_DBG1(("smsatTestUnitReadyCB: momory allocation fails!!!\n"));
2212 * Need to initialize all the fields within satIOContext
2215 satNewIOContext = smsatPrepareNewIO(
2223 /* sends SAT_CHECK_POWER_MODE */
2224 status = smsatTestUnitReady_1( smRoot,
2225 &satNewIntIo->satIntSmIORequest,
2226 satNewIOContext->psmDeviceHandle,
2227 &satNewIntIo->satIntSmScsiXchg,
2230 if (status != SM_RC_SUCCESS)
2232 /* sending SAT_CHECK_POWER_MODE fails */
2233 smsatFreeIntIoResource( smRoot,
2236 smsatSetSensePayload( pSense,
2237 SCSI_SNSKEY_NOT_READY,
2239 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE,
2242 tdsmIOCompletedCB( smRoot,
2245 SCSI_STAT_CHECK_CONDITION,
2246 satOrgIOContext->pSmSenseData,
2247 satOrgIOContext->interruptContext );
2249 SM_DBG1(("smsatTestUnitReadyCB: calling satTestUnitReady_1 fails!!!\n"));
2254 case SAT_CHECK_POWER_MODE:
2255 SM_DBG5(("smsatTestUnitReadyCB: SAT_CHECK_POWER_MODE success\n"));
2258 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2260 smsatFreeIntIoResource( smRoot,
2264 /* returns good status */
2265 tdsmIOCompletedCB( smRoot,
2270 satOrgIOContext->interruptContext );
2274 SM_DBG1(("smsatTestUnitReadyCB: default success command %d!!!\n", hostToDevFis->h.command));
2275 smsatSetSensePayload( pSense,
2276 SCSI_SNSKEY_NOT_READY,
2278 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE,
2281 tdsmIOCompletedCB( smRoot,
2282 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2284 SCSI_STAT_CHECK_CONDITION,
2285 satOrgIOContext->pSmSenseData,
2286 satOrgIOContext->interruptContext );
2289 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2291 smsatFreeIntIoResource( smRoot,
2301 smsatRequestSenseCB(
2303 agsaIORequest_t *agIORequest,
2305 agsaFisHeader_t *agFirstDword,
2311 /* ATA Vol 1, p299 SAT_SMART_RETURN_STATUS */
2313 if threshold exceeds, return SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE
2314 else call satRequestSense_1 to send CHECK_POWER_MODE
2317 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
2318 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
2319 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
2320 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2321 smRoot_t *smRoot = agNULL;
2322 smIntRoot_t *smIntRoot = agNULL;
2323 smIntContext_t *smAllShared = agNULL;
2324 smIORequestBody_t *smIORequestBody;
2325 smIORequestBody_t *smOrgIORequestBody;
2326 smSatIOContext_t *satIOContext;
2327 smSatIOContext_t *satOrgIOContext;
2328 smSatIOContext_t *satNewIOContext;
2329 smSatInternalIo_t *satIntIo;
2330 smSatInternalIo_t *satNewIntIo = agNULL;
2331 // satDeviceData_t *satDevData;
2332 smDeviceData_t *oneDeviceData;
2333 smScsiRspSense_t *pSense;
2334 smIniScsiCmnd_t *scsiCmnd;
2335 smIORequest_t *smOrgIORequest;
2336 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
2337 bit32 ataStatus = 0;
2339 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
2340 agsaFisRegD2HData_t statDevToHostFisData;
2341 bit32 allocationLen = 0;
2343 bit8 *pDataBuffer = agNULL;
2345 SM_DBG2(("smsatRequestSenseCB: start\n"));
2346 SM_DBG4(("smsatRequestSenseCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
2348 /* internally generate smIOContext */
2349 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
2350 satIOContext = (smSatIOContext_t *) ioContext;
2351 satIntIo = satIOContext->satIntIoContext;
2352 oneDeviceData = satIOContext->pSatDevData;
2353 hostToDevFis = satIOContext->pFis;
2354 smRoot = oneDeviceData->smRoot;
2355 smIntRoot = (smIntRoot_t *)smRoot->smData;
2356 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
2359 if (satIntIo == agNULL)
2361 SM_DBG4(("smsatRequestSenseCB: External smSatInternalIo_t satIntIoContext\n"));
2362 satOrgIOContext = satIOContext;
2363 smOrgIORequest = smIORequestBody->smIORequest;
2364 if (satOrgIOContext->superIOFlag)
2366 pDataBuffer = (bit8 *)(((tiSuperScsiInitiatorRequest_t *)satOrgIOContext->smScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense;
2370 pDataBuffer = (bit8 *)(((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense;
2373 scsiCmnd = satOrgIOContext->pScsiCmnd;
2374 pSense = satOrgIOContext->pSense;
2378 SM_DBG4(("smsatRequestSenseCB: Internal smSatInternalIo_t satIntIoContext\n"));
2379 satOrgIOContext = satIOContext->satOrgIOContext;
2380 if (satOrgIOContext == agNULL)
2382 SM_DBG4(("smsatRequestSenseCB: satOrgIOContext is NULL, wrong\n"));
2387 SM_DBG4(("smsatRequestSenseCB: satOrgIOContext is NOT NULL\n"));
2389 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
2390 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
2392 if (satOrgIOContext->superIOFlag)
2394 pDataBuffer = (bit8 *)(((tiSuperScsiInitiatorRequest_t *)satOrgIOContext->smScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense;
2398 pDataBuffer = (bit8 *)(((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense;
2401 scsiCmnd = satOrgIOContext->pScsiCmnd;
2402 pSense = satOrgIOContext->pSense;
2405 smIORequestBody->ioCompleted = agTRUE;
2406 smIORequestBody->ioStarted = agFALSE;
2408 SM_DBG4(("smsatRequestSenseCB: fis command 0x%x\n", hostToDevFis->h.command));
2410 allocationLen = scsiCmnd->cdb[4];
2411 allocationLen = MIN(allocationLen, scsiCmnd->expDataLength);
2412 SM_DBG1(("smsatRequestSenseCB: allocationLen in CDB %d 0x%x!!!\n", allocationLen,allocationLen));
2414 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
2416 SM_DBG1(("smsatRequestSenseCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
2423 satOrgIOContext->interruptContext
2426 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2428 smsatFreeIntIoResource( smRoot,
2436 checking IO status, FIS type and error status
2438 if (agIOStatus != OSSA_IO_SUCCESS)
2440 /* only agsaFisRegDeviceToHost_t is expected */
2441 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
2442 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
2445 if( statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
2447 if (hostToDevFis->h.command == SAT_SMART && hostToDevFis->h.features == SAT_SMART_RETURN_STATUS)
2449 SM_DBG1(("smsatRequestSenseCB: FAILED, Wrong FIS type 0x%x and SAT_SMART_RETURN_STATU!!!\n", statDevToHostFisHeader->fisType));
2453 SM_DBG1(("smsatRequestSenseCB: FAILED, Wrong FIS type 0x%x and SAT_CHECK_POWER_MODE!!!\n",statDevToHostFisHeader->fisType));
2458 if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
2459 (ataStatus & DF_ATA_STATUS_MASK)
2462 if (hostToDevFis->h.command == SAT_SMART && hostToDevFis->h.features == SAT_SMART_RETURN_STATUS)
2464 SM_DBG1(("smsatRequestSenseCB: FAILED, error status and SAT_SMART_RETURN_STATU!!!\n"));
2468 SM_DBG1(("smsatRequestSenseCB: FAILED, error status and SAT_CHECK_POWER_MODE!!!\n"));
2472 /* Process abort case */
2473 if (agIOStatus == OSSA_IO_ABORTED)
2475 smsatProcessAbort(smRoot,
2479 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2481 smsatFreeIntIoResource( smRoot,
2486 if (hostToDevFis->h.command == SAT_SMART && hostToDevFis->h.features == SAT_SMART_RETURN_STATUS)
2488 /* report using the original tiIOrequst */
2489 /* failed during sending SMART RETURN STATUS */
2490 smsatSetSensePayload( pSense,
2491 SCSI_SNSKEY_NO_SENSE,
2493 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE,
2495 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen));
2496 if (SENSE_DATA_LENGTH < allocationLen)
2499 tdsmIOCompletedCB( smRoot,
2500 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
2502 allocationLen - SENSE_DATA_LENGTH,
2504 satOrgIOContext->interruptContext );
2508 tdsmIOCompletedCB( smRoot,
2509 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
2513 satOrgIOContext->interruptContext );
2518 /* report using the original tiIOrequst */
2519 /* failed during sending SAT_CHECK_POWER_MODE */
2520 smsatSetSensePayload( pSense,
2521 SCSI_SNSKEY_NO_SENSE,
2523 SCSI_SNSCODE_LOW_POWER_CONDITION_ON,
2525 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen));
2527 if (SENSE_DATA_LENGTH < allocationLen)
2530 tdsmIOCompletedCB( smRoot,
2531 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
2533 allocationLen - SENSE_DATA_LENGTH,
2535 satOrgIOContext->interruptContext );
2539 tdsmIOCompletedCB( smRoot,
2540 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
2544 satOrgIOContext->interruptContext );
2549 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2551 smsatFreeIntIoResource( smRoot,
2557 saFrameReadBlock(agRoot, agParam, 0, &statDevToHostFisData, sizeof(agsaFisRegD2HData_t));
2559 switch (hostToDevFis->h.command)
2562 SM_DBG4(("smsatRequestSenseCB: SAT_SMART_RETURN_STATUS case\n"));
2563 if (statDevToHostFisData.lbaMid == 0xF4 || statDevToHostFisData.lbaHigh == 0x2C)
2565 /* threshold exceeds */
2566 SM_DBG1(("smsatRequestSenseCB: threshold exceeds!!!\n"));
2569 /* report using the original tiIOrequst */
2570 /* failed during sending SMART RETURN STATUS */
2571 smsatSetSensePayload( pSense,
2572 SCSI_SNSKEY_NO_SENSE,
2574 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE,
2576 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen));
2578 if (SENSE_DATA_LENGTH < allocationLen)
2581 tdsmIOCompletedCB( smRoot,
2582 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2584 allocationLen - SENSE_DATA_LENGTH,
2586 satOrgIOContext->interruptContext );
2590 tdsmIOCompletedCB( smRoot,
2591 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2595 satOrgIOContext->interruptContext );
2599 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2601 smsatFreeIntIoResource( smRoot,
2608 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2610 /* done with internally genereated SAT_SMART_RETURN_STATUS */
2611 smsatFreeIntIoResource( smRoot,
2615 /* at this point, successful SMART_RETURN_STATUS
2616 xmit SAT_CHECK_POWER_MODE
2618 if (satOrgIOContext->superIOFlag)
2620 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength;
2624 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength;
2627 satNewIntIo = smsatAllocIntIoResource( smRoot,
2632 if (satNewIntIo == agNULL)
2634 /* failed as a part of sending SMART RETURN STATUS */
2635 smsatSetSensePayload( pSense,
2636 SCSI_SNSKEY_NO_SENSE,
2638 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE,
2640 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen));
2642 if (SENSE_DATA_LENGTH < allocationLen)
2645 tdsmIOCompletedCB( smRoot,
2648 allocationLen - SENSE_DATA_LENGTH,
2650 satOrgIOContext->interruptContext );
2654 tdsmIOCompletedCB( smRoot,
2659 satOrgIOContext->interruptContext );
2662 SM_DBG1(("smsatRequestSenseCB: momory allocation fails!!!\n"));
2664 } /* end of memory allocation failure */
2668 * Need to initialize all the fields within satIOContext
2671 satNewIOContext = smsatPrepareNewIO(
2679 /* sending SAT_CHECK_POWER_MODE */
2680 status = smsatRequestSense_1( smRoot,
2681 &satNewIntIo->satIntSmIORequest,
2682 satNewIOContext->psmDeviceHandle,
2683 &satNewIntIo->satIntSmScsiXchg,
2686 if (status != SM_RC_SUCCESS)
2688 /* sending SAT_CHECK_POWER_MODE fails */
2689 smsatFreeIntIoResource( smRoot,
2693 /* failed during sending SAT_CHECK_POWER_MODE */
2694 smsatSetSensePayload( pSense,
2695 SCSI_SNSKEY_NO_SENSE,
2697 SCSI_SNSCODE_LOW_POWER_CONDITION_ON,
2699 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen));
2701 if (SENSE_DATA_LENGTH < allocationLen)
2704 tdsmIOCompletedCB( smRoot,
2707 allocationLen - SENSE_DATA_LENGTH,
2709 satOrgIOContext->interruptContext );
2713 tdsmIOCompletedCB( smRoot,
2718 satOrgIOContext->interruptContext );
2721 SM_DBG1(("smsatRequestSenseCB: calling satRequestSense_1 fails!!!\n"));
2726 case SAT_CHECK_POWER_MODE:
2727 SM_DBG4(("smsatRequestSenseCB: SAT_CHECK_POWER_MODE case\n"));
2729 /* check ATA STANDBY state */
2730 if (statDevToHostFisData.sectorCount == 0x00)
2733 SM_DBG1(("smsatRequestSenseCB: in standby!!!\n"));
2736 /* report using the original tiIOrequst */
2737 /* failed during sending SAT_CHECK_POWER_MODE */
2738 smsatSetSensePayload( pSense,
2739 SCSI_SNSKEY_NO_SENSE,
2741 SCSI_SNSCODE_LOW_POWER_CONDITION_ON,
2743 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen));
2745 if (SENSE_DATA_LENGTH < allocationLen)
2748 tdsmIOCompletedCB( smRoot,
2749 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2751 allocationLen - SENSE_DATA_LENGTH,
2753 satOrgIOContext->interruptContext );
2757 tdsmIOCompletedCB( smRoot,
2758 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2762 satOrgIOContext->interruptContext );
2765 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2767 smsatFreeIntIoResource( smRoot,
2773 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2775 /* done with internnaly generated SAT_CHECK_POWER_MODE */
2776 smsatFreeIntIoResource( smRoot,
2780 if (oneDeviceData->satFormatState == agTRUE)
2782 SM_DBG1(("smsatRequestSenseCB: in format!!!\n"));
2785 /* report using the original tiIOrequst */
2786 smsatSetSensePayload( pSense,
2787 SCSI_SNSKEY_NOT_READY,
2789 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_FORMAT_IN_PROGRESS,
2791 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen));
2793 if (SENSE_DATA_LENGTH < allocationLen)
2796 tdsmIOCompletedCB( smRoot,
2797 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2799 allocationLen - SENSE_DATA_LENGTH,
2801 satOrgIOContext->interruptContext );
2805 tdsmIOCompletedCB( smRoot,
2806 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2810 satOrgIOContext->interruptContext );
2816 /* normal: returns good status for requestsense */
2817 /* report using the original tiIOrequst */
2818 smsatSetSensePayload( pSense,
2819 SCSI_SNSKEY_NO_SENSE,
2821 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
2823 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen));
2824 SM_DBG4(("smsatRequestSenseCB: returning good status for requestsense\n"));
2825 if (SENSE_DATA_LENGTH < allocationLen)
2828 SM_DBG6(("smsatRequestSenseCB reporting underrun lenNeeded=0x%x lenReceived=0x%x smIORequest=%p\n",
2829 SENSE_DATA_LENGTH, allocationLen, smOrgIORequest));
2830 tdsmIOCompletedCB( smRoot,
2831 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2833 allocationLen - SENSE_DATA_LENGTH,
2835 satOrgIOContext->interruptContext );
2840 tdsmIOCompletedCB( smRoot,
2841 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2845 satOrgIOContext->interruptContext );
2850 SM_DBG1(("smsatRequestSenseCB: success but error default case command 0x%x!!!\n", hostToDevFis->h.command));
2851 /* pSense here is a part of satOrgIOContext */
2852 pSense = satOrgIOContext->pSmSenseData->senseData;
2853 satOrgIOContext->pSmSenseData->senseLen = SENSE_DATA_LENGTH;
2854 /* unspecified case, return no sense and no addition info */
2855 smsatSetSensePayload( pSense,
2856 SCSI_SNSKEY_NO_SENSE,
2858 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
2860 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen));
2862 tdsmIOCompletedCB( smRoot,
2863 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
2865 SCSI_STAT_CHECK_CONDITION,
2866 satOrgIOContext->pSmSenseData,
2867 satOrgIOContext->interruptContext );
2869 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2871 smsatFreeIntIoResource( smRoot,
2882 smsatSendDiagnosticCB(
2884 agsaIORequest_t *agIORequest,
2886 agsaFisHeader_t *agFirstDword,
2888 agsaFrameHandle_t agFrameHandle,
2893 In the process of SendDiagnotic
2894 Process READ VERIFY SECTOR(S) EXT two time
2895 Process SMART ECECUTE OFF-LINE IMMEDIATE
2897 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
2898 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
2899 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
2900 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
2901 smRoot_t *smRoot = agNULL;
2902 smIntRoot_t *smIntRoot = agNULL;
2903 smIntContext_t *smAllShared = agNULL;
2904 smIORequestBody_t *smIORequestBody;
2905 smIORequestBody_t *smOrgIORequestBody;
2906 smSatIOContext_t *satIOContext;
2907 smSatIOContext_t *satOrgIOContext;
2908 smSatIOContext_t *satNewIOContext;
2909 smSatInternalIo_t *satIntIo;
2910 smSatInternalIo_t *satNewIntIo = agNULL;
2911 // satDeviceData_t *satDevData;
2912 smDeviceData_t *oneDeviceData;
2913 smScsiRspSense_t *pSense;
2914 smIniScsiCmnd_t *scsiCmnd;
2915 smIORequest_t *smOrgIORequest;
2916 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
2917 bit32 ataStatus = 0;
2920 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
2922 SM_DBG2(("smsatSendDiagnosticCB: start\n"));
2923 SM_DBG5(("smsatSendDiagnosticCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
2925 /* internally generate smIOContext */
2926 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
2927 satIOContext = (smSatIOContext_t *) ioContext;
2928 satIntIo = satIOContext->satIntIoContext;
2929 oneDeviceData = satIOContext->pSatDevData;
2930 hostToDevFis = satIOContext->pFis;
2931 smRoot = oneDeviceData->smRoot;
2932 smIntRoot = (smIntRoot_t *)smRoot->smData;
2933 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
2935 if (satIntIo == agNULL)
2937 SM_DBG4(("smsatSendDiagnosticCB: External smSatInternalIo_t satIntIoContext\n"));
2938 satOrgIOContext = satIOContext;
2939 smOrgIORequest = smIORequestBody->smIORequest;
2940 pSense = satOrgIOContext->pSense;
2941 scsiCmnd = satOrgIOContext->pScsiCmnd;
2945 SM_DBG4(("smsatSendDiagnosticCB: Internal smSatInternalIo_t satIntIoContext\n"));
2946 satOrgIOContext = satIOContext->satOrgIOContext;
2947 if (satOrgIOContext == agNULL)
2949 SM_DBG4(("smsatSendDiagnosticCB: satOrgIOContext is NULL, wrong\n"));
2954 SM_DBG4(("smsatSendDiagnosticCB: satOrgIOContext is NOT NULL\n"));
2956 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
2957 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
2958 pSense = satOrgIOContext->pSense;
2959 scsiCmnd = satOrgIOContext->pScsiCmnd;
2962 smIORequestBody->ioCompleted = agTRUE;
2963 smIORequestBody->ioStarted = agFALSE;
2965 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
2967 SM_DBG1(("smsatSendDiagnosticCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
2968 oneDeviceData->satVerifyState = 0;
2969 oneDeviceData->satBGPendingDiag = agFALSE;
2971 if (hostToDevFis->d.lbaLow != 0x01 && hostToDevFis->d.lbaLow != 0x02)
2973 /* no completion for background send diagnotic. It is done in satSendDiagnostic() */
2980 satOrgIOContext->interruptContext
2983 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
2985 smsatFreeIntIoResource( smRoot,
2992 if (agIOStatus != OSSA_IO_SUCCESS)
2994 /* only agsaFisRegDeviceToHost_t is expected */
2995 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
2996 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
2999 SM_DBG5(("smsatSendDiagnosticCB: fis command 0x%x\n", hostToDevFis->h.command));
3001 if( agIOStatus != OSSA_IO_SUCCESS)
3004 checking IO status, FIS type and error status
3006 oneDeviceData->satVerifyState = 0;
3007 oneDeviceData->satBGPendingDiag = agFALSE;
3009 if( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) ||
3010 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
3015 if( agIOStatus != OSSA_IO_SUCCESS)
3017 if ( hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT )
3019 SM_DBG1(("smsatSendDiagnosticCB: FAILED, NOT IO_SUCCESS and SAT_READ_VERIFY_SECTORS(_EXT)!!!\n"));
3023 SM_DBG1(("smsatSendDiagnosticCB: FAILED, NOT IO_SUCCESS and SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE!!!\n"));
3028 if( statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
3030 if ( hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT )
3032 SM_DBG1(("smsatSendDiagnosticCB: FAILED, Wrong FIS type 0x%x and SAT_READ_VERIFY_SECTORS(_EXT)!!!\n", statDevToHostFisHeader->fisType));
3036 SM_DBG1(("smsatSendDiagnosticCB: FAILED, Wrong FIS type 0x%x and SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE!!!\n",statDevToHostFisHeader->fisType));
3041 if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
3042 (ataStatus & DF_ATA_STATUS_MASK)
3045 if ( hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT )
3047 SM_DBG1(("smsatSendDiagnosticCB: FAILED, error status and SAT_READ_VERIFY_SECTORS(_EXT)!!!\n"));
3051 SM_DBG1(("smsatSendDiagnosticCB: FAILED, error status and SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE!!!\n"));
3055 /* Process abort case */
3056 if (agIOStatus == OSSA_IO_ABORTED)
3058 smsatProcessAbort(smRoot,
3063 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3065 smsatFreeIntIoResource( smRoot,
3071 if ( (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS) ||
3072 (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT) )
3074 /* report using the original tiIOrequst */
3075 /* failed during sending SAT_READ_VERIFY_SECTORS(_EXT) */
3076 smsatSetSensePayload( pSense,
3077 SCSI_SNSKEY_HARDWARE_ERROR,
3079 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST,
3082 tdsmIOCompletedCB( smRoot,
3083 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3085 SCSI_STAT_CHECK_CONDITION,
3086 satOrgIOContext->pSmSenseData,
3087 satOrgIOContext->interruptContext );
3089 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3091 smsatFreeIntIoResource( smRoot,
3098 /* report using the original tiIOrequst */
3099 /* failed during sending SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE */
3100 smsatSetSensePayload( pSense,
3101 SCSI_SNSKEY_HARDWARE_ERROR,
3103 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST,
3106 if (hostToDevFis->d.lbaLow != 0x01 && hostToDevFis->d.lbaLow != 0x02)
3108 /* no completion for background send diagnotic. It is done in satSendDiagnostic() */
3109 tdsmIOCompletedCB( smRoot,
3110 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3112 SCSI_STAT_CHECK_CONDITION,
3113 satOrgIOContext->pSmSenseData,
3114 satOrgIOContext->interruptContext );
3117 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3119 smsatFreeIntIoResource( smRoot,
3127 /* processing success case */
3128 switch (hostToDevFis->h.command)
3130 case SAT_READ_VERIFY_SECTORS: /* fall through */
3131 case SAT_READ_VERIFY_SECTORS_EXT:
3132 SM_DBG5(("smsatSendDiagnosticCB: SAT_READ_VERIFY_SECTORS(_EXT) case\n"));
3133 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK);
3134 oneDeviceData->satVerifyState++;
3135 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK);
3136 SM_DBG5(("smsatSendDiagnosticCB: satVerifyState %d\n",oneDeviceData->satVerifyState));
3138 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3140 /* done with internally genereated AT_READ_VERIFY_SECTORS(_EXT) */
3141 smsatFreeIntIoResource( smRoot,
3145 if (oneDeviceData->satVerifyState == 3)
3147 /* reset satVerifyState */
3148 oneDeviceData->satVerifyState = 0;
3149 /* return GOOD status */
3150 SM_DBG5(("smsatSendDiagnosticCB: return GOOD status\n"));
3151 tdsmIOCompletedCB( smRoot,
3152 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
3156 satOrgIOContext->interruptContext );
3161 /* prepare SAT_READ_VERIFY_SECTORS(_EXT) */
3162 satNewIntIo = smsatAllocIntIoResource( smRoot,
3167 if (satNewIntIo == agNULL)
3169 /* reset satVerifyState */
3170 oneDeviceData->satVerifyState = 0;
3172 /* failed as a part of sending SAT_READ_VERIFY_SECTORS(_EXT) */
3173 smsatSetSensePayload( pSense,
3174 SCSI_SNSKEY_HARDWARE_ERROR,
3176 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST,
3179 tdsmIOCompletedCB( smRoot,
3182 SCSI_STAT_CHECK_CONDITION,
3183 satOrgIOContext->pSmSenseData,
3184 satOrgIOContext->interruptContext );
3186 SM_DBG1(("smsatSendDiagnosticCB: momory allocation fails!!!\n"));
3188 } /* end of memory allocation failure */
3191 * Need to initialize all the fields within satIOContext
3194 satNewIOContext = smsatPrepareNewIO(
3202 if (oneDeviceData->satVerifyState == 1)
3204 /* sending SAT_CHECK_POWER_MODE */
3205 status = smsatSendDiagnostic_1( smRoot,
3206 &satNewIntIo->satIntSmIORequest,
3207 satNewIOContext->psmDeviceHandle,
3208 &satNewIntIo->satIntSmScsiXchg,
3213 /* oneDeviceData->satVerifyState == 2 */
3214 status = smsatSendDiagnostic_2( smRoot,
3215 &satNewIntIo->satIntSmIORequest,
3216 satNewIOContext->psmDeviceHandle,
3217 &satNewIntIo->satIntSmScsiXchg,
3221 if (status != SM_RC_SUCCESS)
3223 /* sending SAT_READ_VERIFY_SECTORS(_EXT) fails */
3224 smsatFreeIntIoResource( smRoot,
3228 /* failed during sending SAT_READ_VERIFY_SECTORS(_EXT) */
3229 smsatSetSensePayload( pSense,
3230 SCSI_SNSKEY_HARDWARE_ERROR,
3232 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST,
3235 tdsmIOCompletedCB( smRoot,
3238 SCSI_STAT_CHECK_CONDITION,
3239 satOrgIOContext->pSmSenseData,
3240 satOrgIOContext->interruptContext );
3242 /* reset satVerifyState */
3243 oneDeviceData->satVerifyState = 0;
3244 SM_DBG1(("smsatSendDiagnosticCB: calling satSendDiagnostic_1 or _2 fails!!!\n"));
3247 } /* oneDeviceData->satVerifyState == 1 or 2 */
3251 if (hostToDevFis->h.features == SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE)
3253 SM_DBG5(("smsatSendDiagnosticCB: SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE case\n"));
3255 oneDeviceData->satBGPendingDiag = agFALSE;
3257 if (hostToDevFis->d.lbaLow == 0x01 || hostToDevFis->d.lbaLow == 0x02)
3259 /* for background send diagnostic, no completion here. It is done already. */
3260 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3262 /* done with AT_SMART_EXEUTE_OFF_LINE_IMMEDIATE */
3263 smsatFreeIntIoResource( smRoot,
3266 SM_DBG5(("smsatSendDiagnosticCB: returning but no IOCompleted\n"));
3270 SM_DBG5(("smsatSendDiagnosticCB: returning good status for senddiagnostic\n"));
3271 tdsmIOCompletedCB( smRoot,
3272 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
3276 satOrgIOContext->interruptContext );
3279 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3281 /* done with AT_SMART_EXEUTE_OFF_LINE_IMMEDIATE */
3282 smsatFreeIntIoResource( smRoot,
3289 SM_DBG1(("smsatSendDiagnosticCB: success but error default case command 0x%x!!!\n", hostToDevFis->h.command));
3290 /* unspecified case, return no sense and no addition info */
3291 smsatSetSensePayload( pSense,
3292 SCSI_SNSKEY_NO_SENSE,
3294 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
3297 tdsmIOCompletedCB( smRoot,
3298 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
3300 SCSI_STAT_CHECK_CONDITION,
3301 satOrgIOContext->pSmSenseData,
3302 satOrgIOContext->interruptContext );
3304 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3306 smsatFreeIntIoResource( smRoot,
3316 smsatStartStopUnitCB(
3318 agsaIORequest_t *agIORequest,
3320 agsaFisHeader_t *agFirstDword,
3322 agsaFrameHandle_t agFrameHandle,
3327 In the process of StartStopUnit
3328 Process FLUSH CACHE (EXT)
3330 Process READ VERIFY SECTOR(S) EXT
3333 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
3334 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
3335 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
3336 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
3337 smRoot_t *smRoot = agNULL;
3338 smIntRoot_t *smIntRoot = agNULL;
3339 smIntContext_t *smAllShared = agNULL;
3340 smIORequestBody_t *smIORequestBody;
3341 smIORequestBody_t *smOrgIORequestBody;
3342 smSatIOContext_t *satIOContext;
3343 smSatIOContext_t *satOrgIOContext;
3344 smSatIOContext_t *satNewIOContext;
3345 smSatInternalIo_t *satIntIo;
3346 smSatInternalIo_t *satNewIntIo = agNULL;
3347 // satDeviceData_t *satDevData;
3348 smDeviceData_t *oneDeviceData;
3349 smScsiRspSense_t *pSense;
3350 smIniScsiCmnd_t *scsiCmnd;
3351 smIORequest_t *smOrgIORequest;
3352 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
3353 bit32 ataStatus = 0;
3355 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
3357 SM_DBG2(("smsatStartStopUnitCB: start\n"));
3358 SM_DBG5(("smsatStartStopUnitCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
3360 /* internally generate smIOContext */
3361 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
3362 satIOContext = (smSatIOContext_t *) ioContext;
3363 satIntIo = satIOContext->satIntIoContext;
3364 oneDeviceData = satIOContext->pSatDevData;
3365 hostToDevFis = satIOContext->pFis;
3366 smRoot = oneDeviceData->smRoot;
3367 smIntRoot = (smIntRoot_t *)smRoot->smData;
3368 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
3369 if (satIntIo == agNULL)
3371 SM_DBG4(("smsatStartStopUnitCB: External smSatInternalIo_t satIntIoContext\n"));
3372 satOrgIOContext = satIOContext;
3373 smOrgIORequest = smIORequestBody->smIORequest;
3374 pSense = satIOContext->pSense;
3375 scsiCmnd = satIOContext->pScsiCmnd;
3379 SM_DBG4(("smsatStartStopUnitCB: Internal smSatInternalIo_t satIntIoContext\n"));
3380 satOrgIOContext = satIOContext->satOrgIOContext;
3381 if (satOrgIOContext == agNULL)
3383 SM_DBG4(("smsatStartStopUnitCB: satOrgIOContext is NULL, wrong\n"));
3388 SM_DBG4(("smsatStartStopUnitCB: satOrgIOContext is NOT NULL\n"));
3390 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
3391 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
3393 pSense = satOrgIOContext->pSense;
3394 scsiCmnd = satOrgIOContext->pScsiCmnd;
3397 smIORequestBody->ioCompleted = agTRUE;
3398 smIORequestBody->ioStarted = agFALSE;
3400 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
3402 SM_DBG1(("smsatStartStopUnitCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
3405 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK))
3407 SM_DBG1(("smsatStartStopUnitCB: immed bit 0!!!\n"));
3408 smsatSetSensePayload( pSense,
3409 SCSI_SNSKEY_ABORTED_COMMAND,
3411 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3414 tdsmIOCompletedCB( smRoot,
3415 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3417 SCSI_STAT_CHECK_CONDITION,
3418 satOrgIOContext->pSmSenseData,
3419 satOrgIOContext->interruptContext );
3422 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3423 smsatFreeIntIoResource( smRoot,
3428 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)
3430 SM_DBG1(("smsatStartStopUnitCB: immed bit 1!!!\n"));
3431 smsatSetDeferredSensePayload( pSense,
3432 SCSI_SNSKEY_ABORTED_COMMAND,
3434 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3437 tdsmIOCompletedCB( smRoot,
3438 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3440 SCSI_STAT_CHECK_CONDITION,
3441 satOrgIOContext->pSmSenseData,
3442 satOrgIOContext->interruptContext );
3445 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3446 smsatFreeIntIoResource( smRoot,
3456 if (agIOStatus != OSSA_IO_SUCCESS)
3458 /* only agsaFisRegDeviceToHost_t is expected */
3459 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
3460 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
3463 checking IO status, FIS type and error status
3465 if( agIOStatus != OSSA_IO_SUCCESS)
3467 if( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) ||
3468 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
3472 if( agIOStatus != OSSA_IO_SUCCESS)
3474 SM_DBG1(("smsatStartStopUnitCB: FAILED, NOT IO_SUCCESS!!!\n"));
3476 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
3478 SM_DBG1(("smsatStartStopUnitCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
3480 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
3481 (ataStatus & DF_ATA_STATUS_MASK)
3484 SM_DBG1(("smsatStartStopUnitCB: FAILED, FAILED, error status!!!\n"));
3488 /* Process abort case */
3489 if (agIOStatus == OSSA_IO_ABORTED)
3491 smsatProcessAbort(smRoot,
3497 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3499 smsatFreeIntIoResource( smRoot,
3505 switch (hostToDevFis->h.command)
3507 case SAT_FLUSH_CACHE: /* fall through */
3508 case SAT_FLUSH_CACHE_EXT:
3509 SM_DBG1(("smsatStartStopUnitCB: SAT_FLUSH_CACHE(_EXT)!!!\n"));
3510 /* check immed bit in scsi command */
3512 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK))
3514 smsatSetSensePayload( pSense,
3515 SCSI_SNSKEY_ABORTED_COMMAND,
3517 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3520 tdsmIOCompletedCB( smRoot,
3521 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3523 SCSI_STAT_CHECK_CONDITION,
3524 satOrgIOContext->pSmSenseData,
3525 satOrgIOContext->interruptContext );
3528 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3530 smsatFreeIntIoResource( smRoot,
3535 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)
3537 smsatSetDeferredSensePayload( pSense,
3538 SCSI_SNSKEY_ABORTED_COMMAND,
3540 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3543 tdsmIOCompletedCB( smRoot,
3544 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3546 SCSI_STAT_CHECK_CONDITION,
3547 satOrgIOContext->pSmSenseData,
3548 satOrgIOContext->interruptContext );
3551 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3553 smsatFreeIntIoResource( smRoot,
3559 SM_DBG5(("smsatStartStopUnitCB: SAT_STANDBY\n"));
3560 /* check immed bit in scsi command */
3562 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK))
3564 smsatSetSensePayload( pSense,
3565 SCSI_SNSKEY_ABORTED_COMMAND,
3567 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3570 tdsmIOCompletedCB( smRoot,
3571 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3573 SCSI_STAT_CHECK_CONDITION,
3574 satOrgIOContext->pSmSenseData,
3575 satOrgIOContext->interruptContext );
3578 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3580 smsatFreeIntIoResource( smRoot,
3585 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)
3587 smsatSetDeferredSensePayload( pSense,
3588 SCSI_SNSKEY_ABORTED_COMMAND,
3590 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3593 tdsmIOCompletedCB( smRoot,
3594 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3596 SCSI_STAT_CHECK_CONDITION,
3597 satOrgIOContext->pSmSenseData,
3598 satOrgIOContext->interruptContext );
3601 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3603 smsatFreeIntIoResource( smRoot,
3608 case SAT_READ_VERIFY_SECTORS: /* fall through */
3609 case SAT_READ_VERIFY_SECTORS_EXT:
3610 SM_DBG5(("smsatStartStopUnitCB: SAT_READ_VERIFY_SECTORS(_EXT)\n"));
3612 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK))
3614 smsatSetSensePayload( pSense,
3615 SCSI_SNSKEY_ABORTED_COMMAND,
3617 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3620 tdsmIOCompletedCB( smRoot,
3621 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3623 SCSI_STAT_CHECK_CONDITION,
3624 satOrgIOContext->pSmSenseData,
3625 satOrgIOContext->interruptContext );
3628 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3630 smsatFreeIntIoResource( smRoot,
3635 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)
3637 smsatSetDeferredSensePayload( pSense,
3638 SCSI_SNSKEY_ABORTED_COMMAND,
3640 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3643 tdsmIOCompletedCB( smRoot,
3644 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3646 SCSI_STAT_CHECK_CONDITION,
3647 satOrgIOContext->pSmSenseData,
3648 satOrgIOContext->interruptContext );
3651 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3653 smsatFreeIntIoResource( smRoot,
3658 case SAT_MEDIA_EJECT:
3659 SM_DBG5(("smsatStartStopUnitCB: SAT_MEDIA_EJECT\n"));
3661 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK))
3663 smsatSetSensePayload( pSense,
3664 SCSI_SNSKEY_ABORTED_COMMAND,
3666 SCSI_SNSCODE_MEDIA_LOAD_OR_EJECT_FAILED,
3669 tdsmIOCompletedCB( smRoot,
3670 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3672 SCSI_STAT_CHECK_CONDITION,
3673 satOrgIOContext->pSmSenseData,
3674 satOrgIOContext->interruptContext );
3677 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3679 smsatFreeIntIoResource( smRoot,
3684 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)
3686 smsatSetDeferredSensePayload( pSense,
3687 SCSI_SNSKEY_ABORTED_COMMAND,
3689 SCSI_SNSCODE_MEDIA_LOAD_OR_EJECT_FAILED,
3692 tdsmIOCompletedCB( smRoot,
3693 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
3695 SCSI_STAT_CHECK_CONDITION,
3696 satOrgIOContext->pSmSenseData,
3697 satOrgIOContext->interruptContext );
3699 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3701 smsatFreeIntIoResource( smRoot,
3707 /* unspecified case, return no sense and no addition info */
3708 SM_DBG5(("smsatStartStopUnitCB: default command %d\n", hostToDevFis->h.command));
3709 smsatSetSensePayload( pSense,
3710 SCSI_SNSKEY_NO_SENSE,
3712 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
3715 tdsmIOCompletedCB( smRoot,
3716 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
3718 SCSI_STAT_CHECK_CONDITION,
3719 satOrgIOContext->pSmSenseData,
3720 satOrgIOContext->interruptContext );
3723 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3725 smsatFreeIntIoResource( smRoot,
3735 /* ATA command completes sucessfully */
3736 switch (hostToDevFis->h.command)
3738 case SAT_FLUSH_CACHE: /* fall through */
3739 case SAT_FLUSH_CACHE_EXT:
3740 SM_DBG5(("smsatStartStopUnitCB: SAT_READ_VERIFY_SECTORS(_EXT) success case\n"));
3743 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3745 /* done with SAT_FLUSH_CACHE(_EXT) */
3746 smsatFreeIntIoResource( smRoot,
3750 /* at this point, successful SAT_READ_VERIFY_SECTORS(_EXT)
3753 satNewIntIo = smsatAllocIntIoResource( smRoot,
3758 if (satNewIntIo == agNULL)
3761 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK))
3763 smsatSetSensePayload( pSense,
3764 SCSI_SNSKEY_ABORTED_COMMAND,
3766 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3769 else /* IMMED == 1 */
3771 smsatSetDeferredSensePayload( pSense,
3772 SCSI_SNSKEY_ABORTED_COMMAND,
3774 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3777 tdsmIOCompletedCB( smRoot,
3780 SCSI_STAT_CHECK_CONDITION,
3781 satOrgIOContext->pSmSenseData,
3782 satOrgIOContext->interruptContext );
3784 SM_DBG1(("smsatStartStopUnitCB: momory allocation fails!!!\n"));
3786 } /* end of memory allocation failure */
3789 * Need to initialize all the fields within satIOContext
3792 satNewIOContext = smsatPrepareNewIO(
3800 /* sending SAT_STANDBY */
3801 status = smsatStartStopUnit_1( smRoot,
3802 &satNewIntIo->satIntSmIORequest,
3803 satNewIOContext->psmDeviceHandle,
3804 &satNewIntIo->satIntSmScsiXchg,
3807 if (status != SM_RC_SUCCESS)
3809 /* sending SAT_CHECK_POWER_MODE fails */
3810 smsatFreeIntIoResource( smRoot,
3815 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK))
3817 smsatSetSensePayload( pSense,
3818 SCSI_SNSKEY_ABORTED_COMMAND,
3820 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3823 else /* IMMED == 1 */
3825 smsatSetDeferredSensePayload( pSense,
3826 SCSI_SNSKEY_ABORTED_COMMAND,
3828 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR,
3831 tdsmIOCompletedCB( smRoot,
3834 SCSI_STAT_CHECK_CONDITION,
3835 satOrgIOContext->pSmSenseData,
3836 satOrgIOContext->interruptContext );
3838 SM_DBG1(("smsatStartStopUnitCB: calling satStartStopUnit_1 fails!!!\n"));
3843 SM_DBG5(("smsatStartStopUnitCB: SAT_STANDBY success case\n"));
3845 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3847 /* done with SAT_STANDBY */
3848 smsatFreeIntIoResource( smRoot,
3852 if immed == 0, return good status
3855 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK))
3857 tdsmIOCompletedCB( smRoot,
3862 satOrgIOContext->interruptContext );
3864 oneDeviceData->satStopState = agTRUE;
3866 case SAT_READ_VERIFY_SECTORS: /* fall through */
3867 case SAT_READ_VERIFY_SECTORS_EXT:
3868 SM_DBG5(("smsatStartStopUnitCB: SAT_READ_VERIFY_SECTORS(_EXT) success case\n"));
3870 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3872 /* done with SAT_READ_VERIFY_SECTORS(_EXT) */
3873 smsatFreeIntIoResource( smRoot,
3877 if immed == 0, return good status
3879 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK))
3881 tdsmIOCompletedCB( smRoot,
3886 satOrgIOContext->interruptContext );
3889 if immed == 0, return good status
3892 don't forget to check and set driver state; Active power state
3894 oneDeviceData->satStopState = agFALSE;
3896 case SAT_MEDIA_EJECT:
3897 SM_DBG5(("smsatStartStopUnitCB: SAT_MEDIA_EJECT success case\n"));
3899 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3901 /* done with SAT_READ_VERIFY_SECTORS(_EXT) */
3902 smsatFreeIntIoResource( smRoot,
3906 if immed == 0, return good status
3908 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK))
3910 tdsmIOCompletedCB( smRoot,
3915 satOrgIOContext->interruptContext );
3919 SM_DBG1(("smsatStartStopUnitCB:success but error default case command 0x%x!!!\n", hostToDevFis->h.command));
3921 /* unspecified case, return no sense and no addition info */
3922 smsatSetSensePayload( pSense,
3923 SCSI_SNSKEY_NO_SENSE,
3925 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
3928 tdsmIOCompletedCB( smRoot,
3929 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
3931 SCSI_STAT_CHECK_CONDITION,
3932 satOrgIOContext->pSmSenseData,
3933 satOrgIOContext->interruptContext );
3935 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
3937 smsatFreeIntIoResource( smRoot,
3949 agsaIORequest_t *agIORequest,
3951 agsaFisHeader_t *agFirstDword,
3953 agsaFrameHandle_t agFrameHandle,
3957 smRoot_t *smRoot = agNULL;
3958 smIntRoot_t *smIntRoot = agNULL;
3959 smIntContext_t *smAllShared = agNULL;
3960 smIORequestBody_t *smIORequestBody;
3961 smIORequestBody_t *smOrgIORequestBody;
3962 smIORequestBody_t *smNewIORequestBody;
3963 smSatIOContext_t *satIOContext;
3964 smSatIOContext_t *satOrgIOContext;
3965 smSatIOContext_t *satNewIOContext;
3966 smSatInternalIo_t *satIntIo;
3967 smSatInternalIo_t *satNewIntIo = agNULL;
3968 smDeviceData_t *oneDeviceData;
3969 smScsiRspSense_t *pSense;
3970 smIniScsiCmnd_t *scsiCmnd;
3971 smIORequest_t *smOrgIORequest;
3972 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
3973 bit32 ataStatus = 0;
3975 bit32 sectorcount = 0;
3976 bit32 lba = 0, tl = 0;
3977 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
3978 agsaFisSetDevBitsHeader_t *statSetDevBitFisHeader = agNULL;
3980 SM_DBG2(("smsatWriteSame10CB: start\n"));
3981 SM_DBG5(("smsatWriteSame10CB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
3983 /* internally generate smIOContext */
3984 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
3985 satIOContext = (smSatIOContext_t *) ioContext;
3986 satIntIo = satIOContext->satIntIoContext;
3987 oneDeviceData = satIOContext->pSatDevData;
3988 hostToDevFis = satIOContext->pFis;
3989 smRoot = oneDeviceData->smRoot;
3990 smIntRoot = (smIntRoot_t *)smRoot->smData;
3991 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
3993 if (satIntIo == agNULL)
3995 SM_DBG4(("smsatWriteSame10CB: External smSatInternalIo_t satIntIoContext\n"));
3996 satOrgIOContext = satIOContext;
3997 smOrgIORequest = smIORequestBody->smIORequest;
3998 pSense = satIOContext->pSense;
3999 scsiCmnd = satIOContext->pScsiCmnd;
4003 SM_DBG4(("smsatWriteSame10CB: Internal smSatInternalIo_t satIntIoContext\n"));
4004 satOrgIOContext = satIOContext->satOrgIOContext;
4005 if (satOrgIOContext == agNULL)
4007 SM_DBG4(("smsatWriteSame10CB: satOrgIOContext is NULL, wrong\n"));
4012 SM_DBG4(("smsatWriteSame10CB: satOrgIOContext is NOT NULL\n"));
4014 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
4015 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
4017 pSense = satOrgIOContext->pSense;
4018 scsiCmnd = satOrgIOContext->pScsiCmnd;
4022 smIORequestBody->ioCompleted = agTRUE;
4023 smIORequestBody->ioStarted = agFALSE;
4025 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
4027 SM_DBG1(("smsatWriteSame10CB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
4028 smsatSetSensePayload( pSense,
4029 SCSI_SNSKEY_NO_SENSE,
4031 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
4034 tdsmIOCompletedCB( smRoot,
4035 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
4037 SCSI_STAT_CHECK_CONDITION,
4038 satOrgIOContext->pSmSenseData,
4039 satOrgIOContext->interruptContext );
4041 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4043 smsatFreeIntIoResource( smRoot,
4049 if (agIOStatus != OSSA_IO_SUCCESS)
4051 /* FP, DMA and PIO write */
4052 /* First, assumed to be Reg Device to Host FIS */
4053 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
4054 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
4057 if (agIOStatus != OSSA_IO_SUCCESS)
4059 if (statDevToHostFisHeader->fisType == SET_DEV_BITS_FIS)
4061 statSetDevBitFisHeader = (agsaFisSetDevBitsHeader_t *)&(agFirstDword->D2H);
4063 /* Get ATA Status register */
4064 ataStatus = (statSetDevBitFisHeader->statusHi_Lo & 0x70); /* bits 4,5,6 */
4065 ataStatus = ataStatus | (statSetDevBitFisHeader->statusHi_Lo & 0x07); /* bits 0,1,2 */
4069 if( agIOStatus != OSSA_IO_SUCCESS)
4072 checking IO status, FIS type and error status
4073 FIS type should be either REG_DEV_TO_HOST_FIS or SET_DEV_BITS_FIS
4075 if ( ((statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) &&
4076 (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS)) ||
4077 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
4081 if( agIOStatus != OSSA_IO_SUCCESS)
4083 SM_DBG1(("smsatWriteSame10CB: FAILED, NOT IO_SUCCESS!!!\n"));
4085 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
4087 SM_DBG1(("smsatWriteSame10CB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
4089 else if (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS)
4091 SM_DBG1(("smsatWriteSame10CB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
4093 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
4094 (ataStatus & DF_ATA_STATUS_MASK)
4097 SM_DBG1(("smsatWriteSame10CB: FAILED, FAILED, error status!!!\n"));
4100 /* Process abort case */
4101 if (agIOStatus == OSSA_IO_ABORTED)
4103 smsatProcessAbort(smRoot,
4109 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4111 smsatFreeIntIoResource( smRoot,
4118 switch (hostToDevFis->h.command)
4120 case SAT_WRITE_DMA_EXT:
4121 SM_DBG1(("smsatWriteSame10CB: SAT_WRITE_DMA_EXT!!!\n"));
4123 case SAT_WRITE_SECTORS_EXT:
4124 SM_DBG1(("smsatWriteSame10CB: SAT_WRITE_SECTORS_EXT!!!\n"));
4126 case SAT_WRITE_FPDMA_QUEUED:
4127 SM_DBG1(("smsatWriteSame10CB: SAT_WRITE_FPDMA_QUEUED!!!\n"));
4130 SM_DBG1(("smsatWriteSame10CB: error default case command 0x%x!!!\n", hostToDevFis->h.command));
4134 smsatSetSensePayload( pSense,
4135 SCSI_SNSKEY_NO_SENSE,
4137 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
4140 tdsmIOCompletedCB( smRoot,
4141 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
4143 SCSI_STAT_CHECK_CONDITION,
4144 satOrgIOContext->pSmSenseData,
4145 satOrgIOContext->interruptContext );
4148 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4150 smsatFreeIntIoResource( smRoot,
4157 /* process success from this point on */
4159 note: inefficient implementation until a single block can be manipulated
4162 if (hostToDevFis->h.command == SAT_WRITE_DMA_EXT)
4164 SM_DBG5(("smsatWriteSame10CB: SAT_WRITE_DMA_EXT success\n"));
4166 else if (hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT)
4168 SM_DBG5(("smsatWriteSame10CB: SAT_WRITE_SECTORS_EXT success\n"));
4170 else if (hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED)
4172 SM_DBG5(("smsatWriteSame10CB: SAT_WRITE_FPDMA_QUEUED success\n"));
4176 SM_DBG1(("smsatWriteSame10CB: error case command 0x%x success!!!\n", hostToDevFis->h.command));
4177 smsatSetSensePayload( pSense,
4178 SCSI_SNSKEY_NO_SENSE,
4180 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
4183 tdsmIOCompletedCB( smRoot,
4184 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
4186 SCSI_STAT_CHECK_CONDITION,
4187 satOrgIOContext->pSmSenseData,
4188 satOrgIOContext->interruptContext );
4191 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4193 smsatFreeIntIoResource( smRoot,
4200 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4203 smsatFreeIntIoResource( smRoot,
4208 increment LBA by one, keeping the same sector count(1)
4209 sends another ATA command with the changed parameters
4212 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK);
4213 oneDeviceData->satSectorDone++;
4214 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK);
4216 SM_DBG1(("smsatWriteSame10CB: sectordone %d!!!\n", oneDeviceData->satSectorDone));
4218 lba = (scsiCmnd->cdb[2] << (8*3)) + (scsiCmnd->cdb[3] << (8*2))
4219 + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5];
4220 tl = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8];
4222 SM_DBG5(("smsatWriteSame10CB: lba 0x%x tl 0x%x\n", lba, tl));
4226 /* (oneDeviceData->satMaxUserAddrSectors - 1) - lba*/
4227 sectorcount = (0x0FFFFFFF - 1) - lba;
4234 if (sectorcount <= 0)
4236 smsatSetSensePayload( pSense,
4237 SCSI_SNSKEY_NO_SENSE,
4239 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
4242 tdsmIOCompletedCB( smRoot,
4243 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
4245 SCSI_STAT_CHECK_CONDITION,
4246 satOrgIOContext->pSmSenseData,
4247 satOrgIOContext->interruptContext );
4248 SM_DBG1(("smsatWriteSame10CB: incorrect sectorcount 0x%x!!!\n", sectorcount));
4252 if (sectorcount == oneDeviceData->satSectorDone)
4257 SM_DBG1(("smsatWriteSame10CB: return writesame done!!!\n"));
4258 oneDeviceData->satSectorDone = 0;
4260 tdsmIOCompletedCB( smRoot,
4265 satOrgIOContext->interruptContext );
4269 /* sends another ATA command */
4270 if (hostToDevFis->h.command == SAT_WRITE_DMA_EXT)
4272 SM_DBG1(("smsatWriteSame10CB: sends another SAT_WRITE_DMA_EXT!!!\n"));
4274 else if (hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT)
4276 SM_DBG1(("smsatWriteSame10CB: sends another SAT_WRITE_SECTORS_EXT!!!\n"));
4278 else if (hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED)
4280 SM_DBG1(("smsatWriteSame10CB: sends another SAT_WRITE_FPDMA_QUEUED!!!\n"));
4283 satNewIntIo = smsatAllocIntIoResource( smRoot,
4288 if (satNewIntIo == agNULL)
4290 smsatSetSensePayload( pSense,
4291 SCSI_SNSKEY_NO_SENSE,
4293 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
4296 tdsmIOCompletedCB( smRoot,
4297 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
4299 SCSI_STAT_CHECK_CONDITION,
4300 satOrgIOContext->pSmSenseData,
4301 satOrgIOContext->interruptContext );
4302 SM_DBG1(("smsatWriteSame10CB: momory allocation fails!!!\n"));
4304 } /* end memory allocation */
4306 /* the one to be used */
4307 smNewIORequestBody = satNewIntIo->satIntRequestBody;
4308 satNewIOContext = &smNewIORequestBody->transport.SATA.satIOContext;
4310 satNewIOContext->pSatDevData = oneDeviceData;
4311 satNewIOContext->pFis = &smNewIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev;
4312 satNewIOContext->pScsiCmnd = &satNewIntIo->satIntSmScsiXchg.scsiCmnd;
4313 /* saves scsi command for LBA and number of blocks */
4314 sm_memcpy(satNewIOContext->pScsiCmnd, scsiCmnd, sizeof(smIniScsiCmnd_t));
4315 satNewIOContext->pSense = &smNewIORequestBody->transport.SATA.sensePayload;
4316 satNewIOContext->pSmSenseData = &smNewIORequestBody->transport.SATA.smSenseData;
4317 satNewIOContext->pSmSenseData->senseData = satNewIOContext->pSense;
4318 satNewIOContext->smRequestBody = satNewIntIo->satIntRequestBody;
4319 satNewIOContext->interruptContext = satNewIOContext->interruptContext;
4320 satNewIOContext->satIntIoContext = satNewIntIo;
4321 satNewIOContext->psmDeviceHandle = satIOContext->psmDeviceHandle;
4322 /* saves smScsiXchg; only for writesame10() */
4323 satNewIOContext->smScsiXchg = satOrgIOContext->smScsiXchg;
4325 if (hostToDevFis->h.command == SAT_WRITE_DMA_EXT)
4327 status = smsatWriteSame10_1( smRoot,
4328 &satNewIntIo->satIntSmIORequest,
4329 satNewIOContext->psmDeviceHandle,
4330 &satNewIntIo->satIntSmScsiXchg,
4332 lba + oneDeviceData->satSectorDone
4335 else if (hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT)
4337 status = smsatWriteSame10_2( smRoot,
4338 &satNewIntIo->satIntSmIORequest,
4339 satNewIOContext->psmDeviceHandle,
4340 &satNewIntIo->satIntSmScsiXchg,
4342 lba + oneDeviceData->satSectorDone
4345 else if (hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED)
4347 status = smsatWriteSame10_3( smRoot,
4348 &satNewIntIo->satIntSmIORequest,
4349 satNewIOContext->psmDeviceHandle,
4350 &satNewIntIo->satIntSmScsiXchg,
4352 lba + oneDeviceData->satSectorDone
4358 SM_DBG1(("smsatWriteSame10CB: sucess but error in command 0x%x!!!\n", hostToDevFis->h.command));
4361 if (status != SM_RC_SUCCESS)
4363 /* sending ATA command fails */
4364 smsatFreeIntIoResource( smRoot,
4367 smsatSetSensePayload( pSense,
4368 SCSI_SNSKEY_NO_SENSE,
4370 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
4373 tdsmIOCompletedCB( smRoot,
4374 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
4376 SCSI_STAT_CHECK_CONDITION,
4377 satOrgIOContext->pSmSenseData,
4378 satOrgIOContext->interruptContext );
4379 SM_DBG1(("smsatWriteSame10CB:calling satWriteSame10_1 fails!!!\n"));
4381 } /* end send fails */
4383 } /* end sends another ATA command */
4392 agsaIORequest_t *agIORequest,
4394 agsaFisHeader_t *agFirstDword,
4400 smRoot_t *smRoot = agNULL;
4401 smIntRoot_t *smIntRoot = agNULL;
4402 smIntContext_t *smAllShared = agNULL;
4403 smIORequestBody_t *smIORequestBody;
4404 smIORequestBody_t *smOrgIORequestBody;
4405 smSatIOContext_t *satIOContext;
4406 smSatIOContext_t *satOrgIOContext;
4407 smSatInternalIo_t *satIntIo;
4408 // satDeviceData_t *satDevData;
4409 smDeviceData_t *oneDeviceData;
4411 smScsiRspSense_t *pSense;
4412 smIORequest_t *smOrgIORequest;
4414 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
4415 bit32 ataStatus = 0;
4416 smScsiInitiatorRequest_t *smScsiRequest; /* tiScsiXchg */
4417 smScsiInitiatorRequest_t *smOrgScsiRequest; /* tiScsiXchg */
4418 satReadLogExtSelfTest_t *virtAddr1;
4419 satSmartReadLogSelfTest_t *virtAddr2;
4421 bit8 LogPage[SELFTEST_RESULTS_LOG_PAGE_LENGTH];
4422 bit8 SelfTestExecutionStatus = 0;
4425 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
4426 agsaFisRegD2HData_t statDevToHostFisData;
4427 smIniScsiCmnd_t *scsiCmnd;
4428 bit32 allocationLen = 0;
4430 SM_DBG2(("smsatLogSenseCB: start\n"));
4431 SM_DBG5(("smsatLogSenseCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
4433 /* internally generate smIOContext */
4434 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
4435 satIOContext = (smSatIOContext_t *) ioContext;
4436 if (satIOContext == agNULL)
4438 SM_DBG1(("smsatLogSenseCB: satIOContext is NULL\n"));
4441 satIntIo = satIOContext->satIntIoContext;
4442 oneDeviceData = satIOContext->pSatDevData;
4443 hostToDevFis = satIOContext->pFis;
4444 smRoot = oneDeviceData->smRoot;
4445 smIntRoot = (smIntRoot_t *)smRoot->smData;
4446 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
4448 if (satIntIo == agNULL)
4450 SM_DBG4(("smsatLogSenseCB: External smSatInternalIo_t satIntIoContext\n"));
4451 satOrgIOContext = satIOContext;
4452 smOrgIORequest = smIORequestBody->smIORequest;
4453 pSense = satOrgIOContext->pSense;
4454 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
4455 /* SCSI command response payload to OS layer */
4456 pLogPage = (bit8 *) smOrgScsiRequest->sglVirtualAddr;
4457 /* ATA command response payload */
4458 smScsiRequest = satOrgIOContext->smScsiXchg;
4459 scsiCmnd = satOrgIOContext->pScsiCmnd;
4463 SM_DBG4(("smsatLogSenseCB: Internal smSatInternalIo_t satIntIoContext\n"));
4464 satOrgIOContext = satIOContext->satOrgIOContext;
4465 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
4466 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
4468 pSense = satOrgIOContext->pSense;
4469 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
4470 /* SCSI command response payload to OS layer */
4471 pLogPage = (bit8 *) smOrgScsiRequest->sglVirtualAddr;
4472 /* ATA command response payload */
4473 smScsiRequest = (smScsiInitiatorRequest_t *)&(satIntIo->satIntSmScsiXchg);
4474 scsiCmnd = satOrgIOContext->pScsiCmnd;
4477 smIORequestBody->ioCompleted = agTRUE;
4478 smIORequestBody->ioStarted = agFALSE;
4480 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
4482 SM_DBG1(("smsatLogSenseCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
4489 satOrgIOContext->interruptContext
4491 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4493 smsatFreeIntIoResource( smRoot,
4499 if (agIOStatus != OSSA_IO_SUCCESS)
4501 /* non-data and pio read -> device to host and pio setup fis are expected */
4503 first, assumed to be Reg Device to Host FIS
4504 This is OK to just find fis type
4506 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
4507 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
4510 if( agIOStatus != OSSA_IO_SUCCESS)
4512 if ( ((statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) &&
4513 (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS)) ||
4514 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
4518 if( agIOStatus != OSSA_IO_SUCCESS)
4520 SM_DBG1(("smsatLogSenseCB: FAILED, NOT IO_SUCCESS!!!\n"));
4522 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
4524 SM_DBG1(("smsatLogSenseCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
4526 else if (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS)
4528 SM_DBG1(("smsatLogSenseCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
4530 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
4531 (ataStatus & DF_ATA_STATUS_MASK)
4534 SM_DBG1(("smsatLogSenseCB: FAILED, FAILED, error status!!!\n"));
4537 /* Process abort case */
4538 if (agIOStatus == OSSA_IO_ABORTED)
4540 smsatProcessAbort(smRoot,
4545 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4547 smsatFreeIntIoResource( smRoot,
4554 if (hostToDevFis->h.command == SAT_READ_LOG_EXT)
4556 SM_DBG1(("smsatLogSenseCB: SAT_READ_LOG_EXT failed!!!\n"));
4558 else if (hostToDevFis->h.command == SAT_SMART)
4560 if (hostToDevFis->h.features == SAT_SMART_READ_LOG)
4562 SM_DBG1(("smsatLogSenseCB: SAT_SMART_READ_LOG failed!!!\n"));
4564 else if (hostToDevFis->h.features == SAT_SMART_RETURN_STATUS)
4566 SM_DBG1(("smsatLogSenseCB: SAT_SMART_RETURN_STATUS failed!!!\n"));
4570 SM_DBG1(("smsatLogSenseCB: error unknown command 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features));
4575 SM_DBG1(("smsatLogSenseCB: error default case command 0x%x!!!\n", hostToDevFis->h.command));
4578 smsatSetSensePayload( pSense,
4579 SCSI_SNSKEY_NO_SENSE,
4581 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
4584 tdsmIOCompletedCB( smRoot,
4585 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
4587 SCSI_STAT_CHECK_CONDITION,
4588 satOrgIOContext->pSmSenseData,
4589 satOrgIOContext->interruptContext );
4591 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4593 smsatFreeIntIoResource( smRoot,
4598 } /* error checking */
4601 /* prcessing the success case */
4602 saFrameReadBlock(agRoot, agParam, 0, &statDevToHostFisData, sizeof(agsaFisRegD2HData_t));
4604 allocationLen = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8];
4605 allocationLen = MIN(allocationLen, scsiCmnd->expDataLength);
4606 SM_DBG5(("smsatLogSenseCB: allocationLen in CDB %d 0x%x\n", allocationLen,allocationLen));
4609 if (hostToDevFis->h.command == SAT_READ_LOG_EXT)
4611 SM_DBG5(("smsatLogSenseCB: SAT_READ_LOG_EXT success\n"));
4613 /* process log data and sends it to upper */
4615 /* ATA: Extended Self-Test Log */
4616 virtAddr1 = (satReadLogExtSelfTest_t *)(smScsiRequest->sglVirtualAddr);
4618 ATA/ATAPI VOLII, p197, 287
4619 self-test execution status (4 bits); ((virtAddr1->byte[5] & 0xF0) >> 4)
4621 SelfTestExecutionStatus = (bit8)(((virtAddr1->byte[5] & 0xF0) >> 4));
4623 /* fills in the log page from ATA log page */
4624 /* SPC-4, 7.2.10, Table 216, 217, p 259 - 260 */
4625 LogPage[0] = 0x10; /* page code */
4627 LogPage[2] = 0x01; /* 0x190, page length */
4630 /* SPC-4, Table 217 */
4631 LogPage[4] = 0; /* Parameter Code */
4632 LogPage[5] = 0x01; /* Parameter Code, unspecfied but ... */
4633 LogPage[6] = 3; /* unspecified but ... */
4634 LogPage[7] = 0x10; /* Parameter Length */
4635 LogPage[8] = (bit8)(0 | ((virtAddr1->byte[5] & 0xF0) >> 4)); /* Self Test Code and Self-Test Result */
4636 LogPage[9] = 0; /* self test number */
4637 LogPage[10] = virtAddr1->byte[7]; /* time stamp, MSB */
4638 LogPage[11] = virtAddr1->byte[6]; /* time stamp, LSB */
4640 LogPage[12] = 0; /* address of first failure MSB*/
4641 LogPage[13] = 0; /* address of first failure */
4642 LogPage[14] = virtAddr1->byte[14]; /* address of first failure */
4643 LogPage[15] = virtAddr1->byte[13]; /* address of first failure */
4644 LogPage[16] = virtAddr1->byte[12]; /* address of first failure */
4645 LogPage[17] = virtAddr1->byte[11]; /* address of first failure */
4646 LogPage[18] = virtAddr1->byte[10]; /* address of first failure */
4647 LogPage[19] = virtAddr1->byte[9]; /* address of first failure LSB */
4649 /* SAT rev8 Table75, p 76 */
4650 switch (SelfTestExecutionStatus)
4653 LogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE;
4654 LogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF;
4655 LogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF;
4658 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND;
4659 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4663 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND;
4664 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4668 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND;
4669 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4673 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR;
4674 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4678 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR;
4679 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4683 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR;
4684 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4688 LogPage[20] = 0 | SCSI_SNSKEY_MEDIUM_ERROR;
4689 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4693 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR;
4694 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4697 case 9: /* fall through */
4698 case 10:/* fall through */
4699 case 11:/* fall through */
4700 case 12:/* fall through */
4701 case 13:/* fall through */
4703 LogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE;
4704 LogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF;
4705 LogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF;
4708 LogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE;
4709 LogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF;
4710 LogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF;
4713 SM_DBG1(("smsatLogSenseCB: Error, incorrect SelfTestExecutionStatus 0x%x!!!\n", SelfTestExecutionStatus));
4715 smsatSetSensePayload( pSense,
4716 SCSI_SNSKEY_NO_SENSE,
4718 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
4721 tdsmIOCompletedCB( smRoot,
4722 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
4724 SCSI_STAT_CHECK_CONDITION,
4725 satOrgIOContext->pSmSenseData,
4726 satOrgIOContext->interruptContext );
4728 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4730 smsatFreeIntIoResource( smRoot,
4737 LogPage[23] = 0; /* vendor specific */
4739 /* the rest of Self-test results log */
4740 /* 403 is from SPC-4, 7.2.10, Table 216, p 259*/
4741 for (i=24;i<=403;i++)
4743 LogPage[i] = 0; /* vendor specific */
4746 sm_memcpy(pLogPage, LogPage, MIN(allocationLen, SELFTEST_RESULTS_LOG_PAGE_LENGTH));
4747 if (SELFTEST_RESULTS_LOG_PAGE_LENGTH < allocationLen)
4749 SM_DBG6(("smsatLogSenseCB: 1st underrun allocationLen %d len %d \n", allocationLen, SELFTEST_RESULTS_LOG_PAGE_LENGTH));
4752 tdsmIOCompletedCB( smRoot,
4753 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
4755 allocationLen - SELFTEST_RESULTS_LOG_PAGE_LENGTH,
4757 satOrgIOContext->interruptContext );
4762 tdsmIOCompletedCB( smRoot,
4767 satOrgIOContext->interruptContext);
4770 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4772 smsatFreeIntIoResource( smRoot,
4778 else if (hostToDevFis->h.command == SAT_SMART)
4780 if (hostToDevFis->h.features == SAT_SMART_READ_LOG)
4782 SM_DBG5(("smsatLogSenseCB: SAT_SMART_READ_LOG success\n"));
4783 /* process log data and sends it to upper */
4785 /* ATA: Extended Self-Test Log */
4786 virtAddr2 = (satSmartReadLogSelfTest_t *)(smScsiRequest->sglVirtualAddr);
4789 self-test execution status (4 bits); ((virtAddr2->byte[3] & 0xF0) >> 4)
4791 SelfTestExecutionStatus = (bit8)(((virtAddr2->byte[3] & 0xF0) >> 4));
4793 /* fills in the log page from ATA log page */
4794 /* SPC-4, 7.2.10, Table 216, 217, p 259 - 260 */
4795 LogPage[0] = 0x10; /* page code */
4797 LogPage[2] = 0x01; /* 0x190, page length */
4798 LogPage[3] = 0x90; /* 0x190, page length */
4800 /* SPC-4, Table 217 */
4801 LogPage[4] = 0; /* Parameter Code */
4802 LogPage[5] = 0x01; /* Parameter Code unspecfied but ... */
4803 LogPage[6] = 3; /* unspecified but ... */
4804 LogPage[7] = 0x10; /* Parameter Length */
4805 LogPage[8] = (bit8)(0 | ((virtAddr2->byte[3] & 0xF0) >> 4)); /* Self Test Code and Self-Test Result */
4806 LogPage[9] = 0; /* self test number */
4807 LogPage[10] = virtAddr2->byte[5]; /* time stamp, MSB */
4808 LogPage[11] = virtAddr2->byte[4]; /* time stamp, LSB */
4810 LogPage[12] = 0; /* address of first failure MSB*/
4811 LogPage[13] = 0; /* address of first failure */
4812 LogPage[14] = 0; /* address of first failure */
4813 LogPage[15] = 0; /* address of first failure */
4814 LogPage[16] = virtAddr2->byte[10]; /* address of first failure */
4815 LogPage[17] = virtAddr2->byte[9]; /* address of first failure */
4816 LogPage[18] = virtAddr2->byte[8]; /* address of first failure */
4817 LogPage[19] = virtAddr2->byte[7]; /* address of first failure LSB */
4819 /* SAT rev8 Table75, p 76 */
4820 switch (SelfTestExecutionStatus)
4823 LogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE;
4824 LogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF;
4825 LogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF;
4828 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND;
4829 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4833 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND;
4834 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4838 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND;
4839 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4843 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR;
4844 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4848 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR;
4849 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4853 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR;
4854 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4858 LogPage[20] = 0 | SCSI_SNSKEY_MEDIUM_ERROR;
4859 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4863 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR;
4864 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF;
4867 case 9: /* fall through */
4868 case 10:/* fall through */
4869 case 11:/* fall through */
4870 case 12:/* fall through */
4871 case 13:/* fall through */
4874 LogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE;
4875 LogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF;
4876 LogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF;
4879 LogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE;
4880 LogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF;
4881 LogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF;
4884 SM_DBG1(("smsatLogSenseCB: Error, incorrect SelfTestExecutionStatus 0x%x!!!\n", SelfTestExecutionStatus));
4886 smsatSetSensePayload( pSense,
4887 SCSI_SNSKEY_NO_SENSE,
4889 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
4892 tdsmIOCompletedCB( smRoot,
4893 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
4895 SCSI_STAT_CHECK_CONDITION,
4896 satOrgIOContext->pSmSenseData,
4897 satOrgIOContext->interruptContext );
4899 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4901 smsatFreeIntIoResource( smRoot,
4908 LogPage[23] = 0; /* vendor specific */
4910 /* the rest of Self-test results log */
4911 /* 403 is from SPC-4, 7.2.10, Table 216, p 259*/
4912 for (i=24;i<=403;i++)
4914 LogPage[i] = 0; /* vendor specific */
4917 sm_memcpy(pLogPage, LogPage, MIN(allocationLen, SELFTEST_RESULTS_LOG_PAGE_LENGTH));
4918 if (SELFTEST_RESULTS_LOG_PAGE_LENGTH < allocationLen)
4920 SM_DBG6(("smsatLogSenseCB: 2nd underrun allocationLen %d len %d \n", allocationLen, SELFTEST_RESULTS_LOG_PAGE_LENGTH));
4923 tdsmIOCompletedCB( smRoot,
4924 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
4926 allocationLen - SELFTEST_RESULTS_LOG_PAGE_LENGTH,
4928 satOrgIOContext->interruptContext );
4933 tdsmIOCompletedCB( smRoot,
4938 satOrgIOContext->interruptContext);
4940 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
4942 smsatFreeIntIoResource( smRoot,
4948 else if (hostToDevFis->h.features == SAT_SMART_RETURN_STATUS)
4950 SM_DBG5(("smsatLogSenseCB: SAT_SMART_RETURN_STATUS success\n"));
4952 /* fills in the log page from ATA output */
4953 /* SPC-4, 7.2.5, Table 209, 211, p 255 */
4954 LogPage[0] = 0x2F; /* page code unspecified */
4955 LogPage[1] = 0; /* reserved */
4956 LogPage[2] = 0; /* page length */
4957 LogPage[3] = 0x07; /* page length */
4960 SPC-4, 7.2.5, Table 211, p 255
4961 no vendor specific field
4963 LogPage[4] = 0; /* Parameter Code */
4964 LogPage[5] = 0; /* Parameter Code unspecfied but to do: */
4965 LogPage[6] = 0; /* unspecified */
4966 LogPage[7] = 0x03; /* Parameter length, unspecified */
4968 /* SAT rev8, 10.2.3.1 Table 72, p 73 */
4969 if (statDevToHostFisData.lbaMid == 0x4F || statDevToHostFisData.lbaHigh == 0xC2)
4971 LogPage[8] = 0; /* Sense code */
4972 LogPage[9] = 0; /* Sense code qualifier */
4974 else if (statDevToHostFisData.lbaMid == 0xF4 || statDevToHostFisData.lbaHigh == 0x2C)
4976 LogPage[8] = 0x5D; /* Sense code */
4977 LogPage[9] = 0x10; /* Sense code qualifier */
4980 /* Assumption: No support for SCT */
4981 LogPage[10] = 0xFF; /* Most Recent Temperature Reading */
4983 sm_memcpy(pLogPage, LogPage, MIN(allocationLen, INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH));
4984 if (INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH < allocationLen)
4986 SM_DBG6(("smsatLogSenseCB: 3rd underrun allocationLen %d len %d \n", allocationLen, INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH));
4989 tdsmIOCompletedCB( smRoot,
4990 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
4992 allocationLen - INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH,
4994 satOrgIOContext->interruptContext );
4999 tdsmIOCompletedCB( smRoot,
5004 satOrgIOContext->interruptContext);
5007 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5009 smsatFreeIntIoResource( smRoot,
5018 SM_DBG1(("smsatLogSenseCB: error unknown command success 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features));
5019 smsatSetSensePayload( pSense,
5020 SCSI_SNSKEY_NO_SENSE,
5022 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5025 tdsmIOCompletedCB( smRoot,
5026 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5028 SCSI_STAT_CHECK_CONDITION,
5029 satOrgIOContext->pSmSenseData,
5030 satOrgIOContext->interruptContext );
5031 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5033 smsatFreeIntIoResource( smRoot,
5042 SM_DBG1(("smsatLogSenseCB: error unknown command success 0x%x!!!\n", hostToDevFis->h.command));
5043 smsatSetSensePayload( pSense,
5044 SCSI_SNSKEY_NO_SENSE,
5046 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5049 tdsmIOCompletedCB( smRoot,
5050 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5052 SCSI_STAT_CHECK_CONDITION,
5053 satOrgIOContext->pSmSenseData,
5054 satOrgIOContext->interruptContext );
5056 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5058 smsatFreeIntIoResource( smRoot,
5071 agsaIORequest_t *agIORequest,
5073 agsaFisHeader_t *agFirstDword,
5075 agsaFrameHandle_t agFrameHandle,
5079 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
5080 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
5081 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
5082 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
5083 smRoot_t *smRoot = agNULL;
5084 smIntRoot_t *smIntRoot = agNULL;
5085 smIntContext_t *smAllShared = agNULL;
5086 smIORequestBody_t *smIORequestBody;
5087 smIORequestBody_t *smOrgIORequestBody;
5088 smSatIOContext_t *satIOContext;
5089 smSatIOContext_t *satOrgIOContext;
5090 smSatIOContext_t *satNewIOContext;
5091 smSatInternalIo_t *satIntIo;
5092 smSatInternalIo_t *satNewIntIo = agNULL;
5093 // satDeviceData_t *satDevData;
5094 smDeviceData_t *oneDeviceData;
5095 smIniScsiCmnd_t *scsiCmnd;
5096 smIORequest_t *smOrgIORequest;
5099 SM_DBG2(("smsatSMARTEnableCB: start\n"));
5100 SM_DBG4(("smsatSMARTEnableCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
5102 /* internally generate tiIOContext */
5103 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
5104 satIOContext = (smSatIOContext_t *) ioContext;
5105 satIntIo = satIOContext->satIntIoContext;
5106 oneDeviceData = satIOContext->pSatDevData;
5107 smRoot = oneDeviceData->smRoot;
5108 smIntRoot = (smIntRoot_t *)smRoot->smData;
5109 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
5111 if (satIntIo == agNULL)
5113 SM_DBG4(("smsatSMARTEnableCB: External smSatInternalIo_t satIntIoContext\n"));
5114 satOrgIOContext = satIOContext;
5115 smOrgIORequest = smIORequestBody->smIORequest;
5116 scsiCmnd = satOrgIOContext->pScsiCmnd;
5120 SM_DBG4(("smsatSMARTEnableCB: Internal smSatInternalIo_t satIntIoContext\n"));
5121 satOrgIOContext = satIOContext->satOrgIOContext;
5122 if (satOrgIOContext == agNULL)
5124 SM_DBG4(("smsatSMARTEnableCB: satOrgIOContext is NULL, wrong\n"));
5129 SM_DBG4(("smsatSMARTEnableCB: satOrgIOContext is NOT NULL\n"));
5131 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
5132 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
5133 scsiCmnd = satOrgIOContext->pScsiCmnd;
5135 smIORequestBody->ioCompleted = agTRUE;
5136 smIORequestBody->ioStarted = agFALSE;
5138 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
5140 SM_DBG1(("smsatSMARTEnableCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
5147 satOrgIOContext->interruptContext
5149 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5150 smsatFreeIntIoResource( smRoot,
5156 checking IO status, FIS type and error status
5158 if (agIOStatus != OSSA_IO_SUCCESS)
5160 SM_DBG1(("smsatSMARTEnableCB: not success status, status %d!!!\n", agIOStatus));
5167 satOrgIOContext->interruptContext
5169 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5170 smsatFreeIntIoResource( smRoot,
5175 /* process success case */
5176 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5177 smsatFreeIntIoResource( smRoot,
5180 satNewIntIo = smsatAllocIntIoResource( smRoot,
5185 if (satNewIntIo == agNULL)
5193 satOrgIOContext->interruptContext
5197 satNewIOContext = smsatPrepareNewIO(
5204 status = smsatLogSense_1(smRoot,
5205 &satNewIntIo->satIntSmIORequest,
5206 satNewIOContext->psmDeviceHandle,
5207 &satNewIntIo->satIntSmScsiXchg,
5209 if (status != SM_RC_SUCCESS)
5211 /* sending SAT_CHECK_POWER_MODE fails */
5212 smsatFreeIntIoResource( smRoot,
5221 satOrgIOContext->interruptContext
5229 smsatModeSelect6n10CB(
5231 agsaIORequest_t *agIORequest,
5233 agsaFisHeader_t *agFirstDword,
5235 agsaFrameHandle_t agFrameHandle,
5239 smRoot_t *smRoot = agNULL;
5240 smIntRoot_t *smIntRoot = agNULL;
5241 smIntContext_t *smAllShared = agNULL;
5242 smIORequestBody_t *smIORequestBody;
5243 smIORequestBody_t *smOrgIORequestBody;
5244 smSatIOContext_t *satIOContext;
5245 smSatIOContext_t *satOrgIOContext;
5246 smSatIOContext_t *satNewIOContext;
5247 smSatInternalIo_t *satIntIo;
5248 smSatInternalIo_t *satNewIntIo = agNULL;
5249 // satDeviceData_t *satDevData;
5250 smDeviceData_t *oneDeviceData;
5252 smScsiRspSense_t *pSense;
5253 smIniScsiCmnd_t *scsiCmnd;
5254 smIORequest_t *smOrgIORequest;
5256 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
5257 bit32 ataStatus = 0;
5259 smScsiInitiatorRequest_t *smScsiRequest; /* smScsiXchg */
5260 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
5262 SM_DBG2(("smsatModeSelect6n10CB: start\n"));
5263 SM_DBG5(("smsatModeSelect6n10CB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
5265 /* internally generate smIOContext */
5266 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
5267 satIOContext = (smSatIOContext_t *) ioContext;
5268 satIntIo = satIOContext->satIntIoContext;
5269 oneDeviceData = satIOContext->pSatDevData;
5270 hostToDevFis = satIOContext->pFis;
5271 smRoot = oneDeviceData->smRoot;
5272 smIntRoot = (smIntRoot_t *)smRoot->smData;
5273 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
5275 if (satIntIo == agNULL)
5277 SM_DBG4(("smsatModeSelect6n10CB: External smSatInternalIo_t satIntIoContext\n"));
5278 satOrgIOContext = satIOContext;
5279 smOrgIORequest = smIORequestBody->smIORequest;
5280 smScsiRequest = satOrgIOContext->smScsiXchg;
5281 pSense = satOrgIOContext->pSense;
5282 scsiCmnd = satOrgIOContext->pScsiCmnd;
5286 SM_DBG4(("smsatModeSelect6n10CB: Internal smSatInternalIo_t satIntIoContext\n"));
5287 satOrgIOContext = satIOContext->satOrgIOContext;
5288 if (satOrgIOContext == agNULL)
5290 SM_DBG4(("smsatModeSelect6n10CB: satOrgIOContext is NULL, wrong\n"));
5295 SM_DBG4(("smsatModeSelect6n10CB: satOrgIOContext is NOT NULL\n"));
5297 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
5298 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
5300 smScsiRequest = satOrgIOContext->smScsiXchg;
5301 pSense = satOrgIOContext->pSense;
5302 scsiCmnd = satOrgIOContext->pScsiCmnd;
5305 smIORequestBody->ioCompleted = agTRUE;
5306 smIORequestBody->ioStarted = agFALSE;
5308 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
5310 SM_DBG1(("smsatModeSelect6n10CB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
5317 satOrgIOContext->interruptContext
5319 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5321 smsatFreeIntIoResource( smRoot,
5327 if (agIOStatus != OSSA_IO_SUCCESS)
5329 /* only agsaFisRegDeviceToHost_t is expected */
5330 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
5331 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
5334 if (agIOStatus != OSSA_IO_SUCCESS)
5336 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) ||
5337 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
5341 if( agIOStatus != OSSA_IO_SUCCESS)
5343 SM_DBG1(("smsatModeSelect6n10CB: FAILED, NOT IO_SUCCESS!!!\n"));
5345 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
5347 SM_DBG1(("smsatModeSelect6n10CB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
5349 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
5350 (ataStatus & DF_ATA_STATUS_MASK)
5353 SM_DBG1(("smsatModeSelect6n10CB: FAILED, FAILED, error status!!!\n"));
5356 /* Process abort case */
5357 if (agIOStatus == OSSA_IO_ABORTED)
5359 smsatProcessAbort(smRoot,
5364 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5366 smsatFreeIntIoResource( smRoot,
5373 if (hostToDevFis->h.command == SAT_SET_FEATURES)
5375 if ((hostToDevFis->h.features == 0x82) || (hostToDevFis->h.features == 0x02))
5377 SM_DBG1(("smsatModeSelect6n10CB: 1 SAT_SET_FEATURES failed, feature 0x%x!!!\n", hostToDevFis->h.features));
5379 else if ((hostToDevFis->h.features == 0xAA) || (hostToDevFis->h.features == 0x55))
5381 SM_DBG1(("smsatModeSelect6n10CB: 2 SAT_SET_FEATURES failed, feature 0x%x!!!\n", hostToDevFis->h.features));
5385 SM_DBG1(("smsatModeSelect6n10CB: error unknown command 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features));
5388 else if (hostToDevFis->h.command == SAT_SMART)
5390 if ((hostToDevFis->h.features == SAT_SMART_ENABLE_OPERATIONS) || (hostToDevFis->h.features == SAT_SMART_DISABLE_OPERATIONS))
5392 SM_DBG1(("smsatModeSelect6n10CB: SAT_SMART_ENABLE/DISABLE_OPERATIONS failed, feature 0x%x!!!\n", hostToDevFis->h.features));
5396 SM_DBG1(("smsatModeSelect6n10CB: error unknown command 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features));
5401 SM_DBG1(("smsatModeSelect6n10CB: error default case command 0x%x!!!\n", hostToDevFis->h.command));
5405 smsatSetSensePayload( pSense,
5406 SCSI_SNSKEY_NO_SENSE,
5408 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5411 tdsmIOCompletedCB( smRoot,
5412 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5414 SCSI_STAT_CHECK_CONDITION,
5415 satOrgIOContext->pSmSenseData,
5416 satOrgIOContext->interruptContext );
5419 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5421 smsatFreeIntIoResource( smRoot,
5425 } /* error checking */
5429 /* prcessing the success case */
5432 if (hostToDevFis->h.command == SAT_SET_FEATURES)
5434 if ((hostToDevFis->h.features == 0x82) || (hostToDevFis->h.features == 0x02))
5436 SM_DBG5(("smsatModeSelect6n10CB: 1 SAT_SET_FEATURES success, feature 0x%x\n", hostToDevFis->h.features));
5437 if (hostToDevFis->h.features == 0x02)
5439 /* enable write cache */
5440 oneDeviceData->satWriteCacheEnabled = agTRUE;
5444 /* disable write cache */
5445 oneDeviceData->satWriteCacheEnabled = agFALSE;
5448 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5450 smsatFreeIntIoResource( smRoot,
5454 satNewIntIo = smsatAllocIntIoResource( smRoot,
5459 if (satNewIntIo == agNULL)
5461 smsatSetSensePayload( pSense,
5462 SCSI_SNSKEY_NO_SENSE,
5464 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5467 tdsmIOCompletedCB( smRoot,
5468 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5470 SCSI_STAT_CHECK_CONDITION,
5471 satOrgIOContext->pSmSenseData,
5472 satOrgIOContext->interruptContext );
5473 SM_DBG1(("smsatModeSelect6n10CB: momory allocation fails!!!\n"));
5475 } /* end memory allocation */
5477 satNewIOContext = smsatPrepareNewIO(
5484 /* sends either ATA SET FEATURES based on DRA bit */
5485 status = smsatModeSelect6n10_1( smRoot,
5486 &satNewIntIo->satIntSmIORequest,
5487 satNewIOContext->psmDeviceHandle,
5488 smScsiRequest, /* orginal from OS layer */
5492 if (status != SM_RC_SUCCESS)
5494 /* sending ATA command fails */
5495 smsatFreeIntIoResource( smRoot,
5498 smsatSetSensePayload( pSense,
5499 SCSI_SNSKEY_NO_SENSE,
5501 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5504 tdsmIOCompletedCB( smRoot,
5505 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5507 SCSI_STAT_CHECK_CONDITION,
5508 satOrgIOContext->pSmSenseData,
5509 satOrgIOContext->interruptContext );
5510 SM_DBG1(("smsatModeSelect6n10CB: calling satModeSelect6_1 fails!!!\n"));
5512 } /* end send fails */
5515 else if ((hostToDevFis->h.features == 0xAA) || (hostToDevFis->h.features == 0x55))
5517 SM_DBG5(("smsatModeSelect6n10CB: 2 SAT_SET_FEATURES success, feature 0x%x\n", hostToDevFis->h.features));
5519 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5521 smsatFreeIntIoResource( smRoot,
5525 /* return stat_good */
5526 tdsmIOCompletedCB( smRoot,
5531 satOrgIOContext->interruptContext );
5536 SM_DBG1(("smsatModeSelect6n10CB: error unknown command success 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features));
5538 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5540 smsatFreeIntIoResource( smRoot,
5543 smsatSetSensePayload( pSense,
5544 SCSI_SNSKEY_NO_SENSE,
5546 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5549 tdsmIOCompletedCB( smRoot,
5550 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5552 SCSI_STAT_CHECK_CONDITION,
5553 satOrgIOContext->pSmSenseData,
5554 satOrgIOContext->interruptContext );
5558 else if (hostToDevFis->h.command == SAT_SMART )
5560 if ((hostToDevFis->h.features == SAT_SMART_ENABLE_OPERATIONS) || (hostToDevFis->h.features == SAT_SMART_DISABLE_OPERATIONS))
5562 SM_DBG5(("smsatModeSelect6n10CB: SAT_SMART_ENABLE/DISABLE_OPERATIONS success, feature 0x%x\n", hostToDevFis->h.features));
5564 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5566 smsatFreeIntIoResource( smRoot,
5569 /* return stat_good */
5570 tdsmIOCompletedCB( smRoot,
5575 satOrgIOContext->interruptContext );
5580 SM_DBG1(("smsatModeSelect6n10CB: error unknown command failed 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features));
5582 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5584 smsatFreeIntIoResource( smRoot,
5587 smsatSetSensePayload( pSense,
5588 SCSI_SNSKEY_NO_SENSE,
5590 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5593 tdsmIOCompletedCB( smRoot,
5594 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5596 SCSI_STAT_CHECK_CONDITION,
5597 satOrgIOContext->pSmSenseData,
5598 satOrgIOContext->interruptContext );
5605 SM_DBG1(("smsatModeSelect6n10CB: error default case command success 0x%x!!!\n", hostToDevFis->h.command));
5607 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5609 smsatFreeIntIoResource( smRoot,
5613 smsatSetSensePayload( pSense,
5614 SCSI_SNSKEY_NO_SENSE,
5616 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5619 tdsmIOCompletedCB( smRoot,
5620 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5622 SCSI_STAT_CHECK_CONDITION,
5623 satOrgIOContext->pSmSenseData,
5624 satOrgIOContext->interruptContext );
5633 smsatSynchronizeCache10n16CB(
5635 agsaIORequest_t *agIORequest,
5637 agsaFisHeader_t *agFirstDword,
5639 agsaFrameHandle_t agFrameHandle,
5644 In the process of SynchronizeCache10 and SynchronizeCache16
5645 Process SAT_FLUSH_CACHE_EXT
5646 Process SAT_FLUSH_CACHE
5650 smRoot_t *smRoot = agNULL;
5651 smIntRoot_t *smIntRoot = agNULL;
5652 smIntContext_t *smAllShared = agNULL;
5653 smIORequestBody_t *smIORequestBody;
5654 smIORequestBody_t *smOrgIORequestBody;
5655 smSatIOContext_t *satIOContext;
5656 smSatIOContext_t *satOrgIOContext;
5657 smSatInternalIo_t *satIntIo;
5658 smDeviceData_t *oneDeviceData;
5660 smScsiRspSense_t *pSense;
5661 smIniScsiCmnd_t *scsiCmnd;
5662 smIORequest_t *smOrgIORequest;
5664 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
5665 bit32 ataStatus = 0;
5666 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
5668 SM_DBG2(("smsatSynchronizeCache10n16CB: start\n"));
5669 SM_DBG5(("smsatSynchronizeCache10n16CB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
5671 /* internally generate smIOContext */
5672 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
5673 satIOContext = (smSatIOContext_t *) ioContext;
5674 satIntIo = satIOContext->satIntIoContext;
5675 oneDeviceData = satIOContext->pSatDevData;
5676 hostToDevFis = satIOContext->pFis;
5677 smRoot = oneDeviceData->smRoot;
5678 smIntRoot = (smIntRoot_t *)smRoot->smData;
5679 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
5681 /* SPC: Self-Test Result Log page */
5682 if (satIntIo == agNULL)
5684 SM_DBG4(("smsatSynchronizeCache10n16CB: External smSatInternalIo_t satIntIoContext\n"));
5685 satOrgIOContext = satIOContext;
5686 smOrgIORequest = smIORequestBody->smIORequest;
5687 pSense = satIOContext->pSense;
5688 scsiCmnd = satIOContext->pScsiCmnd;
5692 SM_DBG4(("smsatSynchronizeCache10n16CB: Internal smSatInternalIo_t satIntIoContext\n"));
5693 satOrgIOContext = satIOContext->satOrgIOContext;
5694 if (satOrgIOContext == agNULL)
5696 SM_DBG4(("smsatSynchronizeCache10n16CB: satOrgIOContext is NULL, wrong\n"));
5701 SM_DBG4(("smsatSynchronizeCache10n16CB: satOrgIOContext is NOT NULL\n"));
5703 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
5704 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
5706 pSense = satOrgIOContext->pSense;
5707 scsiCmnd = satOrgIOContext->pScsiCmnd;
5710 smIORequestBody->ioCompleted = agTRUE;
5711 smIORequestBody->ioStarted = agFALSE;
5713 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
5715 SM_DBG1(("smsatSynchronizeCache10n16CB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
5723 satOrgIOContext->interruptContext
5725 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5727 smsatFreeIntIoResource( smRoot,
5733 if( agIOStatus != OSSA_IO_SUCCESS)
5735 /* only agsaFisRegDeviceToHost_t is expected */
5736 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
5737 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
5740 if( agIOStatus != OSSA_IO_SUCCESS)
5742 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) ||
5743 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
5747 if( agIOStatus != OSSA_IO_SUCCESS)
5749 SM_DBG1(("smsatSynchronizeCache10n16CB: FAILED, NOT IO_SUCCESS!!!\n"));
5751 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
5753 SM_DBG1(("smsatSynchronizeCache10n16CB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
5755 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
5756 (ataStatus & DF_ATA_STATUS_MASK)
5759 SM_DBG1(("smsatSynchronizeCache10n16CB: FAILED, FAILED, error status!!!\n"));
5763 /* Process abort case */
5764 if (agIOStatus == OSSA_IO_ABORTED)
5766 smsatProcessAbort(smRoot,
5771 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5773 smsatFreeIntIoResource( smRoot,
5779 switch (hostToDevFis->h.command)
5781 case SAT_FLUSH_CACHE:
5782 SM_DBG1(("smsatSynchronizeCache10n16CB: SAT_FLUSH_CACHE failed!!!\n"));
5783 /* checking IMMED bit */
5784 if (scsiCmnd->cdb[1] & SCSI_FLUSH_CACHE_IMMED_MASK)
5786 smsatSetDeferredSensePayload( pSense,
5787 SCSI_SNSKEY_NO_SENSE,
5789 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5794 smsatSetDeferredSensePayload( pSense,
5795 SCSI_SNSKEY_NO_SENSE,
5797 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5802 tdsmIOCompletedCB( smRoot,
5803 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5805 SCSI_STAT_CHECK_CONDITION,
5806 satOrgIOContext->pSmSenseData,
5807 satOrgIOContext->interruptContext );
5809 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5811 smsatFreeIntIoResource( smRoot,
5816 case SAT_FLUSH_CACHE_EXT:
5817 SM_DBG1(("smsatSynchronizeCache10n16CB: SAT_FLUSH_CACHE_EXT failed!!!\n"));
5818 /* checking IMMED bit */
5819 if (scsiCmnd->cdb[1] & SCSI_FLUSH_CACHE_IMMED_MASK)
5821 smsatSetDeferredSensePayload( pSense,
5822 SCSI_SNSKEY_NO_SENSE,
5824 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5829 smsatSetDeferredSensePayload( pSense,
5830 SCSI_SNSKEY_NO_SENSE,
5832 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5837 tdsmIOCompletedCB( smRoot,
5838 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5840 SCSI_STAT_CHECK_CONDITION,
5841 satOrgIOContext->pSmSenseData,
5842 satOrgIOContext->interruptContext );
5844 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5846 smsatFreeIntIoResource( smRoot,
5852 SM_DBG1(("smsatSynchronizeCache10n16CB: error unknown command 0x%x!!!\n", hostToDevFis->h.command));
5853 smsatSetSensePayload( pSense,
5854 SCSI_SNSKEY_NO_SENSE,
5856 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5860 tdsmIOCompletedCB( smRoot,
5861 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5863 SCSI_STAT_CHECK_CONDITION,
5864 satOrgIOContext->pSmSenseData,
5865 satOrgIOContext->interruptContext );
5867 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5869 smsatFreeIntIoResource( smRoot,
5877 } /* end of error checking */
5880 /* prcessing the success case */
5881 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
5883 smsatFreeIntIoResource( smRoot,
5888 switch (hostToDevFis->h.command)
5890 case SAT_FLUSH_CACHE:
5891 SM_DBG5(("smsatSynchronizeCache10n16CB: SAT_FLUSH_CACHE success\n"));
5893 /* checking IMMED bit */
5894 if ( !(scsiCmnd->cdb[1] & SCSI_FLUSH_CACHE_IMMED_MASK))
5896 tdsmIOCompletedCB( smRoot,
5897 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5901 satOrgIOContext->interruptContext );
5907 case SAT_FLUSH_CACHE_EXT:
5908 SM_DBG5(("smsatSynchronizeCache10n16CB: SAT_FLUSH_CACHE_EXT success\n"));
5910 /* checking IMMED bit */
5911 if ( !(scsiCmnd->cdb[1] & SCSI_FLUSH_CACHE_IMMED_MASK))
5913 tdsmIOCompletedCB( smRoot,
5914 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5918 satOrgIOContext->interruptContext );
5924 SM_DBG5(("smsatSynchronizeCache10n16CB: error unknown command 0x%x\n", hostToDevFis->h.command));
5925 smsatSetSensePayload( pSense,
5926 SCSI_SNSKEY_NO_SENSE,
5928 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
5932 tdsmIOCompletedCB( smRoot,
5933 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
5935 SCSI_STAT_CHECK_CONDITION,
5936 satOrgIOContext->pSmSenseData,
5937 satOrgIOContext->interruptContext );
5948 smsatNonChainedWriteNVerifyCB(
5950 agsaIORequest_t *agIORequest,
5952 agsaFisHeader_t *agFirstDword,
5959 In the process of WriteAndVerify10
5960 Process SAT_WRITE_DMA_FUA_EXT
5961 Process SAT_WRITE_DMA_EXT
5962 Process SAT_WRITE_SECTORS_EXT
5963 Process SAT_WRITE_FPDMA_QUEUED
5964 Process SAT_READ_VERIFY_SECTORS
5965 Process SAT_READ_VERIFY_SECTORS_EXT
5970 smRoot_t *smRoot = agNULL;
5971 smIntRoot_t *smIntRoot = agNULL;
5972 smIntContext_t *smAllShared = agNULL;
5973 smIORequestBody_t *smIORequestBody;
5974 smIORequestBody_t *smOrgIORequestBody;
5975 smSatIOContext_t *satIOContext;
5976 smSatIOContext_t *satOrgIOContext;
5977 smSatIOContext_t *satNewIOContext;
5978 smSatInternalIo_t *satIntIo;
5979 smSatInternalIo_t *satNewIntIo = agNULL;
5980 // satDeviceData_t *satDevData;
5981 smDeviceData_t *oneDeviceData;
5983 smScsiRspSense_t *pSense;
5984 smIniScsiCmnd_t *scsiCmnd;
5985 smIORequest_t *smOrgIORequest;
5987 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
5988 bit32 ataStatus = 0;
5990 smScsiInitiatorRequest_t *smScsiRequest; /* smScsiXchg */
5991 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
5992 agsaFisSetDevBitsHeader_t *statSetDevBitFisHeader = agNULL;
5994 /* internally generate smIOContext */
5995 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
5996 satIOContext = (smSatIOContext_t *) ioContext;
5997 satIntIo = satIOContext->satIntIoContext;
5998 oneDeviceData = satIOContext->pSatDevData;
5999 hostToDevFis = satIOContext->pFis;
6000 smRoot = oneDeviceData->smRoot;
6001 smIntRoot = (smIntRoot_t *)smRoot->smData;
6002 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
6004 /* SPC: Self-Test Result Log page */
6005 smScsiRequest = satIOContext->smScsiXchg;
6007 SM_DBG2(("smsatNonChainedWriteNVerifyCB: start\n"));
6008 SM_DBG5(("smsatNonChainedWriteNVerifyCB: start agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
6011 if (satIntIo == agNULL)
6013 SM_DBG4(("smsatNonChainedWriteNVerifyCB: External smSatInternalIo_t satIntIoContext\n"));
6014 satOrgIOContext = satIOContext;
6015 smOrgIORequest = smIORequestBody->smIORequest;
6016 pSense = satOrgIOContext->pSense;
6017 scsiCmnd = satOrgIOContext->pScsiCmnd;
6021 SM_DBG4(("smsatNonChainedWriteNVerifyCB: Internal smSatInternalIo_t satIntIoContext\n"));
6022 satOrgIOContext = satIOContext->satOrgIOContext;
6023 if (satOrgIOContext == agNULL)
6025 SM_DBG4(("smsatNonChainedWriteNVerifyCB: satOrgIOContext is NULL, wrong\n"));
6030 SM_DBG4(("smsatNonChainedWriteNVerifyCB: satOrgIOContext is NOT NULL\n"));
6032 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
6033 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
6035 pSense = satOrgIOContext->pSense;
6036 scsiCmnd = satOrgIOContext->pScsiCmnd;
6039 smIORequestBody->ioCompleted = agTRUE;
6040 smIORequestBody->ioStarted = agFALSE;
6043 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
6045 SM_DBG1(("smsatNonChainedWriteNVerifyCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
6046 tdsmIOCompletedCB( smRoot,
6051 satOrgIOContext->interruptContext
6053 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6055 smsatFreeIntIoResource( smRoot,
6062 if (agIOStatus != OSSA_IO_SUCCESS)
6065 FIS type should be either REG_DEV_TO_HOST_FIS or SET_DEV_BITS_FIS
6067 /* First, assumed to be Reg Device to Host FIS */
6068 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
6069 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
6072 if (agIOStatus != OSSA_IO_SUCCESS)
6074 if (statDevToHostFisHeader->fisType == SET_DEV_BITS_FIS)
6076 statSetDevBitFisHeader = (agsaFisSetDevBitsHeader_t *)&(agFirstDword->D2H);
6078 /* Get ATA Status register */
6079 ataStatus = (statSetDevBitFisHeader->statusHi_Lo & 0x70); /* bits 4,5,6 */
6080 ataStatus = ataStatus | (statSetDevBitFisHeader->statusHi_Lo & 0x07); /* bits 0,1,2 */
6085 if( agIOStatus != OSSA_IO_SUCCESS)
6088 checking IO status, FIS type and error status
6089 FIS type should be either REG_DEV_TO_HOST_FIS or SET_DEV_BITS_FIS
6090 Both have fisType in the same location
6092 if ( ((statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) &&
6093 (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS)) ||
6094 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
6098 if( agIOStatus != OSSA_IO_SUCCESS)
6100 SM_DBG1(("smsatNonChainedWriteNVerifyCB: FAILED, NOT IO_SUCCESS!!!\n"));
6102 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
6104 SM_DBG1(("smsatNonChainedWriteNVerifyCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
6106 else if (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS)
6108 SM_DBG1(("smsatNonChainedWriteNVerifyCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
6110 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
6111 (ataStatus & DF_ATA_STATUS_MASK)
6114 SM_DBG1(("smsatNonChainedWriteNVerifyCB: FAILED, FAILED, error status!!!\n"));
6118 /* Process abort case */
6119 if (agIOStatus == OSSA_IO_ABORTED)
6121 smsatProcessAbort(smRoot,
6126 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6128 smsatFreeIntIoResource( smRoot,
6135 switch (hostToDevFis->h.command)
6137 case SAT_WRITE_DMA_FUA_EXT:
6138 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_DMA_FUA_EXT!!!\n"));
6140 case SAT_WRITE_DMA_EXT:
6141 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_DMA_EXT!!!\n"));
6143 case SAT_WRITE_SECTORS_EXT:
6144 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_SECTORS_EXT!!!\n"));
6146 case SAT_WRITE_FPDMA_QUEUED:
6147 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_FPDMA_QUEUED!!!\n"));
6149 case SAT_READ_VERIFY_SECTORS:
6150 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS!!!\n"));
6152 case SAT_READ_VERIFY_SECTORS_EXT:
6153 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS_EXT!!!\n"));
6156 SM_DBG1(("smsatNonChainedWriteNVerifyCB: error default case command 0x%x!!!\n", hostToDevFis->h.command));
6160 smsatSetSensePayload( pSense,
6161 SCSI_SNSKEY_NO_SENSE,
6163 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
6166 tdsmIOCompletedCB( smRoot,
6167 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6169 SCSI_STAT_CHECK_CONDITION,
6170 satOrgIOContext->pSmSenseData,
6171 satOrgIOContext->interruptContext );
6173 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6175 smsatFreeIntIoResource( smRoot,
6179 } /* end error checking */
6182 /* process success from this point on */
6184 switch (hostToDevFis->h.command)
6186 case SAT_WRITE_DMA_FUA_EXT:
6187 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_DMA_FUA_EXT success\n"));
6189 case SAT_WRITE_DMA_EXT:
6190 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_DMA_EXT success\n"));
6192 case SAT_WRITE_SECTORS_EXT:
6193 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_SECTORS_EXT succes\n"));
6196 case SAT_WRITE_FPDMA_QUEUED:
6197 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_FPDMA_QUEUED succes\n"));
6199 case SAT_READ_VERIFY_SECTORS:
6200 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS succes\n"));
6201 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6204 smsatFreeIntIoResource( smRoot,
6208 /* return stat_good */
6209 tdsmIOCompletedCB( smRoot,
6214 satOrgIOContext->interruptContext );
6217 case SAT_READ_VERIFY_SECTORS_EXT:
6218 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS_EXT succes\n"));
6219 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6222 smsatFreeIntIoResource( smRoot,
6226 /* return stat_good */
6227 tdsmIOCompletedCB( smRoot,
6232 satOrgIOContext->interruptContext );
6236 SM_DBG1(("smsatNonChainedWriteNVerifyCB: error default case command 0x%x success!!!\n", hostToDevFis->h.command));
6238 smsatSetSensePayload( pSense,
6239 SCSI_SNSKEY_NO_SENSE,
6241 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
6244 tdsmIOCompletedCB( smRoot,
6245 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6247 SCSI_STAT_CHECK_CONDITION,
6248 satOrgIOContext->pSmSenseData,
6249 satOrgIOContext->interruptContext );
6251 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6253 smsatFreeIntIoResource( smRoot,
6260 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6263 smsatFreeIntIoResource( smRoot,
6267 satNewIntIo = smsatAllocIntIoResource( smRoot,
6272 if (satNewIntIo == agNULL)
6274 smsatSetSensePayload( pSense,
6275 SCSI_SNSKEY_NO_SENSE,
6277 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
6280 tdsmIOCompletedCB( smRoot,
6281 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6283 SCSI_STAT_CHECK_CONDITION,
6284 satOrgIOContext->pSmSenseData,
6285 satOrgIOContext->interruptContext );
6286 SM_DBG1(("smsatNonChainedWriteNVerifyCB: momory allocation fails!!!\n"));
6288 } /* end memory allocation */
6290 satNewIOContext = smsatPrepareNewIO(satNewIntIo,
6297 /* sends ATA verify command(READ_VERIFY_SECTORS or READ_VERIFY_SECTORS_EXT) */
6298 status = smsatNonChainedWriteNVerify_Verify(smRoot,
6299 &satNewIntIo->satIntSmIORequest,
6300 satNewIOContext->psmDeviceHandle,
6301 smScsiRequest, /* orginal from OS layer */
6306 if (status != SM_RC_SUCCESS)
6308 /* sending ATA command fails */
6309 smsatFreeIntIoResource( smRoot,
6312 smsatSetSensePayload( pSense,
6313 SCSI_SNSKEY_NO_SENSE,
6315 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
6318 tdsmIOCompletedCB( smRoot,
6319 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6321 SCSI_STAT_CHECK_CONDITION,
6322 satOrgIOContext->pSmSenseData,
6323 satOrgIOContext->interruptContext );
6324 SM_DBG1(("smsatNonChainedWriteNVerifyCB: calling satWriteAndVerify10_1 fails!!!\n"));
6326 } /* end send fails */
6333 smsatChainedWriteNVerifyCB(
6335 agsaIORequest_t *agIORequest,
6337 agsaFisHeader_t *agFirstDword,
6345 then, send verify in loop
6348 smRoot_t *smRoot = agNULL;
6349 smIntRoot_t *smIntRoot = agNULL;
6350 smIntContext_t *smAllShared = agNULL;
6351 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
6352 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
6353 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
6354 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6355 smIORequestBody_t *smIORequestBody;
6356 smIORequestBody_t *smOrgIORequestBody;
6357 smSatIOContext_t *satIOContext;
6358 smSatIOContext_t *satOrgIOContext;
6359 smSatIOContext_t *satNewIOContext;
6360 smSatInternalIo_t *satIntIo;
6361 smSatInternalIo_t *satNewIntIo = agNULL;
6362 // satDeviceData_t *satDevData;
6363 smDeviceData_t *oneDeviceData;
6365 smScsiRspSense_t *pSense;
6366 smIniScsiCmnd_t *scsiCmnd;
6367 smIORequest_t *smOrgIORequest;
6368 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
6369 bit32 ataStatus = 0;
6371 bit32 status = tiError;
6372 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
6374 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
6375 satIOContext = (smSatIOContext_t *) ioContext;
6376 satIntIo = satIOContext->satIntIoContext;
6377 oneDeviceData = satIOContext->pSatDevData;
6378 hostToDevFis = satIOContext->pFis;
6379 smRoot = oneDeviceData->smRoot;
6380 smIntRoot = (smIntRoot_t *)smRoot->smData;
6381 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
6382 SM_DBG2(("smsatChainedWriteNVerifyCB: start\n"));
6383 SM_DBG6(("smsatChainedWriteNVerifyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n",
6384 agIORequest, agIOStatus, agIOInfoLen));
6386 if (satIntIo == agNULL)
6388 SM_DBG5(("smsatChainedWriteNVerifyCB: External smSatInternalIo_t satIntIoContext\n"));
6389 satOrgIOContext = satIOContext;
6390 smOrgIORequest = smIORequestBody->smIORequest;
6391 pSense = satIOContext->pSense;
6392 scsiCmnd = satIOContext->pScsiCmnd;
6396 SM_DBG5(("smsatChainedWriteNVerifyCB: Internal smSatInternalIo_t satIntIoContext\n"));
6397 satOrgIOContext = satIOContext->satOrgIOContext;
6398 if (satOrgIOContext == agNULL)
6400 SM_DBG5(("smsatChainedWriteNVerifyCB: satOrgIOContext is NULL, wrong\n"));
6405 SM_DBG5(("smsatChainedWriteNVerifyCB: satOrgIOContext is NOT NULL\n"));
6407 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
6408 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
6410 pSense = satOrgIOContext->pSense;
6411 scsiCmnd = satOrgIOContext->pScsiCmnd;
6414 smIORequestBody->ioCompleted = agTRUE;
6415 smIORequestBody->ioStarted = agFALSE;
6417 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
6419 SM_DBG1(("smsatChainedWriteNVerifyCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
6420 smsatSetSensePayload( pSense,
6421 SCSI_SNSKEY_NO_SENSE,
6423 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
6426 tdsmIOCompletedCB( smRoot,
6427 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6429 SCSI_STAT_CHECK_CONDITION,
6430 satOrgIOContext->pSmSenseData,
6431 satOrgIOContext->interruptContext );
6433 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6435 smsatFreeIntIoResource( smRoot,
6442 checking IO status, FIS type and error status
6444 if (agIOStatus != OSSA_IO_SUCCESS)
6446 /* agsaFisPioSetup_t or agsaFisRegDeviceToHost_t or agsaFisSetDevBits_t for read
6447 agsaFisRegDeviceToHost_t or agsaFisSetDevBits_t for write
6448 first, assumed to be Reg Device to Host FIS
6449 This is OK to just find fis type
6451 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
6452 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
6454 if( (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS) &&
6455 (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) &&
6456 (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS)
6459 SM_DBG1(("smsatChainedWriteNVerifyCB: FAILED, Wrong FIS type 0x%x!!!\n", statDevToHostFisHeader->fisType));
6463 if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
6464 (ataStatus & DF_ATA_STATUS_MASK)
6467 SM_DBG1(("smsatChainedWriteNVerifyCB: FAILED, error status and command 0x%x!!!\n", hostToDevFis->h.command));
6470 /* the function below handles abort case */
6471 smsatDelayedProcessAbnormalCompletion(agRoot,
6479 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6480 smsatFreeIntIoResource( smRoot,
6484 } /* end of error */
6486 /* process the success case */
6487 switch (hostToDevFis->h.command)
6489 case SAT_WRITE_DMA: /* fall through */
6490 case SAT_WRITE_SECTORS:/* fall through */
6491 // case SAT_WRITE_DMA_FUA_EXT: /* fall through */
6492 case SAT_WRITE_DMA_EXT: /* fall through */
6493 case SAT_WRITE_SECTORS_EXT: /* fall through */
6494 case SAT_WRITE_FPDMA_QUEUED:
6496 SM_DBG5(("smsatChainedWriteNVerifyCB: WRITE success case\n"));
6498 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6500 /* done with internally genereated SAT_SMART_RETURN_STATUS */
6501 smsatFreeIntIoResource( smRoot,
6504 /* let's loop till TL */
6508 if (loopnum == 0) done
6510 (satOrgIOContext->LoopNum)--;
6512 if (satOrgIOContext->superIOFlag)
6514 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength;
6518 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength;
6521 satNewIntIo = smsatAllocIntIoResource( smRoot,
6526 if (satNewIntIo == agNULL)
6528 tdsmIOCompletedCB( smRoot,
6529 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6533 satOrgIOContext->interruptContext );
6535 SM_DBG1(("smsatChainedWriteNVerifyCB: momory allocation fails!!!\n"));
6537 } /* end of memory allocation failure */
6540 * Need to initialize all the fields within satIOContext
6543 satNewIOContext = smsatPrepareNewIO(
6551 if (satOrgIOContext->LoopNum == 0)
6557 satOrgIOContext->LoopNum = satOrgIOContext->LoopNum2;
6558 status = smsatChainedWriteNVerify_Start_Verify(smRoot,
6559 &satNewIntIo->satIntSmIORequest,
6560 satNewIOContext->psmDeviceHandle,
6561 &satNewIntIo->satIntSmScsiXchg,
6566 status = smsatChainedWriteNVerify_Write(smRoot,
6567 &satNewIntIo->satIntSmIORequest,
6568 satNewIOContext->psmDeviceHandle,
6569 &satNewIntIo->satIntSmScsiXchg,
6573 if (status != SM_RC_SUCCESS)
6575 smsatFreeIntIoResource( smRoot,
6578 tdsmIOCompletedCB( smRoot,
6579 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6583 satOrgIOContext->interruptContext );
6584 SM_DBG1(("smsatChainedWriteNVerifyCB: calling satChainedWriteNVerify_Write fails!!!\n"));
6590 case SAT_READ_VERIFY_SECTORS: /* fall through */
6591 case SAT_READ_VERIFY_SECTORS_EXT:
6592 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6594 /* done with internally genereated SAT_SMART_RETURN_STATUS */
6595 smsatFreeIntIoResource( smRoot,
6598 /* let's loop till TL */
6602 if (loopnum == 0) done
6604 (satOrgIOContext->LoopNum)--;
6605 if (satOrgIOContext->LoopNum == 0)
6608 done with write and verify
6610 tdsmIOCompletedCB( smRoot,
6611 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6615 satOrgIOContext->interruptContext );
6619 if (satOrgIOContext->superIOFlag)
6621 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength;
6625 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength;
6628 satNewIntIo = smsatAllocIntIoResource( smRoot,
6633 if (satNewIntIo == agNULL)
6635 tdsmIOCompletedCB( smRoot,
6636 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6640 satOrgIOContext->interruptContext );
6642 SM_DBG1(("smsatChainedWriteNVerifyCB: momory allocation fails!!!\n"));
6644 } /* end of memory allocation failure */
6647 * Need to initialize all the fields within satIOContext
6650 satNewIOContext = smsatPrepareNewIO(
6657 status = smsatChainedWriteNVerify_Verify(smRoot,
6658 &satNewIntIo->satIntSmIORequest,
6659 satNewIOContext->psmDeviceHandle,
6660 &satNewIntIo->satIntSmScsiXchg,
6663 if (status != SM_RC_SUCCESS)
6665 smsatFreeIntIoResource( smRoot,
6668 tdsmIOCompletedCB( smRoot,
6669 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6673 satOrgIOContext->interruptContext );
6674 SM_DBG1(("smsatChainedWriteNVerifyCB: calling satChainedWriteNVerify_Verify fails!!!\n"));
6681 SM_DBG1(("smsatChainedWriteNVerifyCB: success but default case command 0x%x!!!\n",hostToDevFis->h.command));
6682 tdsmIOCompletedCB( smRoot,
6683 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6687 satOrgIOContext->interruptContext );
6689 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6691 smsatFreeIntIoResource( smRoot,
6703 smsatReadMediaSerialNumberCB(
6705 agsaIORequest_t *agIORequest,
6707 agsaFisHeader_t *agFirstDword,
6709 agsaFrameHandle_t agFrameHandle,
6713 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
6714 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
6715 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
6716 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
6717 smRoot_t *smRoot = agNULL;
6718 smIntRoot_t *smIntRoot = agNULL;
6719 smIntContext_t *smAllShared = agNULL;
6720 smIORequestBody_t *smIORequestBody;
6721 smIORequestBody_t *smOrgIORequestBody;
6722 smSatIOContext_t *satIOContext;
6723 smSatIOContext_t *satOrgIOContext;
6724 smSatInternalIo_t *satIntIo;
6725 // satDeviceData_t *satDevData;
6726 smDeviceData_t *oneDeviceData;
6728 smScsiRspSense_t *pSense;
6729 smIORequest_t *smOrgIORequest;
6731 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
6732 smScsiInitiatorRequest_t *smOrgScsiRequest; /* tiScsiXchg */
6733 bit8 *pMediaSerialNumber;
6734 bit8 MediaSerialNumber[ZERO_MEDIA_SERIAL_NUMBER_LENGTH] = {0};
6735 smIniScsiCmnd_t *scsiCmnd;
6736 bit32 allocationLen = 0;
6738 SM_DBG2(("smsatReadMediaSerialNumberCB: start\n"));
6739 SM_DBG4(("smsatReadMediaSerialNumberCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
6741 /* internally generate tiIOContext */
6742 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
6743 satIOContext = (smSatIOContext_t *) ioContext;
6744 satIntIo = satIOContext->satIntIoContext;
6745 oneDeviceData = satIOContext->pSatDevData;
6746 hostToDevFis = satIOContext->pFis;
6747 smRoot = oneDeviceData->smRoot;
6748 smIntRoot = (smIntRoot_t *)smRoot->smData;
6749 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
6751 if (satIntIo == agNULL)
6753 SM_DBG4(("smsatReadMediaSerialNumberCB: External smSatInternalIo_t satIntIoContext\n"));
6754 satOrgIOContext = satIOContext;
6755 smOrgIORequest = smIORequestBody->smIORequest;
6756 pSense = satOrgIOContext->pSense;
6757 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
6758 /* SCSI command response payload to OS layer */
6759 pMediaSerialNumber = (bit8 *) smOrgScsiRequest->sglVirtualAddr;
6760 /* ATA command response payload */
6761 scsiCmnd = satOrgIOContext->pScsiCmnd;
6765 SM_DBG4(("smsatReadMediaSerialNumberCB: Internal smSatInternalIo_t satIntIoContext\n"));
6766 satOrgIOContext = satIOContext->satOrgIOContext;
6767 if (satOrgIOContext == agNULL)
6769 SM_DBG4(("smsatReadMediaSerialNumberCB: satOrgIOContext is NULL, wrong\n"));
6774 SM_DBG4(("smsatReadMediaSerialNumberCB: satOrgIOContext is NOT NULL\n"));
6776 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
6777 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
6779 pSense = satOrgIOContext->pSense;
6780 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
6781 /* SCSI command response payload to OS layer */
6782 pMediaSerialNumber = (bit8 *) smOrgScsiRequest->sglVirtualAddr;
6783 scsiCmnd = satOrgIOContext->pScsiCmnd;
6786 smIORequestBody->ioCompleted = agTRUE;
6787 smIORequestBody->ioStarted = agFALSE;
6789 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
6791 SM_DBG1(("smsatReadMediaSerialNumberCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
6798 satOrgIOContext->interruptContext
6800 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6802 smsatFreeIntIoResource( smRoot,
6808 if( agIOStatus != OSSA_IO_SUCCESS)
6810 /* Process abort case */
6811 if (agIOStatus == OSSA_IO_ABORTED)
6813 smsatProcessAbort(smRoot,
6818 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6820 smsatFreeIntIoResource( smRoot,
6825 smsatSetSensePayload( pSense,
6826 SCSI_SNSKEY_NOT_READY,
6828 SCSI_SNSCODE_MEDIUM_NOT_PRESENT,
6831 tdsmIOCompletedCB( smRoot,
6832 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6834 SCSI_STAT_CHECK_CONDITION,
6835 satOrgIOContext->pSmSenseData,
6836 satOrgIOContext->interruptContext );
6838 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6840 smsatFreeIntIoResource( smRoot,
6846 /* process success case */
6847 allocationLen = (scsiCmnd->cdb[6] << (8*3)) + (scsiCmnd->cdb[7] << (8*2))
6848 + (scsiCmnd->cdb[8] << 8) + scsiCmnd->cdb[9];
6849 allocationLen = MIN(allocationLen, scsiCmnd->expDataLength);
6850 SM_DBG5(("smsatReadMediaSerialNumberCB: allocationLen in CDB %d 0x%x\n", allocationLen,allocationLen));
6852 if (hostToDevFis->h.command == SAT_READ_SECTORS ||
6853 hostToDevFis->h.command == SAT_READ_SECTORS_EXT
6856 MediaSerialNumber[0] = 0;
6857 MediaSerialNumber[1] = 0;
6858 MediaSerialNumber[2] = 0;
6859 MediaSerialNumber[3] = 4;
6860 MediaSerialNumber[4] = 0;
6861 MediaSerialNumber[5] = 0;
6862 MediaSerialNumber[6] = 0;
6863 MediaSerialNumber[7] = 0;
6865 sm_memcpy(pMediaSerialNumber, MediaSerialNumber, MIN(allocationLen, ZERO_MEDIA_SERIAL_NUMBER_LENGTH));
6866 if (ZERO_MEDIA_SERIAL_NUMBER_LENGTH < allocationLen)
6868 SM_DBG1(("smsatReadMediaSerialNumberCB: 1st underrun allocationLen %d len %d !!!\n", allocationLen, ZERO_MEDIA_SERIAL_NUMBER_LENGTH));
6871 tdsmIOCompletedCB( smRoot,
6872 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */
6874 allocationLen - ZERO_MEDIA_SERIAL_NUMBER_LENGTH,
6876 satOrgIOContext->interruptContext );
6881 tdsmIOCompletedCB( smRoot,
6886 satOrgIOContext->interruptContext);
6888 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6890 smsatFreeIntIoResource( smRoot,
6897 SM_DBG1(("smsatReadMediaSerialNumberCB: error unknown command success 0x%x!!!\n", hostToDevFis->h.command));
6898 smsatSetSensePayload( pSense,
6899 SCSI_SNSKEY_NO_SENSE,
6901 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
6904 tdsmIOCompletedCB( smRoot,
6905 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
6907 SCSI_STAT_CHECK_CONDITION,
6908 satOrgIOContext->pSmSenseData,
6909 satOrgIOContext->interruptContext );
6911 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6913 smsatFreeIntIoResource( smRoot,
6925 agsaIORequest_t *agIORequest,
6927 agsaFisHeader_t *agFirstDword,
6929 agsaFrameHandle_t agFrameHandle,
6933 smRoot_t *smRoot = agNULL;
6934 smIntRoot_t *smIntRoot = agNULL;
6935 smIntContext_t *smAllShared = agNULL;
6936 smIORequestBody_t *smIORequestBody;
6937 smIORequestBody_t *smOrgIORequestBody;
6938 smSatIOContext_t *satIOContext;
6939 smSatIOContext_t *satOrgIOContext;
6940 smSatInternalIo_t *satIntIo;
6941 smDeviceData_t *oneDeviceData;
6942 smScsiRspSense_t *pSense;
6943 smIORequest_t *smOrgIORequest;
6944 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
6947 SM_DBG2(("smsatReadBufferCB: start\n"));
6948 SM_DBG4(("smsatReadBufferCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
6949 /* internally generate tiIOContext */
6950 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
6951 satIOContext = (smSatIOContext_t *) ioContext;
6952 satIntIo = satIOContext->satIntIoContext;
6953 oneDeviceData = satIOContext->pSatDevData;
6954 hostToDevFis = satIOContext->pFis;
6955 smRoot = oneDeviceData->smRoot;
6956 smIntRoot = (smIntRoot_t *)smRoot->smData;
6957 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
6958 if (satIntIo == agNULL)
6960 SM_DBG4(("smsatReadBufferCB: External smSatInternalIo_t satIntIoContext\n"));
6961 satOrgIOContext = satIOContext;
6962 smOrgIORequest = smIORequestBody->smIORequest;
6963 pSense = satOrgIOContext->pSense;
6967 SM_DBG4(("smsatReadBufferCB: Internal smSatInternalIo_t satIntIoContext\n"));
6968 satOrgIOContext = satIOContext->satOrgIOContext;
6969 if (satOrgIOContext == agNULL)
6971 SM_DBG4(("smsatReadBufferCB: satOrgIOContext is NULL, wrong\n"));
6976 SM_DBG4(("smsatReadBufferCB: satOrgIOContext is NOT NULL\n"));
6978 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
6979 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
6980 pSense = satOrgIOContext->pSense;
6982 smIORequestBody->ioCompleted = agTRUE;
6983 smIORequestBody->ioStarted = agFALSE;
6984 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
6986 SM_DBG1(("smsatReadBufferCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
6993 satOrgIOContext->interruptContext
6995 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
6997 smsatFreeIntIoResource( smRoot,
7003 if( agIOStatus != OSSA_IO_SUCCESS)
7005 /* Process abort case */
7006 if (agIOStatus == OSSA_IO_ABORTED)
7008 smsatProcessAbort(smRoot,
7013 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7015 smsatFreeIntIoResource( smRoot,
7020 smsatSetSensePayload( pSense,
7021 SCSI_SNSKEY_NOT_READY,
7023 SCSI_SNSCODE_MEDIUM_NOT_PRESENT,
7026 tdsmIOCompletedCB( smRoot,
7027 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
7029 SCSI_STAT_CHECK_CONDITION,
7030 satOrgIOContext->pSmSenseData,
7031 satOrgIOContext->interruptContext );
7033 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7035 smsatFreeIntIoResource( smRoot,
7041 /* process success case */
7042 if (hostToDevFis->h.command == SAT_READ_BUFFER )
7045 tdsmIOCompletedCB( smRoot,
7050 satOrgIOContext->interruptContext);
7051 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7053 smsatFreeIntIoResource( smRoot,
7060 SM_DBG1(("smsatReadBufferCB: error unknown command success 0x%x!!!\n", hostToDevFis->h.command));
7061 smsatSetSensePayload( pSense,
7062 SCSI_SNSKEY_NO_SENSE,
7064 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
7067 tdsmIOCompletedCB( smRoot,
7068 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
7070 SCSI_STAT_CHECK_CONDITION,
7071 satOrgIOContext->pSmSenseData,
7072 satOrgIOContext->interruptContext );
7074 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7076 smsatFreeIntIoResource( smRoot,
7089 agsaIORequest_t *agIORequest,
7091 agsaFisHeader_t *agFirstDword,
7093 agsaFrameHandle_t agFrameHandle,
7097 smRoot_t *smRoot = agNULL;
7098 smIntRoot_t *smIntRoot = agNULL;
7099 smIntContext_t *smAllShared = agNULL;
7100 smIORequestBody_t *smIORequestBody;
7101 smIORequestBody_t *smOrgIORequestBody;
7102 smSatIOContext_t *satIOContext;
7103 smSatIOContext_t *satOrgIOContext;
7104 smSatInternalIo_t *satIntIo;
7105 smDeviceData_t *oneDeviceData;
7106 smScsiRspSense_t *pSense;
7107 smIORequest_t *smOrgIORequest;
7108 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
7111 SM_DBG2(("smsatWriteBufferCB: start\n"));
7112 SM_DBG4(("smsatWriteBufferCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
7113 /* internally generate tiIOContext */
7114 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
7115 satIOContext = (smSatIOContext_t *) ioContext;
7116 satIntIo = satIOContext->satIntIoContext;
7117 oneDeviceData = satIOContext->pSatDevData;
7118 hostToDevFis = satIOContext->pFis;
7119 smRoot = oneDeviceData->smRoot;
7120 smIntRoot = (smIntRoot_t *)smRoot->smData;
7121 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
7122 if (satIntIo == agNULL)
7124 SM_DBG4(("smsatWriteBufferCB: External smSatInternalIo_t satIntIoContext\n"));
7125 satOrgIOContext = satIOContext;
7126 smOrgIORequest = smIORequestBody->smIORequest;
7127 pSense = satOrgIOContext->pSense;
7128 /* SCSI command response payload to OS layer */
7129 // pMediaSerialNumber = (bit8 *) s,OrgScsiRequest->sglVirtualAddr;
7133 SM_DBG4(("smsatWriteBufferCB: Internal smSatInternalIo_t satIntIoContext\n"));
7134 satOrgIOContext = satIOContext->satOrgIOContext;
7135 if (satOrgIOContext == agNULL)
7137 SM_DBG4(("smsatWriteBufferCB: satOrgIOContext is NULL, wrong\n"));
7142 SM_DBG4(("smsatWriteBufferCB: satOrgIOContext is NOT NULL\n"));
7144 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
7145 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
7146 pSense = satOrgIOContext->pSense;
7148 smIORequestBody->ioCompleted = agTRUE;
7149 smIORequestBody->ioStarted = agFALSE;
7150 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
7152 SM_DBG1(("smsatWriteBufferCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
7159 satOrgIOContext->interruptContext
7161 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7163 smsatFreeIntIoResource( smRoot,
7168 if( agIOStatus != OSSA_IO_SUCCESS)
7170 /* Process abort case */
7171 if (agIOStatus == OSSA_IO_ABORTED)
7173 smsatProcessAbort(smRoot,
7177 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7179 smsatFreeIntIoResource( smRoot,
7184 smsatSetSensePayload( pSense,
7185 SCSI_SNSKEY_NOT_READY,
7187 SCSI_SNSCODE_MEDIUM_NOT_PRESENT,
7189 tdsmIOCompletedCB( smRoot,
7190 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
7192 SCSI_STAT_CHECK_CONDITION,
7193 satOrgIOContext->pSmSenseData,
7194 satOrgIOContext->interruptContext );
7195 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7197 smsatFreeIntIoResource( smRoot,
7202 /* process success case */
7203 if (hostToDevFis->h.command == SAT_WRITE_BUFFER )
7205 tdsmIOCompletedCB( smRoot,
7210 satOrgIOContext->interruptContext);
7211 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7213 smsatFreeIntIoResource( smRoot,
7220 SM_DBG1(("smsatWriteBufferCB: error unknown command success 0x%x!!!\n", hostToDevFis->h.command));
7221 smsatSetSensePayload( pSense,
7222 SCSI_SNSKEY_NO_SENSE,
7224 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
7226 tdsmIOCompletedCB( smRoot,
7227 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
7229 SCSI_STAT_CHECK_CONDITION,
7230 satOrgIOContext->pSmSenseData,
7231 satOrgIOContext->interruptContext );
7232 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7233 smsatFreeIntIoResource( smRoot,
7242 smsatReassignBlocksCB(
7244 agsaIORequest_t *agIORequest,
7246 agsaFisHeader_t *agFirstDword,
7248 agsaFrameHandle_t agFrameHandle,
7252 smRoot_t *smRoot = agNULL;
7253 smIntRoot_t *smIntRoot = agNULL;
7254 smIntContext_t *smAllShared = agNULL;
7255 smIORequestBody_t *smIORequestBody;
7256 smIORequestBody_t *smOrgIORequestBody;
7257 smSatIOContext_t *satIOContext;
7258 smSatIOContext_t *satOrgIOContext;
7259 smSatIOContext_t *satNewIOContext;
7260 smSatInternalIo_t *satIntIo;
7261 smSatInternalIo_t *satNewIntIo = agNULL;
7262 smDeviceData_t *oneDeviceData;
7263 smScsiRspSense_t *pSense;
7264 smIniScsiCmnd_t *scsiCmnd;
7265 smIORequest_t *smOrgIORequest;
7266 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
7267 bit32 ataStatus = 0;
7269 smScsiInitiatorRequest_t *smScsiRequest; /* smScsiXchg */
7270 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
7272 SM_DBG2(("smsatReassignBlocksCB: start\n"));
7273 SM_DBG5(("smsatReassignBlocksCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
7275 /* internally generate tiIOContext */
7276 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
7277 satIOContext = (smSatIOContext_t *) ioContext;
7278 satIntIo = satIOContext->satIntIoContext;
7279 oneDeviceData = satIOContext->pSatDevData;
7280 hostToDevFis = satIOContext->pFis;
7281 smRoot = oneDeviceData->smRoot;
7282 smIntRoot = (smIntRoot_t *)smRoot->smData;
7283 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
7284 if (satIntIo == agNULL)
7286 SM_DBG4(("smsatReassignBlocksCB: External smSatInternalIo_t satIntIoContext\n"));
7287 satOrgIOContext = satIOContext;
7288 smOrgIORequest = smIORequestBody->smIORequest;
7289 smScsiRequest = satOrgIOContext->smScsiXchg;
7290 pSense = satOrgIOContext->pSense;
7291 scsiCmnd = satOrgIOContext->pScsiCmnd;
7295 SM_DBG4(("smsatReassignBlocksCB: Internal smSatInternalIo_t satIntIoContext\n"));
7296 satOrgIOContext = satIOContext->satOrgIOContext;
7297 if (satOrgIOContext == agNULL)
7299 SM_DBG4(("smsatReassignBlocksCB: satOrgIOContext is NULL, Wrong\n"));
7304 SM_DBG4(("smsatReassignBlocksCB: satOrgIOContext is NOT NULL, Wrong\n"));
7306 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
7307 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
7308 smScsiRequest = satOrgIOContext->smScsiXchg;
7309 pSense = satOrgIOContext->pSense;
7310 scsiCmnd = satOrgIOContext->pScsiCmnd;
7313 smIORequestBody->ioCompleted = agTRUE;
7314 smIORequestBody->ioStarted = agFALSE;
7316 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
7318 SM_DBG1(("smsatReassignBlocksCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
7325 satOrgIOContext->interruptContext
7327 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7329 smsatFreeIntIoResource( smRoot,
7334 if (agIOStatus != OSSA_IO_SUCCESS)
7336 /* only agsaFisRegDeviceToHost_t is expected */
7337 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
7338 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
7340 if (agIOStatus != OSSA_IO_SUCCESS)
7342 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) ||
7343 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
7347 if( agIOStatus != OSSA_IO_SUCCESS)
7349 SM_DBG1(("smsatReassignBlocksCB FAILED, NOT IO_SUCCESS!!!\n"));
7351 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
7353 SM_DBG1(("smsatReassignBlocksCB FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
7355 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
7356 (ataStatus & DF_ATA_STATUS_MASK)
7359 SM_DBG1(("smsatReassignBlocksCB FAILED, FAILED, error status!!!\n"));
7362 /* Process abort case */
7363 if (agIOStatus == OSSA_IO_ABORTED)
7365 smsatProcessAbort(smRoot,
7369 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7371 smsatFreeIntIoResource( smRoot,
7377 if (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS ||
7378 hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT
7381 SM_DBG1(("smsatReassignBlocksCB SAT_READ_VERIFY_SECTORS(_EXT) failed!!!\n"));
7382 /* Verify failed; send Write with same LBA */
7383 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7385 smsatFreeIntIoResource( smRoot,
7389 satNewIntIo = smsatAllocIntIoResource( smRoot,
7392 512, /* writing 1 sector */
7394 if (satNewIntIo == agNULL)
7396 smsatSetSensePayload( pSense,
7397 SCSI_SNSKEY_HARDWARE_ERROR,
7399 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED,
7401 tdsmIOCompletedCB( smRoot,
7402 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
7404 SCSI_STAT_CHECK_CONDITION,
7405 satOrgIOContext->pSmSenseData,
7406 satOrgIOContext->interruptContext );
7407 SM_DBG1(("smsatReassignBlocksCB: momory allocation fails!!!\n"));
7409 } /* end memory allocation */
7410 satNewIOContext = smsatPrepareNewIO(
7417 /* send Write with same LBA */
7418 status = smsatReassignBlocks_2(
7420 &satNewIntIo->satIntSmIORequest,
7421 satNewIOContext->psmDeviceHandle,
7422 &satNewIntIo->satIntSmScsiXchg,
7424 satOrgIOContext->LBA
7427 if (status != SM_RC_SUCCESS)
7429 /* sending ATA command fails */
7430 smsatFreeIntIoResource( smRoot,
7433 smsatSetSensePayload( pSense,
7434 SCSI_SNSKEY_HARDWARE_ERROR,
7436 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED,
7439 tdsmIOCompletedCB( smRoot,
7440 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
7442 SCSI_STAT_CHECK_CONDITION,
7443 satOrgIOContext->pSmSenseData,
7444 satOrgIOContext->interruptContext );
7445 SM_DBG1(("smsatReassignBlocksCB calling fail 1!!!\n"));
7447 } /* end send fails */
7451 else if (hostToDevFis->h.command == SAT_WRITE_DMA ||
7452 hostToDevFis->h.command == SAT_WRITE_SECTORS ||
7453 hostToDevFis->h.command == SAT_WRITE_DMA_EXT ||
7454 hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT ||
7455 hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED
7458 SM_DBG1(("smsatReassignBlocksCB SAT_WRITE failed!!!\n"));
7463 SM_DBG1(("smsatReassignBlocksCB error default case unexpected command 0x%x!!!\n", hostToDevFis->h.command));
7467 smsatSetSensePayload( pSense,
7468 SCSI_SNSKEY_HARDWARE_ERROR,
7470 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED,
7473 tdsmIOCompletedCB( smRoot,
7474 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
7476 SCSI_STAT_CHECK_CONDITION,
7477 satOrgIOContext->pSmSenseData,
7478 satOrgIOContext->interruptContext );
7481 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7483 smsatFreeIntIoResource( smRoot,
7487 } /* error checking */
7491 /* prcessing the success case */
7492 if (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS ||
7493 hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT ||
7494 hostToDevFis->h.command == SAT_WRITE_DMA ||
7495 hostToDevFis->h.command == SAT_WRITE_SECTORS ||
7496 hostToDevFis->h.command == SAT_WRITE_DMA_EXT ||
7497 hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT ||
7498 hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED
7501 /* next LBA; verify */
7502 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7504 smsatFreeIntIoResource( smRoot,
7508 if (satOrgIOContext->ParmIndex >= satOrgIOContext->ParmLen)
7510 SM_DBG5(("smsatReassignBlocksCB: GOOD status\n"));
7511 /* return stat_good */
7512 tdsmIOCompletedCB( smRoot,
7517 satOrgIOContext->interruptContext );
7522 SM_DBG5(("smsatReassignBlocksCB: processing next LBA\n"));
7523 satNewIntIo = smsatAllocIntIoResource( smRoot,
7528 if (satNewIntIo == agNULL)
7530 smsatSetSensePayload( pSense,
7531 SCSI_SNSKEY_HARDWARE_ERROR,
7533 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED,
7536 tdsmIOCompletedCB( smRoot,
7537 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
7539 SCSI_STAT_CHECK_CONDITION,
7540 satOrgIOContext->pSmSenseData,
7541 satOrgIOContext->interruptContext );
7542 SM_DBG1(("smsatReassignBlocksCB: momory allocation fails!!!\n"));
7544 } /* end memory allocation */
7546 satNewIOContext = smsatPrepareNewIO(
7554 /* send Verify with the next LBA */
7555 status = smsatReassignBlocks_1(
7557 &satNewIntIo->satIntSmIORequest,
7558 satNewIOContext->psmDeviceHandle,
7559 smScsiRequest, /* orginal from OS layer */
7564 if (status != SM_RC_SUCCESS)
7566 /* sending ATA command fails */
7567 smsatFreeIntIoResource( smRoot,
7570 smsatSetSensePayload( pSense,
7571 SCSI_SNSKEY_HARDWARE_ERROR,
7573 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED,
7576 tdsmIOCompletedCB( smRoot,
7577 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
7579 SCSI_STAT_CHECK_CONDITION,
7580 satOrgIOContext->pSmSenseData,
7581 satOrgIOContext->interruptContext );
7582 SM_DBG1(("smsatReassignBlocksCB calling satModeSelect6_1 fails!!!\n"));
7584 } /* end send fails */
7589 else if (hostToDevFis->h.command == SAT_WRITE_DMA ||
7590 hostToDevFis->h.command == SAT_WRITE_SECTORS ||
7591 hostToDevFis->h.command == SAT_WRITE_DMA_EXT ||
7592 hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT ||
7593 hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED
7596 /* next LBA; verify */
7600 SM_DBG1(("smsatReassignBlocksCB error unknown command success 0x%x !!!\n", hostToDevFis->h.command));
7602 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
7604 smsatFreeIntIoResource( smRoot,
7607 smsatSetSensePayload( pSense,
7608 SCSI_SNSKEY_HARDWARE_ERROR,
7610 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED,
7613 tdsmIOCompletedCB( smRoot,
7614 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
7616 SCSI_STAT_CHECK_CONDITION,
7617 satOrgIOContext->pSmSenseData,
7618 satOrgIOContext->interruptContext );
7625 osGLOBAL FORCEINLINE void
7626 smsatDecrementPendingIO(
7628 smIntContext_t *smAllShared,
7629 smSatIOContext_t *satIOContext
7632 #ifdef CCFLAG_OPTIMIZE_SAT_LOCK
7633 bit32 volatile satPendingNCQIO = 0;
7634 bit32 volatile satPendingNONNCQIO = 0;
7635 bit32 volatile satPendingIO = 0;
7636 #endif /* CCFLAG_OPTIMIZE_SAT_LOCK */
7637 smDeviceData_t *oneDeviceData = satIOContext->pSatDevData;
7638 smSatInternalIo_t *satIntIo = satIOContext->satIntIoContext;
7639 smSatIOContext_t *satOrgIOContext = satIOContext->satOrgIOContext;
7640 #ifdef TD_DEBUG_ENABLE
7641 smIORequestBody_t *smIORequestBody = agNULL;
7642 smIORequestBody = (smIORequestBody_t *)satIOContext->smRequestBody;
7645 SM_DBG3(("smsatDecrementPendingIO: start\n"));
7647 #ifdef CCFLAG_OPTIMIZE_SAT_LOCK
7648 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) ||
7649 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) )
7651 tdsmInterlockedDecrement(smRoot,&oneDeviceData->satPendingNCQIO);
7655 tdsmInterlockedDecrement(smRoot,&oneDeviceData->satPendingNONNCQIO);
7657 tdsmInterlockedDecrement(smRoot,&oneDeviceData->satPendingIO);
7659 tdsmInterlockedExchange(smRoot, &satPendingNCQIO, oneDeviceData->satPendingNCQIO);
7660 tdsmInterlockedExchange(smRoot, &satPendingNONNCQIO, oneDeviceData->satPendingNONNCQIO);
7661 tdsmInterlockedExchange(smRoot, &satPendingIO, oneDeviceData->satPendingIO);
7662 if (satPendingNCQIO == -1)
7664 SM_DBG1(("smsatDecrementPendingIO: satPendingNCQIO adjustment!!!\n"));
7665 oneDeviceData->satPendingNCQIO = 0;
7667 if (satPendingNONNCQIO == -1)
7669 SM_DBG1(("smsatDecrementPendingIO: satPendingNONNCQIO adjustment!!!\n"));
7670 oneDeviceData->satPendingNONNCQIO = 0;
7672 if (satPendingIO == -1)
7674 SM_DBG1(("smsatDecrementPendingIO: satPendingIO adjustment!!!\n"));
7675 oneDeviceData->satPendingIO = 0;
7680 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) ||
7681 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) )
7683 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK);
7684 oneDeviceData->satPendingNCQIO--;
7685 oneDeviceData->satPendingIO--;
7686 SMLIST_DEQUEUE_THIS (&satIOContext->satIoContextLink);
7688 if (oneDeviceData->satPendingNCQIO == -1)
7690 SM_DBG1(("smsatDecrementPendingIO: satPendingNCQIO adjustment!!!\n"));
7691 oneDeviceData->satPendingNCQIO = 0;
7693 if (oneDeviceData->satPendingIO == -1)
7695 SM_DBG1(("smsatDecrementPendingIO: satPendingIO adjustment!!!\n"));
7696 oneDeviceData->satPendingIO = 0;
7698 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK);
7702 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK);
7703 oneDeviceData->satPendingNONNCQIO--;
7704 oneDeviceData->satPendingIO--;
7705 SMLIST_DEQUEUE_THIS (&satIOContext->satIoContextLink);
7707 if (oneDeviceData->satPendingNONNCQIO == -1)
7709 SM_DBG1(("smsatDecrementPendingIO: satPendingNONNCQIO adjustment!!!\n"));
7710 oneDeviceData->satPendingNONNCQIO = 0;
7712 if (oneDeviceData->satPendingIO == -1)
7714 SM_DBG1(("smsatDecrementPendingIO: satPendingIO adjustment!!!\n"));
7715 oneDeviceData->satPendingIO = 0;
7717 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK);
7720 #endif /* CCFLAG_OPTIMIZE_SAT_LOCK */
7722 if (satIntIo == agNULL)
7724 SM_DBG3(("smsatDecrementPendingIO: external command!!!\n"));
7725 /*smEnqueueIO(smRoot, satIOContext);*/
7729 SM_DBG3(("smsatDecrementPendingIO: internal command!!!\n"));
7730 if (satOrgIOContext == agNULL)
7732 /* No smEnqueueIO since only alloc used */
7733 SM_DBG3(("smsatDecrementPendingIO: internal only command!!!, ID %d!!!\n", smIORequestBody->id));
7738 /* smDequeueIO used */
7739 /*smEnqueueIO(smRoot, satOrgIOContext);*/
7748 smsatProcessAbnormalCompletion(
7750 agsaIORequest_t *agIORequest,
7752 agsaFisHeader_t *agFirstDword,
7755 smSatIOContext_t *satIOContext
7759 smRoot_t *smRoot = agNULL;
7760 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
7761 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
7762 bit32 interruptContext;
7763 smIORequestBody_t *smIORequestBody;
7764 // satDeviceData_t *pSatDevData;
7765 smDeviceHandle_t *smDeviceHandle;
7766 smDeviceData_t *oneDeviceData = agNULL;
7767 agsaDevHandle_t *agDevHandle = agNULL;
7769 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
7770 oneDeviceData = satIOContext->pSatDevData;
7771 if (oneDeviceData == agNULL)
7773 SM_DBG1(("smsatProcessAbnormalCompletion: oneDeviceData is NULL\n"));
7776 smDeviceHandle = satIOContext->psmDeviceHandle;
7777 smRoot = oneDeviceData->smRoot;
7778 interruptContext = satIOContext->interruptContext;
7780 SM_DBG5(("smsatProcessAbnormalCompletion: start\n"));
7782 /* Get into the detail */
7785 case OSSA_IO_SUCCESS:
7786 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_SUCCESS agIOInfoLen 0x%x calling smsatIOCompleted!!!\n", agIOInfoLen));
7788 * At this point agIOInfoLen should be non-zero and there is valid FIS
7789 * to read. Pass this info to the SAT layer in order to do the ATA status
7790 * to SCSI status translation.
7792 smsatIOCompleted( smRoot,
7793 smIORequestBody->smIORequest,
7802 case OSSA_IO_ABORTED:
7803 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORTED!!!\n"));
7805 tdsmIOCompletedCB( smRoot,
7806 smIORequestBody->smIORequest,
7813 if ( oneDeviceData->satTmTaskTag != agNULL )
7815 SM_DBG1(("smsatProcessAbnormalCompletion: TM callback!!!\n"));
7816 if (smDeviceHandle == agNULL)
7818 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n"));
7821 tdsmEventCB( smRoot,
7823 smIntrEventTypeTaskManagement,
7825 oneDeviceData->satTmTaskTag);
7829 oneDeviceData->satTmTaskTag = agNULL;
7834 * Check if we are in recovery mode and need to update the recovery flag
7836 if ((oneDeviceData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) &&
7837 (oneDeviceData->satPendingIO == 0 ))
7839 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
7840 SM_DBG1(("smsatProcessAbnormalCompletion: STATE NORMAL!!!\n"));
7843 SM_DBG1(("smsatProcessAbnormalCompletion: did %d satDriveState %d!!!\n", oneDeviceData->id, oneDeviceData->satDriveState));
7844 SM_DBG1(("smsatProcessAbnormalCompletion: satPendingIO %d satNCQMaxIO %d!!!\n", oneDeviceData->satPendingIO, oneDeviceData->satNCQMaxIO ));
7845 SM_DBG1(("smsatProcessAbnormalCompletion: satPendingNCQIO %d satPendingNONNCQIO %d!!!\n", oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
7849 case OSSA_IO_OVERFLOW:
7850 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_OVERFLOW!!!\n"));
7851 tdsmIOCompletedCB( smRoot,
7852 smIORequestBody->smIORequest,
7859 case OSSA_IO_UNDERFLOW:
7860 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_UNDERFLOW!!!\n"));
7861 tdsmIOCompletedCB( smRoot,
7862 smIORequestBody->smIORequest,
7870 case OSSA_IO_FAILED:
7871 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_FAILED!!!\n"));
7872 tdsmIOCompletedCB( smRoot,
7873 smIORequestBody->smIORequest,
7880 case OSSA_IO_ABORT_RESET:
7881 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORT_RESET!!!\n"));
7882 tdsmIOCompletedCB( smRoot,
7883 smIORequestBody->smIORequest,
7889 * Check if we are in recovery mode and need to update the recovery flag
7891 if ((oneDeviceData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) &&
7892 (oneDeviceData->satPendingIO == 0 ))
7894 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
7895 SM_DBG1(("smsatProcessAbnormalCompletion: STATE NORMAL!!!\n"));
7898 SM_DBG1(("smsatProcessAbnormalCompletion: satDriveState %d!!!\n", oneDeviceData->satDriveState));
7899 SM_DBG1(("smsatProcessAbnormalCompletion: satPendingIO %d satNCQMaxIO %d!!!\n", oneDeviceData->satPendingIO, oneDeviceData->satNCQMaxIO ));
7900 SM_DBG1(("smsatProcessAbnormalCompletion: satPendingNCQIO %d satPendingNONNCQIO %d!!!\n", oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
7905 case OSSA_IO_NOT_VALID:
7906 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_NOT_VALID!!!\n"));
7907 tdsmIOCompletedCB( smRoot,
7908 smIORequestBody->smIORequest,
7916 case OSSA_IO_NO_DEVICE:
7917 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_NO_DEVICE!!!\n"));
7918 tdsmIOCompletedCB( smRoot,
7919 smIORequestBody->smIORequest,
7926 #ifdef REMOVED /* removed from spec */
7927 case OSSA_IO_ILLEGAL_PARAMETER:
7928 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_ILLEGAL_PARAMETER!!!\n"));
7929 tdsmIOCompletedCB( smRoot,
7930 smIORequestBody->smIORequest,
7937 case OSSA_IO_LINK_FAILURE:
7938 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_LINK_FAILURE!!!\n"));
7939 tdsmIOCompletedCB( smRoot,
7940 smIORequestBody->smIORequest,
7947 case OSSA_IO_PROG_ERROR:
7948 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_PROG_ERROR!!!\n"));
7949 tdsmIOCompletedCB( smRoot,
7950 smIORequestBody->smIORequest,
7957 case OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED: /* fall through */
7958 case OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION: /* fall through */
7959 case OSSA_IO_OPEN_CNX_ERROR_BREAK: /* fall through */
7960 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS: /* fall through */
7961 case OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION: /* fall through */
7962 case OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED: /* fall through */
7963 case OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION: /* fall through */
7964 case OSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED: /* fall through */
7965 #ifdef REMOVED /* removed from spec */
7966 case OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR: /* fall through */
7968 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_OPEN_CNX_ERROR_* 0x%x!!!\n", agIOStatus));
7969 if (smDeviceHandle == agNULL)
7971 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n"));
7972 tdsmIOCompletedCB( smRoot,
7973 smIORequestBody->smIORequest,
7980 if (oneDeviceData == agNULL)
7982 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n"));
7986 SM_DBG1(("smsatProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id));
7989 tdsmIOCompletedCB( smRoot,
7990 smIORequestBody->smIORequest,
7996 case OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
7997 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY!!!\n"));
7998 tdsmIOCompletedCB( smRoot,
7999 smIORequestBody->smIORequest,
8006 case OSSA_IO_XFER_ERROR_BREAK: /* fall throuth */
8009 case OSSA_IO_XFER_ERROR_PHY_NOT_READY: /* fall throuth */
8010 case OSSA_IO_XFER_ERROR_NAK_RECEIVED: /* fall throuth */
8013 case OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT: /* fall throuth */
8014 case OSSA_IO_XFER_ERROR_PEER_ABORTED: /* fall throuth */
8016 case OSSA_IO_XFER_ERROR_DMA: /* fall throuth */
8018 case OSSA_IO_XFER_ERROR_RX_FRAME: /* fall throuth */
8019 case OSSA_IO_XFER_ERROR_CREDIT_TIMEOUT: /* fall throuth */
8020 case OSSA_IO_XFER_ERROR_SATA: /* fall throuth */
8022 case OSSA_IO_XFER_ERROR_SATA_LINK_TIMEOUT: /* fall throuth */
8023 case OSSA_IO_XFER_ERROR_ABORTED_DUE_TO_SRST: /* fall throuth */
8024 case OSSA_IO_XFER_ERROR_REJECTED_NCQ_MODE: /* fall throuth */
8026 case OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN:
8027 case OSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE: /* fall throuth */
8028 case OSSA_IO_XFER_ERROR_DISRUPTED_PHY_DOWN: /* fall throuth */
8029 case OSSA_IO_XFER_ERROR_OFFSET_MISMATCH: /* fall throuth */
8030 case OSSA_IO_XFER_ERROR_XFER_ZERO_DATA_LEN: /* fall throuth */
8032 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_ERROR_* 0x%x!!!\n", agIOStatus));
8033 tdsmIOCompletedCB( smRoot,
8034 smIORequestBody->smIORequest,
8041 case OSSA_IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT: /* fall throuth */
8042 case OSSA_IO_XFER_ERROR_CMD_ISSUE_BREAK_BEFORE_ACK_NAK: /* fall throuth */
8043 case OSSA_IO_XFER_ERROR_CMD_ISSUE_PHY_DOWN_BEFORE_ACK_NAK: /* fall throuth */
8044 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_ERROR_CMD_ISSUE_* 0x%x!!!\n", agIOStatus));
8045 tdsmIOCompletedCB( smRoot,
8046 smIORequestBody->smIORequest,
8052 case OSSA_IO_XFER_PIO_SETUP_ERROR:
8053 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_PIO_SETUP_ERROR!!!\n"));
8054 tdsmIOCompletedCB( smRoot,
8055 smIORequestBody->smIORequest,
8062 case OSSA_IO_DS_IN_ERROR:
8063 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_IN_ERROR!!!\n"));
8064 if (smDeviceHandle == agNULL)
8066 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n"));
8067 tdsmIOCompletedCB( smRoot,
8068 smIORequestBody->smIORequest,
8075 if (oneDeviceData == agNULL)
8077 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n"));
8081 SM_DBG1(("smsatProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id));
8083 tdsmIOCompletedCB( smRoot,
8084 smIORequestBody->smIORequest,
8090 case OSSA_IO_DS_NON_OPERATIONAL:
8091 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_NON_OPERATIONAL!!!\n"));
8092 if (smDeviceHandle == agNULL)
8094 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n"));
8095 tdsmIOCompletedCB( smRoot,
8096 smIORequestBody->smIORequest,
8103 if (oneDeviceData == agNULL)
8105 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n"));
8109 SM_DBG1(("smsatProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id));
8110 agDevHandle = oneDeviceData->agDevHandle;
8111 if (oneDeviceData->valid == agTRUE)
8113 saSetDeviceState(agRoot, agNULL, tdsmRotateQnumber(smRoot, smDeviceHandle), agDevHandle, SA_DS_OPERATIONAL);
8117 tdsmIOCompletedCB( smRoot,
8118 smIORequestBody->smIORequest,
8125 case OSSA_IO_PORT_IN_RESET:
8126 case OSSA_IO_DS_IN_RECOVERY:
8127 SM_DBG1(("smsatProcessAbnormalCompletion: OSSA_IO_DS_IN_RECOVERY or OSSA_IO_PORT_IN_RESET status %x\n", agIOStatus));
8128 tdsmIOCompletedCB( smRoot,
8129 smIORequestBody->smIORequest,
8136 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
8137 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
8138 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
8139 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
8140 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
8141 SM_DBG1(("smsatProcessAbnormalCompletion: SSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_XX status %x\n", agIOStatus));
8142 tdsmIOCompletedCB( smRoot,
8143 smIORequestBody->smIORequest,
8150 case OSSA_MPI_IO_RQE_BUSY_FULL:
8151 case OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE:
8152 case OSSA_MPI_ERR_ATAPI_DEVICE_BUSY:
8153 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_MPI_%x!!!\n", agIOStatus));
8154 tdsmIOCompletedCB( smRoot,
8155 smIORequestBody->smIORequest,
8162 case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS: /* fall through */
8164 case OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH:
8166 case OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID: /* fall through */
8167 case OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH: /* fall through */
8168 case OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR: /* fall through */
8169 case OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS:
8170 case OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE:
8172 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = ENCRYPTION ERROR 0x%x!!!\n", agIOStatus));
8173 smsatEncryptionHandler(smRoot,
8183 case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH: /* fall through */
8184 case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH: /* fall through */
8185 case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH:
8186 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = DIF ERROR 0x%x!!!\n", agIOStatus));
8187 smsatDifHandler(smRoot,
8198 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = unknown 0x%x!!!\n", agIOStatus));
8199 if (oneDeviceData != agNULL)
8201 SM_DBG1(("smsatProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id));
8205 SM_DBG1(("smsatProcessAbnormalCompletion: oneDeviceData is NULL!!!\n"));
8208 tdsmIOCompletedCB( smRoot,
8209 smIORequestBody->smIORequest,
8222 smsatDelayedProcessAbnormalCompletion(
8224 agsaIORequest_t *agIORequest,
8226 agsaFisHeader_t *agFirstDword,
8229 smSatIOContext_t *satIOContext
8232 smRoot_t *smRoot = agNULL;
8233 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
8234 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
8235 // bit32 interruptContext = osData->IntContext;
8236 bit32 interruptContext;
8237 smIORequestBody_t *smIORequestBody;
8238 // satDeviceData_t *pSatDevData;
8239 smDeviceHandle_t *smDeviceHandle;
8240 smDeviceData_t *oneDeviceData = agNULL;
8241 agsaDevHandle_t *agDevHandle = agNULL;
8243 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
8244 oneDeviceData = satIOContext->pSatDevData;
8245 if (oneDeviceData == agNULL)
8247 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: oneDeviceData is NULL\n"));
8250 smDeviceHandle = satIOContext->psmDeviceHandle;
8251 smRoot = oneDeviceData->smRoot;
8252 interruptContext = satIOContext->interruptContext;
8254 SM_DBG5(("smsatDelayedProcessAbnormalCompletion: start\n"));
8256 /* Get into the detail */
8259 case OSSA_IO_SUCCESS:
8260 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_SUCCESS calling smsatIOCompleted!!!\n"));
8265 case OSSA_IO_ABORTED:
8266 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORTED!!!\n"));
8268 tdsmIOCompletedCB( smRoot,
8269 smIORequestBody->smIORequest,
8275 if ( oneDeviceData->satTmTaskTag != agNULL )
8277 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: TM callback!!!\n"));
8278 if (smDeviceHandle == agNULL)
8280 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n"));
8285 tdsmEventCB( smRoot,
8287 smIntrEventTypeTaskManagement,
8289 oneDeviceData->satTmTaskTag);
8293 oneDeviceData->satTmTaskTag = agNULL;
8298 * Check if we are in recovery mode and need to update the recovery flag
8300 if ((oneDeviceData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) &&
8301 (oneDeviceData->satPendingIO == 0 ))
8303 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
8304 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: STATE NORMAL.!!!\n"));
8307 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: satDriveState %d!!!\n", oneDeviceData->satDriveState));
8308 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: satPendingIO %d satNCQMaxIO %d!!!\n", oneDeviceData->satPendingIO, oneDeviceData->satNCQMaxIO ));
8309 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: satPendingNCQIO %d satPendingNONNCQIO %d!!!\n", oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
8313 case OSSA_IO_OVERFLOW:
8314 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_OVERFLOW!!!\n"));
8315 tdsmIOCompletedCB( smRoot,
8316 smIORequestBody->smIORequest,
8323 case OSSA_IO_UNDERFLOW:
8324 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_UNDERFLOW!!!\n"));
8325 tdsmIOCompletedCB( smRoot,
8326 smIORequestBody->smIORequest,
8334 case OSSA_IO_FAILED:
8335 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_FAILED!!!\n"));
8336 tdsmIOCompletedCB( smRoot,
8337 smIORequestBody->smIORequest,
8344 case OSSA_IO_ABORT_RESET:
8345 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORT_RESET!!!\n"));
8346 tdsmIOCompletedCB( smRoot,
8347 smIORequestBody->smIORequest,
8353 * Check if we are in recovery mode and need to update the recovery flag
8355 if ((oneDeviceData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) &&
8356 (oneDeviceData->satPendingIO == 0 ))
8358 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
8359 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: STATE NORMAL.!!!\n"));
8362 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: satDriveState %d!!!\n", oneDeviceData->satDriveState));
8363 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: satPendingIO %d satNCQMaxIO %d!!!\n", oneDeviceData->satPendingIO, oneDeviceData->satNCQMaxIO ));
8364 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: satPendingNCQIO %d satPendingNONNCQIO %d!!!\n", oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
8369 case OSSA_IO_NOT_VALID:
8370 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_NOT_VALID!!!\n"));
8371 tdsmIOCompletedCB( smRoot,
8372 smIORequestBody->smIORequest,
8380 case OSSA_IO_NO_DEVICE:
8381 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_NO_DEVICE!!!\n"));
8382 tdsmIOCompletedCB( smRoot,
8383 smIORequestBody->smIORequest,
8390 #ifdef REMOVED /* removed from spec */
8391 case OSSA_IO_ILLEGAL_PARAMETER:
8392 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_ILLEGAL_PARAMETER!!!\n"));
8393 tdsmIOCompletedCB( smRoot,
8394 smIORequestBody->smIORequest,
8401 case OSSA_IO_LINK_FAILURE:
8402 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_LINK_FAILURE!!!\n"));
8403 tdsmIOCompletedCB( smRoot,
8404 smIORequestBody->smIORequest,
8411 case OSSA_IO_PROG_ERROR:
8412 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_PROG_ERROR!!!\n"));
8413 tdsmIOCompletedCB( smRoot,
8414 smIORequestBody->smIORequest,
8421 case OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED: /* fall through */
8422 case OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION: /* fall through */
8423 case OSSA_IO_OPEN_CNX_ERROR_BREAK: /* fall through */
8424 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS: /* fall through */
8425 case OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION: /* fall through */
8426 case OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED: /* fall through */
8427 case OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION: /* fall through */
8428 case OSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED: /* fall through */
8429 #ifdef REMOVED /* removed from spec */
8430 case OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR: /* fall through */
8432 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_OPEN_CNX_ERROR_* 0x%x!!!\n", agIOStatus));
8433 if (smDeviceHandle == agNULL)
8435 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n"));
8436 tdsmIOCompletedCB( smRoot,
8437 smIORequestBody->smIORequest,
8444 if (oneDeviceData == agNULL)
8446 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n"));
8450 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id));
8452 tdsmIOCompletedCB( smRoot,
8453 smIORequestBody->smIORequest,
8460 case OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
8461 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY!!!\n"));
8462 tdsmIOCompletedCB( smRoot,
8463 smIORequestBody->smIORequest,
8470 case OSSA_IO_XFER_ERROR_BREAK: /* fall throuth */
8473 case OSSA_IO_XFER_ERROR_PHY_NOT_READY: /* fall throuth */
8474 case OSSA_IO_XFER_ERROR_NAK_RECEIVED: /* fall throuth */
8477 case OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT: /* fall throuth */
8478 case OSSA_IO_XFER_ERROR_PEER_ABORTED: /* fall throuth */
8481 case OSSA_IO_XFER_ERROR_DMA: /* fall throuth */
8484 case OSSA_IO_XFER_ERROR_RX_FRAME: /* fall throuth */
8485 case OSSA_IO_XFER_ERROR_CREDIT_TIMEOUT: /* fall throuth */
8486 case OSSA_IO_XFER_ERROR_SATA: /* fall throuth */
8488 case OSSA_IO_XFER_ERROR_SATA_LINK_TIMEOUT: /* fall throuth */
8489 case OSSA_IO_XFER_ERROR_ABORTED_DUE_TO_SRST: /* fall throuth */
8490 case OSSA_IO_XFER_ERROR_REJECTED_NCQ_MODE: /* fall throuth */
8492 case OSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE: /* fall throuth */
8493 case OSSA_IO_XFER_ERROR_DISRUPTED_PHY_DOWN: /* fall throuth */
8494 case OSSA_IO_XFER_ERROR_OFFSET_MISMATCH: /* fall throuth */
8495 case OSSA_IO_XFER_ERROR_XFER_ZERO_DATA_LEN: /* fall throuth */
8497 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_ERROR_* 0x%x!!!\n", agIOStatus));
8499 tdsmIOCompletedCB( smRoot,
8500 smIORequestBody->smIORequest,
8507 case OSSA_IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT: /* fall throuth */
8508 case OSSA_IO_XFER_ERROR_CMD_ISSUE_BREAK_BEFORE_ACK_NAK: /* fall throuth */
8509 case OSSA_IO_XFER_ERROR_CMD_ISSUE_PHY_DOWN_BEFORE_ACK_NAK: /* fall throuth */
8510 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_ERROR_CMD_ISSUE_* 0x%x!!!\n", agIOStatus));
8511 tdsmIOCompletedCB( smRoot,
8512 smIORequestBody->smIORequest,
8518 case OSSA_IO_XFER_PIO_SETUP_ERROR:
8519 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_PIO_SETUP_ERROR!!!\n"));
8520 if (smDeviceHandle == agNULL)
8522 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n"));
8524 if (oneDeviceData == agNULL)
8526 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n"));
8530 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id));
8532 tdsmIOCompletedCB( smRoot,
8533 smIORequestBody->smIORequest,
8540 case OSSA_IO_DS_IN_ERROR:
8541 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_IN_ERROR!!!\n"));
8542 if (smDeviceHandle == agNULL)
8544 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n"));
8545 tdsmIOCompletedCB( smRoot,
8546 smIORequestBody->smIORequest,
8553 if (oneDeviceData == agNULL)
8555 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n"));
8559 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id));
8561 tdsmIOCompletedCB( smRoot,
8562 smIORequestBody->smIORequest,
8568 case OSSA_IO_DS_NON_OPERATIONAL:
8569 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_NON_OPERATIONAL!!!\n"));
8570 if (smDeviceHandle == agNULL)
8572 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n"));
8573 tdsmIOCompletedCB( smRoot,
8574 smIORequestBody->smIORequest,
8581 if (oneDeviceData == agNULL)
8583 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n"));
8587 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id));
8588 agDevHandle = oneDeviceData->agDevHandle;
8589 if (oneDeviceData->valid == agTRUE)
8591 saSetDeviceState(agRoot, agNULL, tdsmRotateQnumber(smRoot, smDeviceHandle), agDevHandle, SA_DS_OPERATIONAL);
8594 tdsmIOCompletedCB( smRoot,
8595 smIORequestBody->smIORequest,
8602 case OSSA_IO_PORT_IN_RESET:
8603 case OSSA_IO_DS_IN_RECOVERY:
8604 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: OSSA_IO_DS_IN_RECOVERY or OSSA_IO_PORT_IN_RESET status %x\n", agIOStatus));
8605 tdsmIOCompletedCB( smRoot,
8606 smIORequestBody->smIORequest,
8613 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
8614 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
8615 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
8616 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
8617 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
8618 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: SSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_XX status %x\n", agIOStatus));
8619 tdsmIOCompletedCB( smRoot,
8620 smIORequestBody->smIORequest,
8626 case OSSA_IO_DS_INVALID:
8627 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: OSSA_IO_DS_INVALID status %x\n", agIOStatus));
8628 tdsmIOCompletedCB( smRoot,
8629 smIORequestBody->smIORequest,
8636 case OSSA_MPI_IO_RQE_BUSY_FULL:
8637 case OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE:
8638 case OSSA_MPI_ERR_ATAPI_DEVICE_BUSY:
8639 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_MPI_%x!!!\n", agIOStatus));
8640 tdsmIOCompletedCB( smRoot,
8641 smIORequestBody->smIORequest,
8648 case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS: /* fall through */
8650 case OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH:
8652 case OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID: /* fall through */
8653 case OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH: /* fall through */
8654 case OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR: /* fall through */
8655 case OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS:
8656 case OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE:
8658 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = ENCRYPTION ERROR 0x%x!!!\n", agIOStatus));
8659 smsatEncryptionHandler(smRoot,
8669 case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH: /* fall through */
8670 case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH: /* fall through */
8671 case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH:
8672 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = DIF ERROR 0x%x!!!\n", agIOStatus));
8673 smsatDifHandler(smRoot,
8684 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = unknown!!!\n"));
8685 tdsmIOCompletedCB( smRoot,
8686 smIORequestBody->smIORequest,
8700 agsaIORequest_t *agIORequest,
8702 agsaFisHeader_t *agFirstDword,
8709 In the process of SAT_IDENTIFY_DEVICE during discovery
8711 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
8712 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
8713 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
8714 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
8715 smRoot_t *smRoot = agNULL;
8716 smIntRoot_t *smIntRoot = agNULL;
8717 smIntContext_t *smAllShared = agNULL;
8718 smIORequestBody_t *smIORequestBody;
8719 smIORequestBody_t *smOrgIORequestBody = agNULL;
8720 smDeviceHandle_t *smDeviceHandle;
8721 smSatIOContext_t *satIOContext;
8722 smSatIOContext_t *satOrgIOContext;
8723 smSatIOContext_t *satNewIOContext;
8724 smSatInternalIo_t *satIntIo;
8725 smSatInternalIo_t *satNewIntIo = agNULL;
8726 smDeviceData_t *oneDeviceData;
8727 smIORequest_t *smOrgIORequest = agNULL;
8728 // agsaFisRegD2HData_t *deviceToHostFisData = agNULL;
8729 // bit8 signature[8];
8730 #ifdef TD_DEBUG_ENABLE
8731 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL;
8732 bit32 ataStatus = 0;
8735 agsaSATAIdentifyData_t *pSATAIdData;
8736 bit16 *tmpptr, tmpptr_tmp;
8738 void *sglVirtualAddr;
8740 // tdsaPortContext_t *onePortContext = agNULL;
8741 // tiPortalContext_t *tiPortalContext = agNULL;
8742 // bit32 retry_status;
8743 smIORequest_t *smIORequest;
8744 agsaDevHandle_t *agDevHandle = agNULL;
8746 SM_DBG1(("smsatIDStartCB: start\n"));
8747 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
8748 satIOContext = (smSatIOContext_t *) ioContext;
8749 satIntIo = satIOContext->satIntIoContext;
8750 oneDeviceData = satIOContext->pSatDevData;
8751 smDeviceHandle = satIOContext->psmDeviceHandle;
8752 smRoot = oneDeviceData->smRoot;
8753 smIntRoot = (smIntRoot_t *)smRoot->smData;
8754 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
8755 SM_DBG1(("smsatIDStartCB: did %d\n", oneDeviceData->id));
8756 // onePortContext = oneDeviceData->tdPortContext;
8757 // tiPortalContext= onePortContext->tiPortalContext;
8758 oneDeviceData->IDDeviceValid = agFALSE;
8759 if (satIntIo == agNULL)
8761 SM_DBG1(("smsatIDStartCB: External, OS generated!!!\n"));
8762 SM_DBG1(("smsatIDStartCB: Not possible case!!!\n"));
8763 satOrgIOContext = satIOContext;
8764 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
8766 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
8768 smsatFreeIntIoResource( smRoot,
8775 SM_DBG3(("smsatIDStartCB: Internal, SM generated\n"));
8776 satOrgIOContext = satIOContext->satOrgIOContext;
8777 if (satOrgIOContext == agNULL)
8779 SM_DBG5(("smsatIDStartCB: satOrgIOContext is NULL\n"));
8783 SM_DBG5(("smsatIDStartCB: satOrgIOContext is NOT NULL\n"));
8784 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
8785 if (smOrgIORequestBody == agNULL)
8787 SM_DBG1(("smsatIDStartCB: smOrgIORequestBody is NULL!!!\n"));
8788 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
8790 smsatFreeIntIoResource(smRoot, oneDeviceData, satIntIo);
8794 sglVirtualAddr = satIntIo->satIntSmScsiXchg.sglVirtualAddr;
8796 smOrgIORequest = smIORequestBody->smIORequest;
8797 smIORequest = smOrgIORequestBody->smIORequest;
8798 smIORequestBody->ioCompleted = agTRUE;
8799 smIORequestBody->ioStarted = agFALSE;
8802 if ( agIOStatus == OSSA_IO_XFER_OPEN_RETRY_TIMEOUT ||
8803 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY ||
8804 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED ||
8805 agIOStatus == OSSA_IO_DS_NON_OPERATIONAL )
8807 SM_DBG1(("smsatIDStartCB: OPEN_RETRY_TIMEOUT or STP_RESOURCES_BUSY or OPEN_RETRY_BACKOFF_THRESHOLD_REACHED or OSSA_IO_DS_NON_OPERATIONAL!!! 0x%x\n", agIOStatus));
8808 SM_DBG1(("smsatIDStartCB: did %d!!!\n", oneDeviceData->id));
8809 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
8811 smsatFreeIntIoResource( smRoot,
8815 SM_DBG2(("smsatIDStartCB: smOrgIORequestBody %p smIORequest %p\n", smOrgIORequestBody, smIORequest));
8816 SM_DBG2(("smsatIDStartCB: smOrgIORequestBody->id %d\n", smOrgIORequestBody->id));
8817 if (agIOStatus == OSSA_IO_XFER_OPEN_RETRY_TIMEOUT)
8819 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIORetry, &(oneDeviceData->satIdentifyData));
8821 else if ( agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED ||
8822 agIOStatus == OSSA_IO_DS_NON_OPERATIONAL )
8824 /* set device to operational */
8825 agDevHandle = oneDeviceData->agDevHandle;
8826 if (oneDeviceData->valid == agTRUE)
8828 saSetDeviceState(agRoot, agNULL, tdsmRotateQnumber(smRoot, smDeviceHandle), agDevHandle, SA_DS_OPERATIONAL);
8830 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIORetry, &(oneDeviceData->satIdentifyData));
8834 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSTPResourceBusy, &(oneDeviceData->satIdentifyData));
8839 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
8841 SM_DBG1(("smsatIDStartCB: agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
8842 SM_DBG1(("smsatIDStartCB: did %d!!!\n", oneDeviceData->id));
8843 SM_DBG1(("smsatIDStartCB: before pending IO %d NCQ pending IO %d NONNCQ pending IO %d\n",
8844 oneDeviceData->satPendingIO, oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
8846 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
8848 SM_DBG1(("smsatIDStartCB: after pending IO %d NCQ pending IO %d NONNCQ pending IO %d\n",
8849 oneDeviceData->satPendingIO, oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
8851 smsatFreeIntIoResource( smRoot,
8855 SM_DBG2(("smsatIDStartCB: smOrgIORequestBody %p smIORequest %p\n", smOrgIORequestBody, smIORequest));
8856 SM_DBG2(("smsatIDStartCB: smOrgIORequestBody->id %d\n", smOrgIORequestBody->id));
8857 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData));
8861 if (agIOStatus == OSSA_IO_ABORTED ||
8862 agIOStatus == OSSA_IO_UNDERFLOW ||
8863 agIOStatus == OSSA_IO_XFER_ERROR_BREAK ||
8864 agIOStatus == OSSA_IO_XFER_ERROR_PHY_NOT_READY ||
8865 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED ||
8866 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK ||
8867 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS ||
8868 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION ||
8869 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED ||
8870 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION ||
8871 agIOStatus == OSSA_IO_XFER_ERROR_NAK_RECEIVED ||
8872 agIOStatus == OSSA_IO_XFER_ERROR_DMA ||
8873 agIOStatus == OSSA_IO_XFER_ERROR_SATA_LINK_TIMEOUT ||
8874 agIOStatus == OSSA_IO_XFER_ERROR_REJECTED_NCQ_MODE ||
8875 agIOStatus == OSSA_IO_NO_DEVICE ||
8876 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION ||
8877 agIOStatus == OSSA_IO_PORT_IN_RESET ||
8878 agIOStatus == OSSA_IO_DS_NON_OPERATIONAL ||
8879 agIOStatus == OSSA_IO_DS_IN_RECOVERY ||
8880 agIOStatus == OSSA_IO_DS_IN_ERROR ||
8881 agIOStatus == OSSA_IO_DS_INVALID
8884 SM_DBG1(("smsatIDStartCB: OSSA_IO_OPEN_CNX_ERROR 0x%x!!!\n", agIOStatus));
8885 SM_DBG1(("smsatIDStartCB: did %d!!!\n", oneDeviceData->id));
8886 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
8888 smsatFreeIntIoResource( smRoot,
8893 SM_DBG2(("smsatIDStartCB: smOrgIORequestBody %p smIORequest %p\n", smOrgIORequestBody, smIORequest));
8894 SM_DBG2(("smsatIDStartCB: smOrgIORequestBody->id %d\n", smOrgIORequestBody->id));
8895 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData));
8899 if ( agIOStatus != OSSA_IO_SUCCESS ||
8900 (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL && agIOInfoLen != 0)
8903 #ifdef TD_DEBUG_ENABLE
8904 /* only agsaFisPioSetup_t is expected */
8905 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup);
8906 ataStatus = satPIOSetupHeader->status; /* ATA Status register */
8907 ataError = satPIOSetupHeader->error; /* ATA Eror register */
8909 SM_DBG1(("smsatIDStartCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError));
8911 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
8913 smsatFreeIntIoResource( smRoot,
8917 SM_DBG2(("smsatIDStartCB: smOrgIORequestBody %p smIORequest %p\n", smOrgIORequestBody, smIORequest));
8918 SM_DBG2(("smsatIDStartCB: smOrgIORequestBody->id %d\n", smOrgIORequestBody->id));
8921 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData));
8928 SM_DBG3(("smsatIDStartCB: Success\n"));
8929 SM_DBG3(("smsatIDStartCB: Success did %d\n", oneDeviceData->id));
8931 /* Convert to host endian */
8932 tmpptr = (bit16*)sglVirtualAddr;
8933 for (x=0; x < sizeof(agsaSATAIdentifyData_t)/sizeof(bit16); x++)
8935 OSSA_READ_LE_16(AGROOT, &tmpptr_tmp, tmpptr, 0);
8936 *tmpptr = tmpptr_tmp;
8940 pSATAIdData = (agsaSATAIdentifyData_t *)sglVirtualAddr;
8941 //smhexdump("satAddSATAIDDevCB before", (bit8 *)pSATAIdData, sizeof(agsaSATAIdentifyData_t));
8943 SM_DBG5(("smsatIDStartCB: OS satOrgIOContext %p \n", satOrgIOContext));
8944 SM_DBG5(("smsatIDStartCB: TD satIOContext %p \n", satIOContext));
8945 SM_DBG5(("smsatIDStartCB: OS tiScsiXchg %p \n", satOrgIOContext->smScsiXchg));
8946 SM_DBG5(("smsatIDStartCB: TD tiScsiXchg %p \n", satIOContext->smScsiXchg));
8949 /* copy ID Dev data to oneDeviceData */
8950 oneDeviceData->satIdentifyData = *pSATAIdData;
8951 oneDeviceData->IDDeviceValid = agTRUE;
8953 #ifdef SM_INTERNAL_DEBUG
8954 smhexdump("smsatIDStartCB ID Dev data",(bit8 *)pSATAIdData, sizeof(agsaSATAIdentifyData_t));
8955 smhexdump("smsatIDStartCB Device ID Dev data",(bit8 *)&oneDeviceData->satIdentifyData, sizeof(agsaSATAIdentifyData_t));
8958 /* set oneDeviceData fields from IndentifyData */
8959 smsatSetDevInfo(oneDeviceData,pSATAIdData);
8960 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
8962 smsatFreeIntIoResource( smRoot,
8966 if (smIORequest->tdData == smIORequest->smData)
8968 SM_DBG1(("smsatIDStartCB: the same tdData and smData error!\n"));
8971 /* send the Set Feature ATA command to SATA device for enbling PIO and DMA transfer mode*/
8972 satNewIntIo = smsatAllocIntIoResource( smRoot,
8978 if (satNewIntIo == agNULL)
8980 SM_DBG1(("smsatIDStartCB: momory allocation fails\n"));
8981 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData));
8983 } /* end memory allocation */
8985 satNewIOContext = smsatPrepareNewIO(satNewIntIo,
8992 status = smsatSetFeaturesPIO(smRoot,
8993 &satNewIntIo->satIntSmIORequest,
8994 satNewIOContext->psmDeviceHandle,
8995 &satNewIntIo->satIntSmScsiXchg, /* orginal from OS layer */
8999 if (status != SM_RC_SUCCESS)
9001 smsatFreeIntIoResource(smRoot,
9004 /* clean up TD layer's IORequestBody */
9005 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData));
9008 SM_DBG2(("smsatIDStartCB: End device id %d\n", oneDeviceData->id));
9016 smIORequest_t *smIORequest,
9017 agsaFisHeader_t *agFirstDword,
9019 agsaFrameHandle_t agFrameHandle,
9020 smSatIOContext_t *satIOContext,
9021 bit32 interruptContext
9024 // satDeviceData_t *pSatDevData;
9025 smDeviceData_t *oneDeviceData;
9026 smScsiRspSense_t *pSense;
9027 #ifdef TD_DEBUG_ENABLE
9028 smIniScsiCmnd_t *pScsiCmnd;
9030 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
9031 bit32 ataStatus = 0;
9033 smSatInternalIo_t *satIntIo = agNULL;
9035 // agsaRoot_t *agRoot;
9036 // agsaDevHandle_t *agDevHandle;
9037 smDeviceHandle_t *smDeviceHandle;
9038 smSatIOContext_t *satIOContext2;
9039 smIORequestBody_t *smIORequestBody;
9040 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
9041 agsaFisSetDevBitsHeader_t *statSetDevBitFisHeader = agNULL;
9042 smIORequest_t smIORequestTMP;
9044 pSense = satIOContext->pSense;
9045 oneDeviceData = satIOContext->pSatDevData;
9046 #ifdef TD_DEBUG_ENABLE
9047 pScsiCmnd = satIOContext->pScsiCmnd;
9049 hostToDevFis = satIOContext->pFis;
9052 // agRoot = ((tdsaDeviceData_t *)(pSatDevData->satSaDeviceData))->agRoot;
9053 // agDevHandle = ((tdsaDeviceData_t *)(pSatDevData->satSaDeviceData))->agDevHandle;
9054 // tiDeviceHandle = &((tdsaDeviceData_t *)(pSatDevData->satSaDeviceData))->tiDeviceHandle;
9055 smDeviceHandle = satIOContext->psmDeviceHandle;
9057 * Find out the type of response FIS:
9058 * Set Device Bit FIS or Reg Device To Host FIS.
9061 /* First assume it is Reg Device to Host FIS */
9062 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
9063 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
9064 ataError = statDevToHostFisHeader->error; /* ATA Eror register */
9066 SM_DBG5(("smsatIOCompleted: start\n"));
9069 SM_DBG1(("smsatIOCompleted: H to D command 0x%x!!!\n", hostToDevFis->h.command));
9070 SM_DBG1(("smsatIOCompleted: D to H fistype 0x%x!!!\n", statDevToHostFisHeader->fisType));
9073 if (statDevToHostFisHeader->fisType == SET_DEV_BITS_FIS)
9075 /* It is Set Device Bits FIS */
9076 statSetDevBitFisHeader = (agsaFisSetDevBitsHeader_t *)&(agFirstDword->D2H);
9077 /* Get ATA Status register */
9078 ataStatus = (statSetDevBitFisHeader->statusHi_Lo & 0x70); /* bits 4,5,6 */
9079 ataStatus = ataStatus | (statSetDevBitFisHeader->statusHi_Lo & 0x07); /* bits 0,1,2 */
9081 /* ATA Eror register */
9082 ataError = statSetDevBitFisHeader->error;
9084 statDevToHostFisHeader = agNULL;
9087 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
9089 SM_DBG1(("smsatIOCompleted: *** UNEXPECTED RESP FIS TYPE 0x%x *** smIORequest=%p!!!\n",
9090 statDevToHostFisHeader->fisType, smIORequest));
9092 smsatSetSensePayload( pSense,
9093 SCSI_SNSKEY_HARDWARE_ERROR,
9095 SCSI_SNSCODE_INTERNAL_TARGET_FAILURE,
9098 tdsmIOCompletedCB( smRoot,
9101 SCSI_STAT_CHECK_CONDITION,
9102 satIOContext->pSmSenseData,
9108 if ( ataStatus & DF_ATA_STATUS_MASK )
9110 oneDeviceData->satDeviceFaultState = agTRUE;
9114 oneDeviceData->satDeviceFaultState = agFALSE;
9117 SM_DBG5(("smsatIOCompleted: smIORequest=%p CDB=0x%x ATA CMD =0x%x\n",
9118 smIORequest, pScsiCmnd->cdb[0], hostToDevFis->h.command));
9121 * Decide which ATA command is the translation needed
9123 switch(hostToDevFis->h.command)
9125 case SAT_READ_FPDMA_QUEUED:
9126 case SAT_WRITE_FPDMA_QUEUED:
9128 /************************************************************************
9130 * !!!! See Section 13.5.2.4 of SATA 2.5 specs. !!!!
9131 * !!!! If the NCQ error ends up here, it means that the device sent !!!!
9132 * !!!! Set Device Bit FIS (which has SActive register) instead of !!!!
9133 * !!!! Register Device To Host FIS (which does not have SActive !!!!
9134 * !!!! register). The callback ossaSATAEvent() deals with the case !!!!
9135 * !!!! where Register Device To Host FIS was sent by the device. !!!!
9137 * For NCQ we need to issue READ LOG EXT command with log page 10h
9138 * to get the error and to allow other I/Os to continue.
9140 * Here is the basic flow or sequence of error recovery, note that due
9141 * to the SATA HW assist that we have, this sequence is slighly different
9142 * from the one described in SATA 2.5:
9144 * 1. Set SATA device flag to indicate error condition and returning busy
9145 * for all new request.
9146 * return SM_RC_SUCCESS;
9148 * 2. Because the HW/LL layer received Set Device Bit FIS, it can get the
9149 * tag or I/O context for NCQ request, SATL would translate the ATA error
9150 * to SCSI status and return the original NCQ I/O with the appopriate
9153 * 3. Prepare READ LOG EXT page 10h command. Set flag to indicate that
9154 * the failed I/O has been returned to the OS Layer. Send command.
9156 * 4. When the device receives READ LOG EXT page 10h request all other
9157 * pending I/O are implicitly aborted. No completion (aborted) status
9158 * will be sent to the host for these aborted commands.
9160 * 5. SATL receives the completion for READ LOG EXT command in
9161 * smsatReadLogExtCB(). Steps 6,7,8,9 below are the step 1,2,3,4 in
9162 * smsatReadLogExtCB().
9164 * 6. Check flag that indicates whether the failed I/O has been returned
9165 * to the OS Layer. If not, search the I/O context in device data
9166 * looking for a matched tag. Then return the completion of the failed
9167 * NCQ command with the appopriate/trasnlated SCSI status.
9169 * 7. Issue abort to LL layer to all other pending I/Os for the same SATA
9172 * 8. Free resource allocated for the internally generated READ LOG EXT.
9174 * 9. At the completion of abort, in the context of ossaSATACompleted(),
9175 * return the I/O with error status to the OS-App Specific layer.
9176 * When all I/O aborts are completed, clear SATA device flag to
9177 * indicate ready to process new request.
9179 ***********************************************************************/
9181 SM_DBG1(("smsatIOCompleted: NCQ ERROR smIORequest=%p ataStatus=0x%x ataError=0x%x!!!\n",
9182 smIORequest, ataStatus, ataError ));
9184 /* Set flag to indicate we are in recovery */
9185 oneDeviceData->satDriveState = SAT_DEV_STATE_IN_RECOVERY;
9187 /* Return the failed NCQ I/O to OS-Apps Specifiic layer */
9188 smsatDefaultTranslation( smRoot,
9197 * Allocate resource for READ LOG EXT page 10h
9199 satIntIo = smsatAllocIntIoResource( smRoot,
9200 &(smIORequestTMP), /* anything but NULL */
9202 sizeof (satReadLogExtPage10h_t),
9206 * If we cannot allocate resource for READ LOG EXT 10 in order to do
9207 * the normal NCQ recovery, we will do SATA device reset.
9209 if (satIntIo == agNULL)
9211 SM_DBG1(("smsatIOCompleted: can't send RLE due to resource lack!!!\n"));
9213 /* Abort I/O after completion of device reset */
9214 oneDeviceData->satAbortAfterReset = agTRUE;
9216 /* needs further investigation */
9217 /* no report to OS layer */
9220 SM_INTERNAL_TM_RESET,
9228 SM_DBG1(("smsatIOCompleted: calling saSATADeviceReset 1!!!\n"));
9234 * Set flag to indicate that the failed I/O has been returned to the
9235 * OS-App specific Layer.
9237 satIntIo->satIntFlag = AG_SAT_INT_IO_FLAG_ORG_IO_COMPLETED;
9239 /* compare to satPrepareNewIO() */
9240 /* Send READ LOG EXIT page 10h command */
9243 * Need to initialize all the fields within satIOContext except
9244 * reqType and satCompleteCB which will be set depending on cmd.
9247 smIORequestBody = (smIORequestBody_t *)satIntIo->satIntRequestBody;
9248 satIOContext2 = &(smIORequestBody->transport.SATA.satIOContext);
9250 satIOContext2->pSatDevData = oneDeviceData;
9251 satIOContext2->pFis = &(smIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev);
9252 satIOContext2->pScsiCmnd = &(satIntIo->satIntSmScsiXchg.scsiCmnd);
9253 satIOContext2->pSense = &(smIORequestBody->transport.SATA.sensePayload);
9254 satIOContext2->pSmSenseData = &(smIORequestBody->transport.SATA.smSenseData);
9255 satIOContext2->pSmSenseData->senseData = satIOContext2->pSense;
9257 satIOContext2->smRequestBody = satIntIo->satIntRequestBody;
9258 satIOContext2->interruptContext = interruptContext;
9259 satIOContext2->satIntIoContext = satIntIo;
9261 satIOContext2->psmDeviceHandle = smDeviceHandle;
9262 satIOContext2->satOrgIOContext = agNULL;
9263 satIOContext2->smScsiXchg = agNULL;
9265 status = smsatSendReadLogExt( smRoot,
9266 &satIntIo->satIntSmIORequest,
9268 &satIntIo->satIntSmScsiXchg,
9271 if (status != SM_RC_SUCCESS)
9273 SM_DBG1(("smsatIOCompleted: can't send RLE due to LL api failure!!!\n"));
9274 smsatFreeIntIoResource( smRoot,
9278 /* Abort I/O after completion of device reset */
9279 oneDeviceData->satAbortAfterReset = agTRUE;
9281 /* needs further investigation */
9282 /* no report to OS layer */
9285 SM_INTERNAL_TM_RESET,
9292 SM_DBG1(("smsatIOCompleted: calling saSATADeviceReset 2!!!\n"));
9298 case SAT_READ_DMA_EXT:
9300 /* Use default status/error translation */
9304 /* Use default status/error translation */
9307 smsatDefaultTranslation( smRoot,
9322 smsatEncryptionHandler(
9324 agsaIORequest_t *agIORequest,
9329 bit32 interruptContext
9332 smIORequestBody_t *smIORequestBody;
9333 bit32 errorDetail = smDetailOtherError;
9335 SM_DBG1(("smsatEncryptionHandler: start\n"));
9336 SM_DBG1(("smsatEncryptionHandler: agIOStatus 0x%x\n", agIOStatus));
9338 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
9342 case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS:
9343 SM_DBG1(("smsatEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS\n"));
9344 errorDetail = smDetailDekKeyCacheMiss;
9346 case OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID:
9347 SM_DBG1(("smsatEncryptionHandler: OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID\n"));
9348 errorDetail = smDetailCipherModeInvalid;
9350 case OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH:
9351 SM_DBG1(("smsatEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH\n"));
9352 errorDetail = smDetailDekIVMismatch;
9354 case OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR:
9355 SM_DBG1(("smsatEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR\n"));
9356 errorDetail = smDetailDekRamInterfaceError;
9358 case OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS:
9359 SM_DBG1(("smsatEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS\n"));
9360 errorDetail = smDetailDekIndexOutofBounds;
9362 case OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE:
9363 SM_DBG1(("smsatEncryptionHandler:OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE\n"));
9364 errorDetail = smDetailOtherError;
9367 SM_DBG1(("smsatEncryptionHandler: other error!!! 0x%x\n", agIOStatus));
9368 errorDetail = smDetailOtherError;
9372 tdsmIOCompletedCB( smRoot,
9373 smIORequestBody->smIORequest,
9385 agsaIORequest_t *agIORequest,
9390 bit32 interruptContext
9393 smIORequestBody_t *smIORequestBody;
9394 bit32 errorDetail = smDetailOtherError;
9395 #ifdef TD_DEBUG_ENABLE
9396 agsaDifDetails_t *DifDetail;
9399 SM_DBG1(("smsatDifHandler: start\n"));
9400 SM_DBG1(("smsatDifHandler: agIOStatus 0x%x\n", agIOStatus));
9401 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
9402 #ifdef TD_DEBUG_ENABLE
9403 DifDetail = (agsaDifDetails_t *)agParam;
9408 case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH:
9409 SM_DBG1(("smsatDifHandler: OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH\n"));
9410 errorDetail = smDetailDifAppTagMismatch;
9412 case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH:
9413 SM_DBG1(("smsatDifHandler: OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH\n"));
9414 errorDetail = smDetailDifRefTagMismatch;
9416 case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH:
9417 SM_DBG1(("smsatDifHandler: OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH\n"));
9418 errorDetail = smDetailDifCrcMismatch;
9421 SM_DBG1(("smsatDifHandler: other error!!! 0x%x\n", agIOStatus));
9422 errorDetail = smDetailOtherError;
9426 SM_DBG1(("smsatDifHandler: DIF detail UpperLBA 0x%08x LowerLBA 0x%08x\n", DifDetail->UpperLBA, DifDetail->LowerLBA));
9428 tdsmIOCompletedCB( smRoot,
9429 smIORequestBody->smIORequest,
9441 smIORequest_t *smIORequest,
9442 smSatIOContext_t *satIOContext
9445 smDeviceData_t *oneDeviceData;
9447 smDeviceHandle_t *smDeviceHandle;
9449 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
9451 SM_DBG5(("smsatProcessAbort: start\n"));
9453 oneDeviceData = satIOContext->pSatDevData;
9455 smDeviceHandle = satIOContext->psmDeviceHandle;
9457 hostToDevFis = satIOContext->pFis;
9459 if ( (hostToDevFis->h.command == SAT_SMART && hostToDevFis->h.features == SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE) &&
9460 (hostToDevFis->d.lbaLow != 0x01 && hostToDevFis->d.lbaLow != 0x02)
9463 /* no completion for send diagnotic in background. It is done in satSendDiagnostic() */
9464 tdsmIOCompletedCB( smRoot,
9469 satIOContext->interruptContext);
9472 if ( oneDeviceData->satTmTaskTag != agNULL )
9474 SM_DBG1(("smsatProcessAbort: TM callback!!!\n"));
9477 tdsmEventCB( smRoot,
9479 smIntrEventTypeTaskManagement,
9481 oneDeviceData->satTmTaskTag);
9486 oneDeviceData->satTmTaskTag = agNULL;
9490 * Check if we are in recovery mode and need to update the recovery flag
9492 if ((oneDeviceData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) &&
9493 (oneDeviceData->satPendingIO == 0 ))
9495 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
9496 SM_DBG1(("smsatProcessAbort: STATE NORMAL.!!!\n"));
9498 SM_DBG1(("smsatProcessAbort: satDriveState %d!!!\n", oneDeviceData->satDriveState));
9499 SM_DBG1(("smsatProcessAbort: satPendingIO %d satNCQMaxIO %d!!!\n", oneDeviceData->satPendingIO, oneDeviceData->satNCQMaxIO ));
9500 SM_DBG1(("smsatProcessAbort: satPendingNCQIO %d satPendingNONNCQIO %d!!!\n", oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
9509 agsaIORequest_t *agIORequest,
9511 agsaFisHeader_t *agFirstDword,
9517 smRoot_t *smRoot = agNULL;
9518 smIntRoot_t *smIntRoot = agNULL;
9519 smIntContext_t *smAllShared = agNULL;
9520 smIORequestBody_t *smIORequestBody;
9521 bit32 interruptContext;
9522 smSatIOContext_t *satIOContext;
9523 smDeviceData_t *oneDeviceData;
9525 SM_DBG2(("smsatNonDataIOCB: start\n"));
9526 SM_DBG5(("satNonDataIOCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n",
9527 agIORequest, agIOStatus, agIOInfoLen));
9529 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
9530 satIOContext = (smSatIOContext_t *) ioContext;
9531 oneDeviceData = satIOContext->pSatDevData;
9532 smRoot = oneDeviceData->smRoot;
9533 smIntRoot = (smIntRoot_t *)smRoot->smData;
9534 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
9535 interruptContext = satIOContext->interruptContext;
9537 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
9540 smIORequestBody->ioCompleted = agTRUE;
9541 smIORequestBody->ioStarted = agFALSE;
9543 /* Process completion */
9544 if( (agIOStatus == OSSA_IO_SUCCESS) && (agIOInfoLen==0))
9547 SM_DBG1(("satNonDataIOCB: *** ERROR*** agIORequest=%p agIOStatus=0x%x agIOInfoLen %d!!!\n",
9548 agIORequest, agIOStatus, agIOInfoLen));
9550 tdsmIOCompletedCB( smRoot,
9551 smIORequestBody->smIORequest,
9559 /* More checking needed, for non-data IO this should be the normal case */
9560 smsatProcessAbnormalCompletion( agRoot,
9574 agsaIORequest_t *agIORequest,
9576 agsaFisHeader_t *agFirstDword,
9583 In the process of Inquiry
9584 Process SAT_IDENTIFY_DEVICE
9586 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
9587 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
9588 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
9589 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
9590 smRoot_t *smRoot = agNULL;
9591 smIntRoot_t *smIntRoot = agNULL;
9592 smIntContext_t *smAllShared = agNULL;
9593 smIORequestBody_t *smIORequestBody;
9594 smIORequestBody_t *smOrgIORequestBody;
9595 smSatIOContext_t *satIOContext;
9596 smSatIOContext_t *satOrgIOContext;
9597 smSatInternalIo_t *satIntIo;
9598 // satDeviceData_t *satDevData;
9599 smDeviceData_t *oneDeviceData;
9600 smScsiRspSense_t *pSense;
9601 smIniScsiCmnd_t *scsiCmnd;
9602 smIORequest_t *smOrgIORequest;
9603 #ifdef TD_DEBUG_ENABLE
9604 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL;
9605 bit32 ataStatus = 0;
9608 smScsiInitiatorRequest_t *smScsiRequest; /* TD's smScsiXchg */
9609 smScsiInitiatorRequest_t *smOrgScsiRequest; /* OS's smScsiXchg */
9610 agsaSATAIdentifyData_t *pSATAIdData;
9613 bit16 *tmpptr,tmpptr_tmp;
9615 bit32 lenReceived = 0;
9616 bit32 allocationLen = 0;
9617 bit32 lenNeeded = 0;
9618 bit8 dataBuffer[SATA_PAGE89_INQUIRY_SIZE] = {0};
9621 SM_DBG6(("smsatInquiryCB: start\n"));
9622 SM_DBG6(("smsatInquiryCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
9624 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
9625 satIOContext = (smSatIOContext_t *) ioContext;
9626 satIntIo = satIOContext->satIntIoContext;
9627 oneDeviceData = satIOContext->pSatDevData;
9628 smScsiRequest = satIOContext->smScsiXchg;
9629 smRoot = oneDeviceData->smRoot;
9630 smIntRoot = (smIntRoot_t *)smRoot->smData;
9631 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
9633 if (satIntIo == agNULL)
9635 SM_DBG6(("smsatInquiryCB: External, OS generated\n"));
9636 pSense = satIOContext->pSense;
9637 scsiCmnd = satIOContext->pScsiCmnd;
9638 satOrgIOContext = satIOContext;
9639 smOrgIORequest = smIORequestBody->smIORequest;
9643 SM_DBG6(("smsatInquiryCB: Internal, TD generated\n"));
9644 satOrgIOContext = satIOContext->satOrgIOContext;
9645 if (satOrgIOContext == agNULL)
9647 SM_DBG1(("smsatInquiryCB: satOrgIOContext is NULL, wrong!!!\n"));
9652 SM_DBG6(("smsatInquiryCB: satOrgIOContext is NOT NULL\n"));
9654 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
9655 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
9656 pSense = satOrgIOContext->pSense;
9657 scsiCmnd = satOrgIOContext->pScsiCmnd;
9660 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
9661 pInquiry = dataBuffer;
9663 smIORequestBody->ioCompleted = agTRUE;
9664 smIORequestBody->ioStarted = agFALSE;
9666 SM_DBG3(("smsatInquiryCB: did %d\n", oneDeviceData->id));
9668 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
9670 SM_DBG1(("smsatInquiryCB: agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
9671 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY)
9673 SM_DBG1(("smsatInquiryCB: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY!!!\n"));
9674 /* should NOT be retried */
9675 tdsmIOCompletedCB( smRoot,
9680 satOrgIOContext->interruptContext
9685 SM_DBG1(("smsatInquiryCB: NOT OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY!!!\n"));
9686 tdsmIOCompletedCB( smRoot,
9691 satOrgIOContext->interruptContext
9694 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
9696 smsatFreeIntIoResource( smRoot,
9701 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED ||
9702 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION ||
9703 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK ||
9704 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS ||
9705 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION ||
9706 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED ||
9707 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION ||
9708 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR ||
9709 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY
9712 SM_DBG1(("smsatInquiryCB: OSSA_IO_OPEN_CNX_ERROR!!!\n"));
9714 tdsmIOCompletedCB( smRoot,
9719 satOrgIOContext->interruptContext
9722 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
9724 smsatFreeIntIoResource( smRoot,
9730 if ( agIOStatus != OSSA_IO_SUCCESS ||
9731 (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL && agIOInfoLen != 0)
9734 #ifdef TD_DEBUG_ENABLE
9735 /* only agsaFisPioSetup_t is expected */
9736 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup);
9737 ataStatus = satPIOSetupHeader->status; /* ATA Status register */
9738 ataError = satPIOSetupHeader->error; /* ATA Eror register */
9740 SM_DBG1(("smsatInquiryCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError));
9742 /* Process abort case */
9743 if (agIOStatus == OSSA_IO_ABORTED)
9745 smsatProcessAbort(smRoot,
9750 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
9752 smsatFreeIntIoResource( smRoot,
9758 tdsmIOCompletedCB( smRoot,
9763 satOrgIOContext->interruptContext
9766 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
9768 smsatFreeIntIoResource( smRoot,
9777 /* Convert to host endian */
9778 tmpptr = (bit16*)(smScsiRequest->sglVirtualAddr);
9779 for (x=0; x < sizeof(agsaSATAIdentifyData_t)/sizeof(bit16); x++)
9781 OSSA_READ_LE_16(AGROOT, &tmpptr_tmp, tmpptr, 0);
9782 *tmpptr = tmpptr_tmp;
9784 /*Print tmpptr_tmp here for debugging purpose*/
9787 pSATAIdData = (agsaSATAIdentifyData_t *)(smScsiRequest->sglVirtualAddr);
9789 SM_DBG5(("smsatInquiryCB: OS satOrgIOContext %p \n", satOrgIOContext));
9790 SM_DBG5(("smsatInquiryCB: TD satIOContext %p \n", satIOContext));
9791 SM_DBG5(("smsatInquiryCB: OS smScsiXchg %p \n", satOrgIOContext->smScsiXchg));
9792 SM_DBG5(("smsatInquiryCB: TD smScsiXchg %p \n", satIOContext->smScsiXchg));
9794 /* copy ID Dev data to oneDeviceData */
9795 oneDeviceData->satIdentifyData = *pSATAIdData;
9796 oneDeviceData->IDDeviceValid = agTRUE;
9797 #ifdef SM_INTERNAL_DEBUG
9798 smhexdump("smsatInquiryCB ID Dev data",(bit8 *)pSATAIdData, sizeof(agsaSATAIdentifyData_t));
9799 smhexdump("smsatInquiryCB Device ID Dev data",(bit8 *)&oneDeviceData->satIdentifyData, sizeof(agsaSATAIdentifyData_t));
9801 // smhexdump("smsatInquiryCB Device ID Dev data",(bit8 *)&oneDeviceData->satIdentifyData, sizeof(agsaSATAIdentifyData_t));
9803 /* set oneDeviceData fields from IndentifyData */
9804 smsatSetDevInfo(oneDeviceData,pSATAIdData);
9806 allocationLen = ((scsiCmnd->cdb[3]) << 8) + scsiCmnd->cdb[4];
9807 allocationLen = MIN(allocationLen, scsiCmnd->expDataLength);
9809 /* SPC-4, spec 6.4 p 141 */
9811 if (!(scsiCmnd->cdb[1] & SCSI_EVPD_MASK))
9813 /* Returns the standard INQUIRY data */
9814 lenNeeded = STANDARD_INQUIRY_SIZE;
9817 smsatInquiryStandard(pInquiry, pSATAIdData, scsiCmnd);
9818 //smhexdump("smsatInquiryCB ***standard***", (bit8 *)pInquiry, 36);
9823 /* EVPD bit != 0 && PAGE CODE != 0 */
9824 /* returns the pages of vital product data information */
9826 /* we must support page 00h, 83h and 89h */
9827 page = scsiCmnd->cdb[2];
9828 if ((page != INQUIRY_SUPPORTED_VPD_PAGE) &&
9829 (page != INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE) &&
9830 (page != INQUIRY_ATA_INFORMATION_VPD_PAGE) &&
9831 (page != INQUIRY_BLOCK_DEVICE_CHARACTERISTICS_VPD_PAGE))
9833 smsatSetSensePayload( pSense,
9834 SCSI_SNSKEY_ILLEGAL_REQUEST,
9836 SCSI_SNSCODE_INVALID_FIELD_IN_CDB,
9839 tdsmIOCompletedCB( smRoot,
9842 SCSI_STAT_CHECK_CONDITION,
9843 satOrgIOContext->pSmSenseData,
9844 satOrgIOContext->interruptContext );
9846 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
9848 smsatFreeIntIoResource( smRoot,
9851 SM_DBG1(("smsatInquiryCB: invalid PAGE CODE 0x%x!!!\n", page));
9855 /* checking length */
9858 case INQUIRY_SUPPORTED_VPD_PAGE:
9859 lenNeeded = SATA_PAGE0_INQUIRY_SIZE; /* 9 */
9861 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE:
9862 if (oneDeviceData->satWWNSupport)
9864 lenNeeded = SATA_PAGE83_INQUIRY_WWN_SIZE; /* 16 */
9868 lenNeeded = SATA_PAGE83_INQUIRY_NO_WWN_SIZE; /* 76 */
9871 case INQUIRY_ATA_INFORMATION_VPD_PAGE:
9872 lenNeeded = SATA_PAGE89_INQUIRY_SIZE; /* 572 */
9874 case INQUIRY_BLOCK_DEVICE_CHARACTERISTICS_VPD_PAGE:
9875 lenNeeded = SATA_PAGEB1_INQUIRY_SIZE; /* 64 */
9878 SM_DBG1(("smsatInquiryCB: wrong!!! invalid PAGE CODE 0x%x!!!\n", page));
9884 * Fill in the Inquiry data depending on what Inquiry data we are returning.
9888 case INQUIRY_SUPPORTED_VPD_PAGE:
9889 smsatInquiryPage0(pInquiry, pSATAIdData);
9891 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE:
9892 smsatInquiryPage83(pInquiry, pSATAIdData, oneDeviceData);
9894 case INQUIRY_ATA_INFORMATION_VPD_PAGE:
9895 smsatInquiryPage89(pInquiry, pSATAIdData, oneDeviceData, lenReceived);
9897 case INQUIRY_BLOCK_DEVICE_CHARACTERISTICS_VPD_PAGE:
9898 smsatInquiryPageB1(pInquiry, pSATAIdData);
9901 SM_DBG1(("smsatInquiryCB: wrong!!! invalidinvalid PAGE CODE 0x%x!!!\n", page));
9906 SM_DBG6(("smsatInquiryCB: calling tdsmIOCompletedCB\n"));
9908 /* if this is a standard Inquiry command, notify Stoport to set the device queue depth to max NCQ */
9909 if ( (oneDeviceData->satNCQ == agTRUE) &&
9910 ((scsiCmnd->cdb[1] & 0x01) == 0))
9912 if (tdsmSetDeviceQueueDepth(smRoot,
9914 oneDeviceData->satNCQMaxIO-1
9917 SM_DBG1(("smsatInquiryCB: failed to call tdsmSetDeviceQueueDepth()!!! Q=%d\n", oneDeviceData->satNCQMaxIO));
9921 sm_memcpy(smOrgScsiRequest->sglVirtualAddr, dataBuffer, MIN(allocationLen, lenNeeded));
9922 if (allocationLen > lenNeeded)
9924 SM_DBG6(("smsatInquiryCB reporting underrun lenNeeded=0x%x allocationLen=0x%x smIORequest=%p\n",
9925 lenNeeded, allocationLen, smOrgIORequest));
9927 tdsmIOCompletedCB( smRoot,
9930 allocationLen - lenNeeded,
9932 satOrgIOContext->interruptContext );
9936 tdsmIOCompletedCB( smRoot,
9941 satOrgIOContext->interruptContext);
9944 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
9946 smsatFreeIntIoResource( smRoot,
9949 SM_DBG5(("smsatInquiryCB: device %p pending IO %d\n", oneDeviceData, oneDeviceData->satPendingIO));
9950 SM_DBG6(("smsatInquiryCB: end\n"));
9957 smIORequest_t *smIORequest,
9958 smDeviceHandle_t *smDeviceHandle,
9959 smScsiInitiatorRequest_t *smScsiRequest,
9960 smSatIOContext_t *satIOContext
9963 smScsiRspSense_t *pSense;
9964 smIniScsiCmnd_t *scsiCmnd;
9965 // satDeviceData_t *satDevData;
9966 smDeviceData_t *oneDeviceData;
9967 agsaSATAIdentifyData_t *pSATAIdData;
9971 bit32 lenReceived = 0;
9972 bit32 allocationLen = 0;
9973 bit32 lenNeeded = 0;
9974 bit8 dataBuffer[SATA_PAGE89_INQUIRY_SIZE] = {0};
9976 SM_DBG6(("smsatInquiryIntCB: start\n"));
9978 pSense = satIOContext->pSense;
9979 scsiCmnd = &smScsiRequest->scsiCmnd;
9980 pInquiry = dataBuffer;
9981 oneDeviceData = satIOContext->pSatDevData;
9982 pSATAIdData = &oneDeviceData->satIdentifyData;
9984 allocationLen = ((scsiCmnd->cdb[3]) << 8) + scsiCmnd->cdb[4];
9985 allocationLen = MIN(allocationLen, scsiCmnd->expDataLength);
9987 /* SPC-4, spec 6.4 p 141 */
9989 if (!(scsiCmnd->cdb[1] & SCSI_EVPD_MASK))
9991 /* Returns the standard INQUIRY data */
9992 lenNeeded = STANDARD_INQUIRY_SIZE;
9994 smsatInquiryStandard(pInquiry, pSATAIdData, scsiCmnd);
9995 //smhexdump("satInquiryIntCB ***standard***", (bit8 *)pInquiry, 36);
10000 /* EVPD bit != 0 && PAGE CODE != 0 */
10001 /* returns the pages of vital product data information */
10003 /* we must support page 00h, 83h and 89h */
10004 page = scsiCmnd->cdb[2];
10005 if ((page != INQUIRY_SUPPORTED_VPD_PAGE) &&
10006 (page != INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE) &&
10007 (page != INQUIRY_ATA_INFORMATION_VPD_PAGE) &&
10008 (page != INQUIRY_UNIT_SERIAL_NUMBER_VPD_PAGE) &&
10009 (page != INQUIRY_BLOCK_DEVICE_CHARACTERISTICS_VPD_PAGE))
10011 smsatSetSensePayload( pSense,
10012 SCSI_SNSKEY_ILLEGAL_REQUEST,
10014 SCSI_SNSCODE_INVALID_FIELD_IN_CDB,
10017 tdsmIOCompletedCB( smRoot,
10020 SCSI_STAT_CHECK_CONDITION,
10021 satIOContext->pSmSenseData,
10022 satIOContext->interruptContext );
10024 SM_DBG1(("smsatInquiryIntCB: invalid PAGE CODE 0x%x!!!\n", page));
10028 /* checking length */
10031 case INQUIRY_SUPPORTED_VPD_PAGE:
10032 lenNeeded = SATA_PAGE0_INQUIRY_SIZE; /* 36 */
10034 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE:
10035 if (oneDeviceData->satWWNSupport)
10037 lenNeeded = SATA_PAGE83_INQUIRY_WWN_SIZE; /* 16 */
10041 lenNeeded = SATA_PAGE83_INQUIRY_NO_WWN_SIZE; /* 76 */
10044 case INQUIRY_ATA_INFORMATION_VPD_PAGE:
10045 lenNeeded = SATA_PAGE89_INQUIRY_SIZE; /* 572 */
10047 case INQUIRY_UNIT_SERIAL_NUMBER_VPD_PAGE:
10048 lenNeeded = SATA_PAGE80_INQUIRY_SIZE; /* 24 */
10050 case INQUIRY_BLOCK_DEVICE_CHARACTERISTICS_VPD_PAGE:
10051 lenNeeded = SATA_PAGEB1_INQUIRY_SIZE; /* 64 */
10054 SM_DBG1(("smsatInquiryIntCB: wrong!!! invalidinvalid PAGE CODE 0x%x!!!\n", page));
10060 * Fill in the Inquiry data depending on what Inquiry data we are returning.
10064 case INQUIRY_SUPPORTED_VPD_PAGE:
10065 smsatInquiryPage0(pInquiry, pSATAIdData);
10067 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE:
10068 smsatInquiryPage83(pInquiry, pSATAIdData, oneDeviceData);
10070 case INQUIRY_ATA_INFORMATION_VPD_PAGE:
10071 smsatInquiryPage89(pInquiry, pSATAIdData, oneDeviceData, lenReceived);
10073 case INQUIRY_UNIT_SERIAL_NUMBER_VPD_PAGE:
10074 smsatInquiryPage80(pInquiry, pSATAIdData);
10076 case INQUIRY_BLOCK_DEVICE_CHARACTERISTICS_VPD_PAGE:
10077 smsatInquiryPageB1(pInquiry, pSATAIdData);
10080 SM_DBG1(("smsatInquiryIntCB: wrong!!! invalidinvalid PAGE CODE 0x%x!!!\n", page));
10085 SM_DBG6(("smsatInquiryIntCB: calling tdsmIOCompletedCB\n"));
10087 /* if this is a standard Inquiry command, notify Stoport to set the device queue depth to max NCQ */
10088 if ( (oneDeviceData->satNCQ == agTRUE) &&
10089 ((scsiCmnd->cdb[1] & 0x01) == 0))
10091 if (tdsmSetDeviceQueueDepth(smRoot,
10093 oneDeviceData->satNCQMaxIO-1
10096 SM_DBG1(("smsatInquiryIntCB: failed to call tdsmSetDeviceQueueDepth()!!! Q=%d\n", oneDeviceData->satNCQMaxIO));
10100 sm_memcpy(smScsiRequest->sglVirtualAddr, dataBuffer, MIN(allocationLen, lenNeeded));
10101 if (allocationLen > lenNeeded)
10103 SM_DBG6(("smsatInquiryIntCB reporting underrun lenNeeded=0x%x allocationLen=0x%x smIORequest=%p\n",
10104 lenNeeded, allocationLen, smIORequest));
10106 tdsmIOCompletedCB( smRoot,
10109 allocationLen - lenNeeded,
10111 satIOContext->interruptContext );
10115 tdsmIOCompletedCB( smRoot,
10120 satIOContext->interruptContext);
10123 SM_DBG5(("smsatInquiryIntCB: device %p pending IO %d\n", oneDeviceData, oneDeviceData->satPendingIO));
10124 SM_DBG6(("smsatInquiryIntCB: end\n"));
10131 agsaRoot_t *agRoot,
10132 agsaIORequest_t *agIORequest,
10134 agsaFisHeader_t *agFirstDword,
10140 smRoot_t *smRoot = agNULL;
10141 smIntRoot_t *smIntRoot = agNULL;
10142 smIntContext_t *smAllShared = agNULL;
10143 smIORequestBody_t *smIORequestBody;
10144 smIORequestBody_t *smOrgIORequestBody;
10145 smSatIOContext_t *satIOContext;
10146 smSatIOContext_t *satOrgIOContext;
10147 smSatInternalIo_t *satIntIo;
10148 smDeviceData_t *oneDeviceData;
10150 smScsiRspSense_t *pSense;
10151 smIORequest_t *smOrgIORequest;
10153 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
10154 bit32 ataStatus = 0;
10155 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
10157 SM_DBG5(("smsatVerify10CB: start\n"));
10158 SM_DBG5(("smsatVerify10CB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
10160 /* internally generate smIOContext */
10161 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
10162 satIOContext = (smSatIOContext_t *) ioContext;
10163 satIntIo = satIOContext->satIntIoContext;
10164 oneDeviceData = satIOContext->pSatDevData;
10165 hostToDevFis = satIOContext->pFis;
10166 smRoot = oneDeviceData->smRoot;
10167 smIntRoot = (smIntRoot_t *)smRoot->smData;
10168 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
10170 if (satIntIo == agNULL)
10172 SM_DBG4(("smsatVerify10CB: External smSatInternalIo_t satIntIoContext\n"));
10173 satOrgIOContext = satIOContext;
10174 smOrgIORequest = smIORequestBody->smIORequest;
10175 pSense = satIOContext->pSense;
10179 SM_DBG4(("smsatVerify10CB: Internal smSatInternalIo_t satIntIoContext\n"));
10180 satOrgIOContext = satIOContext->satOrgIOContext;
10181 if (satOrgIOContext == agNULL)
10183 SM_DBG4(("smsatVerify10CB: satOrgIOContext is NULL, wrong\n"));
10188 SM_DBG4(("smsatVerify10CB: satOrgIOContext is NOT NULL\n"));
10190 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
10191 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
10192 pSense = satOrgIOContext->pSense;
10195 smIORequestBody->ioCompleted = agTRUE;
10196 smIORequestBody->ioStarted = agFALSE;
10198 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
10200 SM_DBG1(("smsatVerify10CB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
10201 smsatSetSensePayload( pSense,
10202 SCSI_SNSKEY_NO_SENSE,
10204 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
10207 tdsmIOCompletedCB( smRoot,
10208 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
10210 SCSI_STAT_CHECK_CONDITION,
10211 satOrgIOContext->pSmSenseData,
10212 satOrgIOContext->interruptContext );
10214 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
10216 smsatFreeIntIoResource( smRoot,
10222 if (agIOStatus != OSSA_IO_SUCCESS)
10224 /* only agsaFisRegDeviceToHost_t is expected */
10225 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
10226 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
10229 if( agIOStatus != OSSA_IO_SUCCESS)
10231 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) ||
10232 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
10235 /* for debugging */
10236 if( agIOStatus != OSSA_IO_SUCCESS)
10238 SM_DBG1(("smsatVerify10CB: FAILED, NOT IO_SUCCESS!!!\n"));
10240 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
10242 SM_DBG1(("smsatVerify10CB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
10244 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
10245 (ataStatus & DF_ATA_STATUS_MASK)
10248 SM_DBG1(("smsatVerify10CB: FAILED, FAILED, error status!!!\n"));
10251 /* Process abort case */
10252 if (agIOStatus == OSSA_IO_ABORTED)
10254 smsatProcessAbort(smRoot,
10259 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
10261 smsatFreeIntIoResource( smRoot,
10267 /* for debugging */
10268 switch (hostToDevFis->h.command)
10270 case SAT_READ_VERIFY_SECTORS_EXT:
10271 SM_DBG1(("smsatVerify10CB: SAT_READ_VERIFY_SECTORS_EXT!!!\n"));
10274 SM_DBG1(("smsatVerify10CB: error default case command 0x%x!!!\n", hostToDevFis->h.command));
10278 smsatSetSensePayload( pSense,
10279 SCSI_SNSKEY_NO_SENSE,
10281 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
10284 tdsmIOCompletedCB( smRoot,
10285 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
10287 SCSI_STAT_CHECK_CONDITION,
10288 satOrgIOContext->pSmSenseData,
10289 satOrgIOContext->interruptContext );
10291 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
10293 smsatFreeIntIoResource( smRoot,
10297 } /* end error checking */
10300 /* process success from this point on */
10301 switch (hostToDevFis->h.command)
10303 case SAT_READ_VERIFY_SECTORS_EXT:
10304 SM_DBG5(("smsatVerify10CB: SAT_WRITE_DMA_EXT success \n"));
10306 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
10308 smsatFreeIntIoResource( smRoot,
10312 tdsmIOCompletedCB( smRoot,
10317 satOrgIOContext->interruptContext);
10320 SM_DBG1(("smsatVerify10CB: success but error default case command 0x%x!!!\n", hostToDevFis->h.command));
10322 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
10324 smsatFreeIntIoResource( smRoot,
10328 smsatSetSensePayload( pSense,
10329 SCSI_SNSKEY_NO_SENSE,
10331 SCSI_SNSCODE_NO_ADDITIONAL_INFO,
10334 tdsmIOCompletedCB( smRoot,
10335 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */
10337 SCSI_STAT_CHECK_CONDITION,
10338 satOrgIOContext->pSmSenseData,
10339 satOrgIOContext->interruptContext );
10349 agsaRoot_t *agRoot,
10350 agsaIORequest_t *agIORequest,
10352 agsaFisHeader_t *agFirstDword,
10358 smRoot_t *smRoot = agNULL;
10359 smIntRoot_t *smIntRoot = agNULL;
10360 smIntContext_t *smAllShared = agNULL;
10361 smIORequestBody_t *smIORequestBody;
10362 smSatIOContext_t *satReadLogExtIOContext;
10363 smSatIOContext_t *satIOContext;
10364 smSatInternalIo_t *satIntIo;
10365 smDeviceData_t *oneDeviceData;
10366 agsaIORequest_t *agAbortIORequest;
10367 smIORequestBody_t *smAbortIORequestBody;
10370 bit32 memAllocStatus;
10372 smDeviceHandle_t *smDeviceHandle;
10374 SM_DBG5(("smsatReadLogExtCB: start\n"));
10375 SM_DBG1(("smsatReadLogExtCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n",
10376 agIORequest, agIOStatus, agIOInfoLen));
10377 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
10378 satReadLogExtIOContext = (smSatIOContext_t *) ioContext;
10379 satIntIo = satReadLogExtIOContext->satIntIoContext;
10380 oneDeviceData = satReadLogExtIOContext->pSatDevData;
10381 smDeviceHandle = satReadLogExtIOContext->psmDeviceHandle;
10382 smRoot = oneDeviceData->smRoot;
10383 smIntRoot = (smIntRoot_t *)smRoot->smData;
10384 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
10385 SM_DBG1(("smsatReadLogExtCB: did %d!!!\n", oneDeviceData->id));
10386 SM_DBG1(("smsatReadLogExtCB: smIORequestBody ID %d!!!\n", smIORequestBody->id));
10387 SM_DBG1(("smsatReadLogExtCB: smIORequestBody ioCompleted %d ioStarted %d\n", smIORequestBody->ioCompleted, smIORequestBody->ioStarted));
10388 smsatDecrementPendingIO(smRoot, smAllShared, satReadLogExtIOContext);
10390 smIORequestBody->ioCompleted = agTRUE;
10391 smIORequestBody->ioStarted = agFALSE;
10394 * If READ LOG EXT failed, we issue device reset.
10396 if ( agIOStatus != OSSA_IO_SUCCESS ||
10397 (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL && agIOInfoLen != 0)
10400 SM_DBG1(("smsatReadLogExtCB: FAILED.!!!\n"));
10402 smsatFreeIntIoResource( smRoot,
10405 /* Abort I/O after completion of device reset */
10406 oneDeviceData->satAbortAfterReset = agTRUE;
10408 /* needs to investigate this case */
10409 /* no report to OS layer */
10411 satReadLogExtIOContext->ptiDeviceHandle,
10412 TD_INTERNAL_TM_RESET,
10422 /***************************************************************************
10423 * The following steps take place when READ LOG EXT successfully completed.
10424 ***************************************************************************/
10426 /************************************************************************
10428 * 1. Issue abort to LL layer to all other pending I/Os for the same SATA
10431 * 2. Free resource allocated for the internally generated READ LOG EXT.
10433 * 3. At the completion of abort, in the context of ossaSATACompleted(),
10434 * return the I/O with error status to the OS-App Specific layer.
10435 * When all I/O aborts are completed, clear SATA device flag to
10436 * indicate ready to process new request.
10438 ***********************************************************************/
10441 * Issue abort to LL layer to all other pending I/Os for the same SATA drive
10444 replace the single IO abort with device abort
10447 SM_DBG1(("smsatReadLogExtCB: issuing saSATAAbort. Device Abort!!!\n"));
10448 oneDeviceData->SMAbortAll = agTRUE;
10450 smAbortIORequestBody = smDequeueIO(smRoot);
10452 if (smAbortIORequestBody == agNULL)
10454 SM_DBG1(("smsatReadLogExtCB: empty freeIOList!!!\n"));
10458 /* allocating agIORequest for abort itself */
10459 memAllocStatus = tdsmAllocMemory(
10462 (void **)&smAbortIORequestBody,
10466 sizeof(smIORequestBody_t),
10470 if (memAllocStatus != tiSuccess)
10472 /* let os process IO */
10473 SM_DBG1(("smsatReadLogExtCB: ostiAllocMemory failed...\n"));
10477 if (smAbortIORequestBody == agNULL)
10479 /* let os process IO */
10480 SM_DBG1(("smsatReadLogExtCB: ostiAllocMemory returned NULL smAbortIORequestBody\n"));
10483 smIOReInit(smRoot, smAbortIORequestBody);
10484 /* setup task management structure */
10485 smAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
10486 smAbortIORequestBody->smDevHandle = smDeviceHandle;
10487 /* setup task management structure */
10488 // smAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
10489 satIOContext = &(smAbortIORequestBody->transport.SATA.satIOContext);
10490 satIOContext->smRequestBody = smAbortIORequestBody;
10492 /* initialize agIORequest */
10493 agAbortIORequest = &(smAbortIORequestBody->agIORequest);
10494 agAbortIORequest->osData = (void *) smAbortIORequestBody;
10495 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */
10498 * Issue abort (device abort all)
10500 saSATAAbort( agRoot, agAbortIORequest, tdsmRotateQnumber(smRoot, smDeviceHandle), oneDeviceData->agDevHandle, 1, agNULL, smaSATAAbortCB);
10503 * Free resource allocated for the internally generated READ LOG EXT.
10505 smsatFreeIntIoResource( smRoot,
10510 * Sequence of recovery continue at some other context:
10511 * At the completion of abort, in the context of ossaSATACompleted(),
10512 * return the I/O with error status to the OS-App Specific layer.
10513 * When all I/O aborts are completed, clear SATA device flag to
10514 * indicate ready to process new request.
10517 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
10519 SM_DBG1(("smsatReadLogExtCB: end return!!!\n"));
10525 agsaRoot_t *agRoot,
10526 agsaIORequest_t *agIORequest,
10527 agsaPortContext_t *agPortContext,
10528 agsaDevHandle_t *agDevHandle,
10534 smRoot_t *smRoot = gsmRoot;
10535 smIntRoot_t *smIntRoot = (smIntRoot_t *)smRoot->smData;
10536 smIntContext_t *smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
10537 smDeviceHandle_t *smDeviceHandle = agNULL;
10538 smDeviceData_t *oneDeviceData = agNULL;
10539 smList_t *DeviceListList;
10540 bit32 found = agFALSE;
10541 smIORequestBody_t *smIORequestBody = agNULL;
10542 smSatInternalIo_t *satIntIo = agNULL;
10543 smSatIOContext_t *satIOContext2;
10544 smIORequest_t smIORequestTMP;
10547 agsaDifDetails_t agDifDetails;
10548 bit8 framePayload[256];
10549 bit16 frameOffset = 0;
10550 bit16 frameLen = 0;
10553 SM_DBG1(("ossaSATAEvent: start\n"));
10554 if (event == OSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE)
10556 /* agIORequest is invalid, search for smDeviceHandle from smAllShared using agDevHandle */
10557 /* find a device's existence */
10558 DeviceListList = smAllShared->MainDeviceList.flink;
10559 while (DeviceListList != &(smAllShared->MainDeviceList))
10561 oneDeviceData = SMLIST_OBJECT_BASE(smDeviceData_t, MainLink, DeviceListList);
10562 if (oneDeviceData == agNULL)
10564 SM_DBG1(("ossaSATAEvent: oneDeviceData is NULL!!!\n"));
10567 if (oneDeviceData->agDevHandle == agDevHandle)
10569 SM_DBG2(("ossaSATAEvent: did %d\n", oneDeviceData->id));
10573 DeviceListList = DeviceListList->flink;
10575 if (found == agFALSE)
10577 SM_DBG2(("ossaSATAEvent: not found!!!\n"));
10580 if (oneDeviceData->valid == agFALSE)
10582 SM_DBG2(("ossaSATAEvent: oneDeviceData is not valid did %d!!!\n", oneDeviceData->id));
10585 /**************************************************************************
10587 * !!!! See Section 13.5.2.4 of SATA 2.5 specs. !!!!
10588 * !!!! If the NCQ error ends up here, it means that the device sent !!!!
10589 * !!!! Register Device To Host FIS (which does not have SActive !!!!
10590 * !!!! register) instead of Set Device Bit FIS (which has SActive !!!!
10591 * !!!! register). The routine osSatIOCompleted() deals with the case !!!!
10592 * !!!! where Set Device Bit FIS was sent by the device. !!!!
10594 * For NCQ we need to issue READ LOG EXT command with log page 10h
10595 * to get the error and to allow other I/Os to continue.
10597 * Here is the basic flow or sequence of error recovery, this sequence is
10598 * similar to the one described in SATA 2.5:
10600 * 1. Set SATA device flag to indicate error condition and returning busy
10601 * for all new request.
10603 * 2. Prepare READ LOG EXT page 10h command. Set flag to indicate that
10604 * the failed I/O has NOT been returned to the OS Layer. Send command.
10606 * 3. When the device receives READ LOG EXT page 10h request all other
10607 * pending I/O are implicitly aborted. No completion (aborted) status
10608 * will be sent to the host for these aborted commands.
10610 * 4. SATL receives the completion for READ LOG EXT command in
10611 * smsatReadLogExtCB(). Steps 5,6,7,8 below are the step 1,2,3,4 in
10612 * smsatReadLogExtCB().
10614 * 5. Check flag that indicates whether the failed I/O has been returned
10615 * to the OS Layer. If not, search the I/O context in device data
10616 * looking for a matched tag. Then return the completion of the failed
10617 * NCQ command with the appopriate/trasnlated SCSI status.
10619 * 6. Issue abort to LL layer to all other pending I/Os for the same SATA
10622 * 7. Free resource allocated for the internally generated READ LOG EXT.
10624 * 8. At the completion of abort, in the context of ossaSATACompleted(),
10625 * return the I/O with error status to the OS-App Specific layer.
10626 * When all I/O aborts are completed, clear SATA device flag to
10627 * indicate ready to process new request.
10629 *************************************************************************/
10631 smDeviceHandle = oneDeviceData->smDevHandle;
10632 SM_DBG1(("ossaSATAEvent: did %d!!!\n", oneDeviceData->id));
10634 if (oneDeviceData->satDriveState == SAT_DEV_STATE_NORMAL)
10636 SM_DBG1(("ossaSATAEvent: NCQ ERROR did %d!!!\n", oneDeviceData->id ));
10638 /* Set flag to indicate we are in recovery */
10639 oneDeviceData->satDriveState = SAT_DEV_STATE_IN_RECOVERY;
10642 * Allocate resource for READ LOG EXIT page 10h
10644 satIntIo = smsatAllocIntIoResource( smRoot,
10645 &(smIORequestTMP), /* anything but NULL */
10647 sizeof (satReadLogExtPage10h_t),
10651 * If we cannot allocate resource to do the normal NCQ recovery, we
10652 * will do SATA device reset.
10654 if (satIntIo == agNULL)
10656 /* Abort I/O after completion of device reset */
10657 oneDeviceData->satAbortAfterReset = agTRUE;
10658 SM_DBG1(("ossaSATAEvent: can't send RLE due to resource lack!!!\n"));
10661 /* needs to investigate this case */
10662 /* no report to OS layer */
10665 TD_INTERNAL_TM_RESET,
10677 * Clear flag to indicate that the failed I/O has NOT been returned to the
10678 * OS-App specific Layer.
10680 satIntIo->satIntFlag = 0;
10682 /* compare to satPrepareNewIO() */
10683 /* Send READ LOG EXIT page 10h command */
10686 * Need to initialize all the fields within satIOContext except
10687 * reqType and satCompleteCB which will be set depending on cmd.
10690 smIORequestBody = (smIORequestBody_t *)satIntIo->satIntRequestBody;
10691 satIOContext2 = &(smIORequestBody->transport.SATA.satIOContext);
10693 satIOContext2->pSatDevData = oneDeviceData;
10694 satIOContext2->pFis = &(smIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev);
10695 satIOContext2->pScsiCmnd = &(satIntIo->satIntSmScsiXchg.scsiCmnd);
10696 satIOContext2->pSense = &(smIORequestBody->transport.SATA.sensePayload);
10697 satIOContext2->pSmSenseData = &(smIORequestBody->transport.SATA.smSenseData);
10698 satIOContext2->pSmSenseData->senseData = satIOContext2->pSense;
10700 satIOContext2->smRequestBody = satIntIo->satIntRequestBody;
10702 // satIOContext2->interruptContext = interruptContext;
10703 satIOContext2->satIntIoContext = satIntIo;
10705 satIOContext2->psmDeviceHandle = smDeviceHandle;
10706 satIOContext2->satOrgIOContext = agNULL;
10707 satIOContext2->smScsiXchg = agNULL;
10709 SM_DBG1(("ossaSATAEvent: smIORequestBody ID %d!!!\n", smIORequestBody->id));
10710 SM_DBG1(("ossaSATAEvent: smIORequestBody ioCompleted %d ioStarted %d\n", smIORequestBody->ioCompleted, smIORequestBody->ioStarted));
10711 status = smsatSendReadLogExt( smRoot,
10712 &satIntIo->satIntSmIORequest,
10714 &satIntIo->satIntSmScsiXchg,
10717 if (status != SM_RC_SUCCESS)
10719 SM_DBG1(("ossaSATAEvent: can't send RLE due to LL api failure!!!\n"));
10720 smsatFreeIntIoResource( smRoot,
10723 /* Abort I/O after completion of device reset */
10724 oneDeviceData->satAbortAfterReset = agTRUE;
10726 /* needs to investigate this case */
10727 /* no report to OS layer */
10730 TD_INTERNAL_TM_RESET,
10742 SM_DBG1(("ossaSATAEvent: NCQ ERROR but recovery in progress!!!\n"));
10745 else if (event == OSSA_IO_XFER_CMD_FRAME_ISSUED)
10747 SM_DBG1(("ossaSATAEvent: OSSA_IO_XFER_CMD_FRAME_ISSUED\n"));
10749 else if (event == OSSA_IO_XFER_PIO_SETUP_ERROR)
10751 SM_DBG1(("ossaSATAEvent: OSSA_IO_XFER_PIO_SETUP_ERROR\n"));
10753 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED)
10755 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED\n"));
10757 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO)
10759 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO\n"));
10761 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST)
10763 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST\n"));
10765 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE)
10767 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE\n"));
10769 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED)
10771 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED\n"));
10773 else if (event == OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH)
10775 SM_DBG1(("ossaSATAEvent: OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH\n"));
10778 else if (event == OSSA_IO_XFR_ERROR_DIF_MISMATCH || event == OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH ||
10779 event == OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH || event == OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH )
10781 SM_DBG1(("ossaSATAEvent: DIF related, event 0x%x\n", event));
10782 /* process DIF detail information */
10783 SM_DBG2(("ossaSATAEvent: agIOInfoLen %d\n", agIOInfoLen));
10784 if (agParam == agNULL)
10786 SM_DBG2(("ossaSATAEvent: agParam is NULL!!!\n"));
10789 if (agIOInfoLen < sizeof(agsaDifDetails_t))
10791 SM_DBG2(("ossaSATAEvent: wrong agIOInfoLen!!! agIOInfoLen %d sizeof(agsaDifDetails_t) %d\n", agIOInfoLen, (int)sizeof(agsaDifDetails_t)));
10794 /* reads agsaDifDetails_t */
10795 saFrameReadBlock(agRoot, agParam, 0, &agDifDetails, sizeof(agsaDifDetails_t));
10796 frameOffset = (agDifDetails.ErrBoffsetEDataLen & 0xFFFF);
10797 frameLen = (agDifDetails.ErrBoffsetEDataLen & 0xFFFF0000) >> 16;
10799 SM_DBG2(("ossaSATAEvent: UpperLBA 0x%08x LowerLBA 0x%08x\n", agDifDetails.UpperLBA, agDifDetails.LowerLBA));
10800 SM_DBG2(("ossaSATAEvent: SASAddrHI 0x%08x SASAddrLO 0x%08x\n",
10801 SM_GET_SAS_ADDRESSHI(agDifDetails.sasAddressHi), SM_GET_SAS_ADDRESSLO(agDifDetails.sasAddressLo)));
10802 SM_DBG2(("ossaSATAEvent: DIF error mask 0x%x Device ID 0x%x\n",
10803 (agDifDetails.DIFErrDevID) & 0xFF, (agDifDetails.DIFErrDevID & 0xFFFF0000) >> 16));
10804 if (frameLen != 0 && frameLen <= 256)
10806 saFrameReadBlock(agRoot, agParam, sizeof(agsaDifDetails_t), framePayload, frameLen);
10807 smhexdump("ossaSATAEvent frame", framePayload, frameLen);
10811 else if (event == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY)
10813 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
10814 if (smIORequestBody == agNULL)
10816 SM_DBG1(("ossaSATAEvent: smIORequestBody is NULL!!!\n"));
10819 smDeviceHandle = smIORequestBody->smDevHandle;
10820 if (smDeviceHandle == agNULL)
10822 SM_DBG1(("ossaSATAEvent: smDeviceHandle is NULL!!!\n"));
10825 oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData;
10826 if (oneDeviceData == agNULL)
10828 SM_DBG1(("ossaSATAEvent: oneDeviceData is NULL!!!\n"));
10831 SM_DBG1(("ossaSATAEvent: ERROR event %d did=%d\n", event, oneDeviceData->id));
10834 if (smAllShared->FCA)
10836 if (oneDeviceData->SMNumOfFCA <= 0) /* does SMP HARD RESET only upto one time */
10838 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; sending HARD_RESET\n"));
10839 oneDeviceData->SMNumOfFCA++;
10840 smPhyControlSend(smRoot,
10842 SMP_PHY_CONTROL_HARD_RESET,
10844 tdsmRotateQnumber(smRoot, smDeviceHandle)
10849 /* given up after one time of SMP HARD RESET; */
10850 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; but giving up sending HARD_RESET!!!\n"));
10854 else if (event == OSSA_IO_XFER_ERROR_NAK_RECEIVED)
10856 SM_DBG1(("ossaSATAEvent: OSSA_IO_XFER_ERROR_NAK_RECEIVED\n"));
10858 else if (event == OSSA_IO_XFER_ERROR_DMA_ACTIVATE_TIMEOUT)
10860 SM_DBG1(("ossaSATAEvent: OSSA_IO_XFER_ERROR_DMA_ACTIVATE_TIMEOUT\n"));
10864 SM_DBG1(("ossaSATAEvent: other event 0x%x\n", event));
10872 agsaRoot_t *agRoot,
10873 agsaIORequest_t *agIORequest,
10876 agsaFrameHandle_t agFrameHandle
10879 smSMPRequestBody_t *smSMPRequestBody = (smSMPRequestBody_t *) agIORequest->osData;
10881 SM_DBG2(("smSMPCompletedCB: start\n"));
10883 if (smSMPRequestBody == agNULL)
10885 SM_DBG1(("smSMPCompletedCB: smSMPRequestBody is NULL!!!\n"));
10889 if (smSMPRequestBody->SMPCompletionFunc == agNULL)
10891 SM_DBG1(("smSMPCompletedCB: smSMPRequestBody->SMPCompletionFunc is NULL!!!\n"));
10895 /* calling smSMPCompleted */
10896 smSMPRequestBody->SMPCompletionFunc(
10908 agsaRoot_t *agRoot,
10909 agsaIORequest_t *agIORequest,
10912 agsaFrameHandle_t agFrameHandle
10915 smRoot_t *smRoot = gsmRoot;
10916 smSMPRequestBody_t *smSMPRequestBody = (smSMPRequestBody_t *) agIORequest->osData;
10917 smDeviceData_t *oneDeviceData;
10918 smDeviceHandle_t *smDeviceHandle;
10919 smIORequest_t *CurrentTaskTag;
10921 smSMPFrameHeader_t *smSMPFrameHeader;
10922 agsaDevHandle_t *agDevHandle = agNULL;
10924 SM_DBG2(("smSMPCompleted: start\n"));
10926 if (smSMPRequestBody == agNULL)
10928 SM_DBG1(("smSMPCompleted: smSMPRequestBody is NULL, wrong!!!\n"));
10932 CurrentTaskTag = smSMPRequestBody->CurrentTaskTag;
10933 oneDeviceData = smSMPRequestBody->smDeviceData;
10934 smDeviceHandle = smSMPRequestBody->smDevHandle;
10935 if (smDeviceHandle == agNULL)
10937 SM_DBG2(("smSMPCompleted: smDeviceHandle is NULL, wrong!!!\n"));
10941 if (oneDeviceData == agNULL)
10943 SM_DBG2(("smSMPCompleted: oneDeviceData is NULL, wrong!!!\n"));
10946 agDevHandle = oneDeviceData->agExpDevHandle;
10947 if (agIOStatus == OSSA_IO_SUCCESS)
10949 saFrameReadBlock(agRoot, agFrameHandle, 0, smpHeader, 4);
10950 smSMPFrameHeader = (smSMPFrameHeader_t *)smpHeader;
10951 if (smSMPFrameHeader->smpFunction == SMP_PHY_CONTROL)
10953 SM_DBG3(("smSMPCompleted: phy control\n"));
10954 if (agIOInfoLen != 4 &&
10955 smSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED) /*zero length is expected */
10957 SM_DBG1(("smSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x!!!\n", agIOInfoLen, 4));
10960 smSMPRequestBody->osMemHandle,
10961 sizeof(smSMPRequestBody_t)
10963 if (CurrentTaskTag != agNULL)
10965 tdsmEventCB(smRoot,
10967 smIntrEventTypeTaskManagement,
10974 smPhyControlRespRcvd(smRoot,
10985 /* unknown SMP function */
10986 SM_DBG2(("smSMPCompleted: unknown smSMPFrameHeader %d!!!\n", smSMPFrameHeader->smpFunction));
10989 smSMPRequestBody->osMemHandle,
10990 sizeof(smSMPRequestBody_t)
10992 if (CurrentTaskTag != agNULL)
10994 tdsmEventCB(smRoot,
10996 smIntrEventTypeTaskManagement,
11005 SM_DBG2(("smSMPCompleted: failed agIOStatus %d!!!\n", agIOStatus));
11006 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS ||
11007 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED ||
11008 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO ||
11009 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST ||
11010 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE ||
11011 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED ||
11012 agIOStatus == OSSA_IO_DS_NON_OPERATIONAL
11015 SM_DBG1(("smSMPCompleted: setting back to operational\n"));
11016 if (agDevHandle != agNULL)
11018 saSetDeviceState(agRoot, agNULL, tdsmRotateQnumber(smRoot, smDeviceHandle), agDevHandle, SA_DS_OPERATIONAL);
11022 SM_DBG1(("smSMPCompleted: agDevHandle is NULL\n"));
11027 smSMPRequestBody->osMemHandle,
11028 sizeof(smSMPRequestBody_t)
11030 if (CurrentTaskTag != agNULL)
11032 tdsmEventCB(smRoot,
11034 smIntrEventTypeTaskManagement,
11043 smSMPRequestBody->osMemHandle,
11044 sizeof(smSMPRequestBody_t)
11050 smPhyControlRespRcvd(
11052 agsaRoot_t *agRoot,
11053 agsaIORequest_t *agIORequest,
11054 smDeviceData_t *oneDeviceData, /* sata disk */
11055 smSMPFrameHeader_t *frameHeader,
11056 agsaFrameHandle_t frameHandle,
11057 smIORequest_t *CurrentTaskTag
11060 smDeviceData_t *TargetDeviceData = agNULL;
11061 agsaDevHandle_t *agDevHandle = agNULL;
11062 smSMPRequestBody_t *smSMPRequestBody;
11063 smDeviceHandle_t *smDeviceHandle;
11065 SM_DBG2(("smPhyControlRespRcvd: start\n"));
11067 if (CurrentTaskTag == agNULL )
11069 SM_DBG1(("smPhyControlRespRcvd: CurrentTaskTag is NULL; allowed\n"));
11073 smSMPRequestBody = (smSMPRequestBody_t *)CurrentTaskTag->smData;
11074 if (smSMPRequestBody == agNULL)
11076 SM_DBG1(("smPhyControlRespRcvd: smSMPRequestBody is NULL!!!\n"));
11080 smDeviceHandle = smSMPRequestBody->smDevHandle;
11081 if (smDeviceHandle == agNULL)
11083 SM_DBG2(("smPhyControlRespRcvd: smDeviceHandle is NULL!!!\n"));
11087 TargetDeviceData = smSMPRequestBody->smDeviceData;
11088 if (oneDeviceData != TargetDeviceData)
11090 SM_DBG1(("smPhyControlRespRcvd: oneDeviceData != TargetDeviceData!!!\n"));
11094 agDevHandle = TargetDeviceData->agDevHandle;
11097 if (frameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED)
11099 SM_DBG2(("smPhyControlRespRcvd: SMP success\n"));
11100 SM_DBG1(("smPhyControlRespRcvd: callback to TD layer with success\n"));
11101 TargetDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
11102 saSetDeviceState(agRoot, agNULL, tdsmRotateQnumber(smRoot, smDeviceHandle), agDevHandle, SA_DS_OPERATIONAL);
11104 tdsmEventCB(smRoot,
11106 smIntrEventTypeTaskManagement,
11112 SM_DBG1(("smPhyControlRespRcvd: SMP failure; result %d!!!\n", frameHeader->smpFunctionResult));
11113 tdsmEventCB(smRoot,
11115 smIntrEventTypeTaskManagement,
11123 smsatCheckPowerModeCB(
11124 agsaRoot_t *agRoot,
11125 agsaIORequest_t *agIORequest,
11127 agsaFisHeader_t *agFirstDword,
11129 agsaFrameHandle_t agFrameHandle,
11133 /* callback for satDeResetDevice */
11134 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
11135 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
11136 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
11137 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
11138 smRoot_t *smRoot = agNULL;
11139 smIntRoot_t *smIntRoot = agNULL;
11140 smIntContext_t *smAllShared = agNULL;
11141 smIORequestBody_t *smIORequestBody;
11142 smSatIOContext_t *satIOContext;
11143 smSatIOContext_t *satOrgIOContext;
11144 smSatInternalIo_t *satIntIo;
11145 // satDeviceData_t *satDevData;
11146 smDeviceData_t *oneDeviceData;
11147 #ifdef TD_DEBUG_ENABLE
11148 bit32 ataStatus = 0;
11150 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL;
11152 bit32 AbortTM = agFALSE;
11153 smDeviceHandle_t *smDeviceHandle;
11155 SM_DBG1(("smsatCheckPowerModeCB: start\n"));
11156 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
11157 satIOContext = (smSatIOContext_t *) ioContext;
11158 satIntIo = satIOContext->satIntIoContext;
11159 oneDeviceData = satIOContext->pSatDevData;
11160 smRoot = oneDeviceData->smRoot;
11161 smIntRoot = (smIntRoot_t *)smRoot->smData;
11162 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
11163 smDeviceHandle = oneDeviceData->smDevHandle;
11164 if (satIntIo == agNULL)
11166 SM_DBG6(("smsatCheckPowerModeCB: External, OS generated\n"));
11167 satOrgIOContext = satIOContext;
11171 SM_DBG6(("smsatCheckPowerModeCB: Internal, TD generated\n"));
11172 satOrgIOContext = satIOContext->satOrgIOContext;
11173 if (satOrgIOContext == agNULL)
11175 SM_DBG6(("smsatCheckPowerModeCB: satOrgIOContext is NULL, wrong\n"));
11180 SM_DBG6(("smsatCheckPowerModeCB: satOrgIOContext is NOT NULL\n"));
11183 smIORequestBody->ioCompleted = agTRUE;
11184 smIORequestBody->ioStarted = agFALSE;
11185 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
11187 SM_DBG1(("smsatCheckPowerModeCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
11189 tdsmEventCB( smRoot,
11191 smIntrEventTypeTaskManagement,
11193 oneDeviceData->satTmTaskTag);
11195 oneDeviceData->satTmTaskTag = agNULL;
11196 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11198 smsatFreeIntIoResource( smRoot,
11204 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED ||
11205 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION ||
11206 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK ||
11207 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS ||
11208 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION ||
11209 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED ||
11210 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION ||
11211 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR ||
11212 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY
11215 SM_DBG1(("smsatCheckPowerModeCB: OSSA_IO_OPEN_CNX_ERROR!!!\n"));
11217 tdsmEventCB( smRoot,
11219 smIntrEventTypeTaskManagement,
11221 oneDeviceData->satTmTaskTag);
11222 oneDeviceData->satTmTaskTag = agNULL;
11224 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11225 smsatFreeIntIoResource( smRoot,
11230 if (agIOStatus != OSSA_IO_SUCCESS)
11232 /* only agsaFisPioSetup_t is expected */
11233 #ifdef TD_DEBUG_ENABLE
11234 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup);
11235 ataStatus = satPIOSetupHeader->status; /* ATA Status register */
11236 ataError = satPIOSetupHeader->error; /* ATA Eror register */
11238 SM_DBG1(("smsatCheckPowerModeCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError));
11240 tdsmEventCB( smRoot,
11242 smIntrEventTypeTaskManagement,
11244 oneDeviceData->satTmTaskTag);
11245 oneDeviceData->satTmTaskTag = agNULL;
11246 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11247 smsatFreeIntIoResource( smRoot,
11253 SM_DBG1(("smsatCheckPowerModeCB: success!!!\n"));
11254 SM_DBG1(("smsatCheckPowerModeCB: TMF %d!!!\n", satOrgIOContext->TMF));
11256 if (satOrgIOContext->TMF == AG_ABORT_TASK)
11260 if (AbortTM == agTRUE)
11262 SM_DBG1(("smsatCheckPowerModeCB: calling local satAbort!!!\n"));
11263 smsatAbort(smRoot, agRoot, satOrgIOContext->satToBeAbortedIOContext);
11265 oneDeviceData->satTmTaskTag = agNULL;
11266 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
11268 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11270 SM_DBG1(("smsatCheckPowerModeCB: satPendingIO %d satNCQMaxIO %d!!!\n", oneDeviceData->satPendingIO, oneDeviceData->satNCQMaxIO ));
11271 SM_DBG1(("smsatCheckPowerModeCB: satPendingNCQIO %d satPendingNONNCQIO %d!!!\n", oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
11272 smsatFreeIntIoResource( smRoot,
11277 tdsmEventCB( smRoot,
11279 smIntrEventTypeTaskManagement,
11281 oneDeviceData->satTmTaskTag);
11282 SM_DBG5(("smsatCheckPowerModeCB: device %p pending IO %d\n", oneDeviceData, oneDeviceData->satPendingIO));
11283 SM_DBG2(("smsatCheckPowerModeCB: end\n"));
11288 smsatCheckPowerModePassCB(
11289 agsaRoot_t *agRoot,
11290 agsaIORequest_t *agIORequest,
11292 agsaFisHeader_t *agFirstDword,
11294 agsaFrameHandle_t agFrameHandle,
11300 smRoot_t *smRoot = agNULL;
11301 smIntRoot_t *smIntRoot = agNULL;
11302 smIntContext_t *smAllShared = agNULL;
11303 smIORequestBody_t *smIORequestBody;
11304 smSatIOContext_t *satIOContext;
11305 smSatIOContext_t *satOrgIOContext;
11306 smSatInternalIo_t *satIntIo;
11307 smIORequest_t *smOrgIORequest;
11308 smIORequestBody_t *smOrgIORequestBody;
11309 // satDeviceData_t *satDevData;
11310 smDeviceData_t *oneDeviceData;
11311 #ifdef TD_DEBUG_ENABLE
11312 bit32 ataStatus = 0;
11314 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL;
11317 smScsiRspSense_t *pSense;
11318 bit8 bSenseKey = 0;
11319 bit16 bSenseCodeInfo = 0;
11321 SM_DBG1(("smsatCheckPowerModePassCB: start\n"));
11322 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
11323 satIOContext = (smSatIOContext_t *) ioContext;
11324 satIntIo = satIOContext->satIntIoContext;
11325 oneDeviceData = satIOContext->pSatDevData;
11326 smRoot = oneDeviceData->smRoot;
11327 smIntRoot = (smIntRoot_t *)smRoot->smData;
11328 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
11330 if (satIntIo == agNULL)
11332 SM_DBG6(("smsatCheckPowerModePassCB: External, OS generated\n"));
11333 satOrgIOContext = satIOContext;
11334 smOrgIORequest = smIORequestBody->smIORequest;
11335 pSense = satOrgIOContext->pSense;
11339 SM_DBG6(("smsatCheckPowerModePassCB: Internal, TD generated\n"));
11340 satOrgIOContext = satIOContext->satOrgIOContext;
11341 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
11342 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
11343 pSense = satOrgIOContext->pSense;
11344 if (satOrgIOContext == agNULL)
11346 SM_DBG6(("smsatCheckPowerModePassCB: satOrgIOContext is NULL, wrong\n"));
11351 SM_DBG6(("smsatCheckPowerModePassCB: satOrgIOContext is NOT NULL\n"));
11354 smIORequestBody->ioCompleted = agTRUE;
11355 smIORequestBody->ioStarted = agFALSE;
11356 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
11358 SM_DBG1(("smsatCheckPowerModePassCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
11364 smDetailOtherError,
11366 satOrgIOContext->interruptContext
11368 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11370 smsatFreeIntIoResource( smRoot,
11377 if (agIOStatus != OSSA_IO_SUCCESS)
11379 /* only agsaFisPioSetup_t is expected */
11380 #ifdef TD_DEBUG_ENABLE
11381 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup);
11382 ataStatus = satPIOSetupHeader->status; /* ATA Status register */
11383 ataError = satPIOSetupHeader->error; /* ATA Eror register */
11385 SM_DBG1(("smsatCheckPowerModePassCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError));
11388 if (agIOStatus == OSSA_IO_ABORTED)
11390 smsatProcessAbort(smRoot,
11395 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11397 smsatFreeIntIoResource( smRoot,
11402 smsatTranslateATAErrorsToSCSIErrors(
11403 agFirstDword->D2H.status,
11404 agFirstDword->D2H.error,
11408 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext);
11409 tdsmIOCompletedCB(smRoot,
11412 SCSI_STAT_CHECK_CONDITION,
11413 satOrgIOContext->pSmSenseData,
11414 satOrgIOContext->interruptContext );
11417 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11419 smsatFreeIntIoResource( smRoot,
11426 SM_DBG1(("smsatCheckPowerModePassCB: success!!!\n"));
11428 tdsmIOCompletedCB( smRoot,
11433 satOrgIOContext->interruptContext);
11436 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11438 smsatFreeIntIoResource( smRoot,
11448 agsaRoot_t *agRoot,
11449 agsaIORequest_t *agIORequest,
11451 agsaFisHeader_t *agFirstDword,
11453 agsaFrameHandle_t agFrameHandle,
11457 smRoot_t *smRoot = agNULL;
11458 smIntRoot_t *smIntRoot = agNULL;
11459 smIntContext_t *smAllShared = agNULL;
11460 smIORequestBody_t *smIORequestBody;
11461 smSatIOContext_t *satIOContext;
11462 smSatIOContext_t *satOrgIOContext;
11463 smSatInternalIo_t *satIntIo;
11464 smIORequest_t *smOrgIORequest;
11465 smIORequestBody_t *smOrgIORequestBody;
11466 // satDeviceData_t *satDevData;
11467 smDeviceData_t *oneDeviceData;
11468 #ifdef TD_DEBUG_ENABLE
11469 bit32 ataStatus = 0;
11471 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL;
11474 smScsiRspSense_t *pSense;
11475 bit8 bSenseKey = 0;
11476 bit16 bSenseCodeInfo = 0;
11478 SM_DBG3(("smsatIDDataPassCB: start\n"));
11479 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
11480 satIOContext = (smSatIOContext_t *) ioContext;
11481 satIntIo = satIOContext->satIntIoContext;
11482 oneDeviceData = satIOContext->pSatDevData;
11483 smRoot = oneDeviceData->smRoot;
11484 smIntRoot = (smIntRoot_t *)smRoot->smData;
11485 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
11487 if (satIntIo == agNULL)
11489 SM_DBG6(("smsatIDDataPassCB: External, OS generated\n"));
11490 satOrgIOContext = satIOContext;
11491 smOrgIORequest = smIORequestBody->smIORequest;
11492 pSense = satOrgIOContext->pSense;
11496 SM_DBG6(("smsatIDDataPassCB: Internal, TD generated\n"));
11497 satOrgIOContext = satIOContext->satOrgIOContext;
11498 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
11499 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
11500 pSense = satOrgIOContext->pSense;
11501 if (satOrgIOContext == agNULL)
11503 SM_DBG6(("smsatIDDataPassCB: satOrgIOContext is NULL, wrong\n"));
11508 SM_DBG6(("smsatIDDataPassCB: satOrgIOContext is NOT NULL\n"));
11511 smIORequestBody->ioCompleted = agTRUE;
11512 smIORequestBody->ioStarted = agFALSE;
11513 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
11515 SM_DBG1(("smsatIDDataPassCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
11521 smDetailOtherError,
11523 satOrgIOContext->interruptContext
11525 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11527 smsatFreeIntIoResource( smRoot,
11534 if (agIOStatus != OSSA_IO_SUCCESS)
11536 /* only agsaFisPioSetup_t is expected */
11537 #ifdef TD_DEBUG_ENABLE
11538 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup);
11539 ataStatus = satPIOSetupHeader->status; /* ATA Status register */
11540 ataError = satPIOSetupHeader->error; /* ATA Eror register */
11542 SM_DBG1(("smsatIDDataPassCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError));
11545 if (agIOStatus == OSSA_IO_ABORTED)
11547 smsatProcessAbort(smRoot,
11552 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11554 smsatFreeIntIoResource( smRoot,
11559 smsatTranslateATAErrorsToSCSIErrors(
11560 agFirstDword->D2H.status,
11561 agFirstDword->D2H.error,
11565 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext);
11566 tdsmIOCompletedCB(smRoot,
11569 SCSI_STAT_CHECK_CONDITION,
11570 satOrgIOContext->pSmSenseData,
11571 satOrgIOContext->interruptContext );
11574 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11576 smsatFreeIntIoResource( smRoot,
11583 SM_DBG3(("smsatIDDataPassCB: success!!!\n"));
11585 SM_DBG3(("smsatIDDataPassCB: extend 0x%x ck_cond 0x%x sectorCnt07 0x%x\n", satOrgIOContext->extend,
11586 satIOContext->ck_cond, satOrgIOContext->sectorCnt07));
11587 SM_DBG3(("smsatIDDataPassCB: LBAHigh07 0x%x LBAMid07 0x%x LBALow07 0x%x\n", satOrgIOContext->LBAHigh07,
11588 satOrgIOContext->LBAMid07, satOrgIOContext->LBALow07));
11590 if (satIOContext->ck_cond)
11592 smsatSetSensePayload( pSense,
11593 SCSI_SNSKEY_RECOVERED_ERROR,
11594 satOrgIOContext->sectorCnt07,
11595 SCSI_SNSCODE_ATA_PASS_THROUGH_INFORMATION_AVAILABLE,
11598 tdsmIOCompletedCB( smRoot,
11601 SCSI_STAT_CHECK_CONDITION,
11602 satIOContext->pSmSenseData,
11603 satOrgIOContext->interruptContext );
11607 tdsmIOCompletedCB( smRoot,
11612 satOrgIOContext->interruptContext);
11615 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11617 smsatFreeIntIoResource( smRoot,
11626 smsatResetDeviceCB(
11627 agsaRoot_t *agRoot,
11628 agsaIORequest_t *agIORequest,
11630 agsaFisHeader_t *agFirstDword,
11632 agsaFrameHandle_t agFrameHandle,
11636 /* callback for satResetDevice */
11637 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
11638 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
11639 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
11640 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
11641 smRoot_t *smRoot = agNULL;
11642 smIntRoot_t *smIntRoot = agNULL;
11643 smIntContext_t *smAllShared = agNULL;
11644 smIORequestBody_t *smIORequestBody;
11645 smIORequestBody_t *smOrgIORequestBody;
11646 smSatIOContext_t *satIOContext;
11647 smSatIOContext_t *satOrgIOContext;
11648 smSatIOContext_t *satNewIOContext;
11649 smSatInternalIo_t *satIntIo;
11650 smSatInternalIo_t *satNewIntIo = agNULL;
11651 // satDeviceData_t *satDevData;
11652 smDeviceData_t *oneDeviceData;
11653 smIORequest_t *smOrgIORequest;
11654 #ifdef TD_DEBUG_ENABLE
11655 bit32 ataStatus = 0;
11657 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL;
11660 smDeviceHandle_t *smDeviceHandle;
11662 SM_DBG1(("smsatResetDeviceCB: start\n"));
11663 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
11664 satIOContext = (smSatIOContext_t *) ioContext;
11665 satIntIo = satIOContext->satIntIoContext;
11666 oneDeviceData = satIOContext->pSatDevData;
11667 smRoot = oneDeviceData->smRoot;
11668 smIntRoot = (smIntRoot_t *)smRoot->smData;
11669 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
11670 smDeviceHandle = oneDeviceData->smDevHandle;
11672 if (satIntIo == agNULL)
11674 SM_DBG6(("smsatResetDeviceCB: External, OS generated\n"));
11675 satOrgIOContext = satIOContext;
11676 smOrgIORequest = smIORequestBody->smIORequest;
11680 SM_DBG6(("smsatResetDeviceCB: Internal, TD generated\n"));
11681 satOrgIOContext = satIOContext->satOrgIOContext;
11682 if (satOrgIOContext == agNULL)
11684 SM_DBG6(("smsatResetDeviceCB: satOrgIOContext is NULL, wrong\n"));
11689 SM_DBG6(("smsatResetDeviceCB: satOrgIOContext is NOT NULL\n"));
11691 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
11692 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
11694 smIORequestBody->ioCompleted = agTRUE;
11695 smIORequestBody->ioStarted = agFALSE;
11696 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
11698 SM_DBG1(("smsatResetDeviceCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
11700 tdsmEventCB( smRoot,
11702 smIntrEventTypeTaskManagement,
11704 oneDeviceData->satTmTaskTag);
11705 oneDeviceData->satTmTaskTag = agNULL;
11706 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11707 smsatFreeIntIoResource( smRoot,
11712 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED ||
11713 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION ||
11714 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK ||
11715 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS ||
11716 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION ||
11717 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED ||
11718 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION ||
11719 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR ||
11720 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY
11723 SM_DBG1(("smsatResetDeviceCB: OSSA_IO_OPEN_CNX_ERROR!!!\n"));
11725 tdsmEventCB( smRoot,
11727 smIntrEventTypeTaskManagement,
11729 oneDeviceData->satTmTaskTag);
11731 oneDeviceData->satTmTaskTag = agNULL;
11732 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11733 smsatFreeIntIoResource( smRoot,
11738 if (agIOStatus != OSSA_IO_SUCCESS)
11740 /* only agsaFisPioSetup_t is expected */
11741 #ifdef TD_DEBUG_ENABLE
11742 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup);
11743 ataStatus = satPIOSetupHeader->status; /* ATA Status register */
11744 ataError = satPIOSetupHeader->error; /* ATA Eror register */
11746 SM_DBG1(("smsatResetDeviceCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError));
11748 tdsmEventCB( smRoot,
11750 smIntrEventTypeTaskManagement,
11752 oneDeviceData->satTmTaskTag);
11754 oneDeviceData->satTmTaskTag = agNULL;
11755 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11756 smsatFreeIntIoResource( smRoot,
11763 satNewIntIo = smsatAllocIntIoResource( smRoot,
11768 if (satNewIntIo == agNULL)
11770 oneDeviceData->satTmTaskTag = agNULL;
11772 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11773 /* memory allocation failure */
11774 smsatFreeIntIoResource( smRoot,
11778 tdsmEventCB( smRoot,
11780 smIntrEventTypeTaskManagement,
11782 oneDeviceData->satTmTaskTag);
11783 SM_DBG1(("smsatResetDeviceCB: momory allocation fails!!!\n"));
11785 } /* end of memory allocation failure */
11787 * Need to initialize all the fields within satIOContext
11789 satNewIOContext = smsatPrepareNewIO(
11796 /* send AGSA_SATA_PROTOCOL_SRST_DEASSERT */
11797 status = smsatDeResetDevice(smRoot,
11799 satOrgIOContext->psmDeviceHandle,
11803 if (status != SM_RC_SUCCESS)
11806 tdsmEventCB( smRoot,
11808 smIntrEventTypeTaskManagement,
11810 oneDeviceData->satTmTaskTag);
11811 /* sending AGSA_SATA_PROTOCOL_SRST_DEASSERT fails */
11812 oneDeviceData->satTmTaskTag = agNULL;
11814 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11815 smsatFreeIntIoResource( smRoot,
11819 smsatFreeIntIoResource( smRoot,
11824 // oneDeviceData->satTmTaskTag = agNULL;
11826 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11828 smsatFreeIntIoResource( smRoot,
11831 SM_DBG5(("smsatResetDeviceCB: device %p pending IO %d\n", oneDeviceData, oneDeviceData->satPendingIO));
11832 SM_DBG6(("smsatResetDeviceCB: end\n"));
11837 smsatDeResetDeviceCB(
11838 agsaRoot_t *agRoot,
11839 agsaIORequest_t *agIORequest,
11841 agsaFisHeader_t *agFirstDword,
11843 agsaFrameHandle_t agFrameHandle,
11847 /* callback for satDeResetDevice */
11848 // tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
11849 // tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
11850 // tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
11851 // tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
11852 smRoot_t *smRoot = agNULL;
11853 smIntRoot_t *smIntRoot = agNULL;
11854 smIntContext_t *smAllShared = agNULL;
11855 smIORequestBody_t *smIORequestBody;
11856 smSatIOContext_t *satIOContext;
11857 smSatIOContext_t *satOrgIOContext;
11858 smSatInternalIo_t *satIntIo;
11859 // satDeviceData_t *satDevData;
11860 smDeviceData_t *oneDeviceData;
11861 #ifdef TD_DEBUG_ENABLE
11862 bit32 ataStatus = 0;
11864 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL;
11866 bit32 AbortTM = agFALSE;
11867 smDeviceHandle_t *smDeviceHandle;
11869 SM_DBG1(("smsatDeResetDeviceCB: start!!!\n"));
11870 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
11871 satIOContext = (smSatIOContext_t *) ioContext;
11872 satIntIo = satIOContext->satIntIoContext;
11873 oneDeviceData = satIOContext->pSatDevData;
11874 smRoot = oneDeviceData->smRoot;
11875 smIntRoot = (smIntRoot_t *)smRoot->smData;
11876 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
11877 smDeviceHandle = oneDeviceData->smDevHandle;
11878 if (satIntIo == agNULL)
11880 SM_DBG6(("smsatDeResetDeviceCB: External, OS generated\n"));
11881 satOrgIOContext = satIOContext;
11885 SM_DBG6(("smsatDeResetDeviceCB: Internal, TD generated\n"));
11886 satOrgIOContext = satIOContext->satOrgIOContext;
11887 if (satOrgIOContext == agNULL)
11889 SM_DBG6(("smsatDeResetDeviceCB: satOrgIOContext is NULL, wrong\n"));
11894 SM_DBG6(("smsatDeResetDeviceCB: satOrgIOContext is NOT NULL\n"));
11897 smIORequestBody->ioCompleted = agTRUE;
11898 smIORequestBody->ioStarted = agFALSE;
11899 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
11901 SM_DBG1(("smsatDeResetDeviceCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
11903 tdsmEventCB( smRoot,
11905 smIntrEventTypeTaskManagement,
11907 oneDeviceData->satTmTaskTag);
11908 oneDeviceData->satTmTaskTag = agNULL;
11909 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11910 smsatFreeIntIoResource( smRoot,
11916 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED ||
11917 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION ||
11918 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK ||
11919 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS ||
11920 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION ||
11921 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED ||
11922 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION ||
11923 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR ||
11924 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY
11927 SM_DBG1(("smsatDeResetDeviceCB: OSSA_IO_OPEN_CNX_ERROR!!!\n"));
11930 tdsmEventCB( smRoot,
11932 smIntrEventTypeTaskManagement,
11934 oneDeviceData->satTmTaskTag);
11935 oneDeviceData->satTmTaskTag = agNULL;
11936 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11937 smsatFreeIntIoResource( smRoot,
11942 if (agIOStatus != OSSA_IO_SUCCESS)
11944 /* only agsaFisPioSetup_t is expected */
11945 #ifdef TD_DEBUG_ENABLE
11946 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup);
11947 ataStatus = satPIOSetupHeader->status; /* ATA Status register */
11948 ataError = satPIOSetupHeader->error; /* ATA Eror register */
11950 SM_DBG1(("smsatDeResetDeviceCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError));
11952 tdsmEventCB( smRoot,
11954 smIntrEventTypeTaskManagement,
11956 oneDeviceData->satTmTaskTag);
11957 oneDeviceData->satTmTaskTag = agNULL;
11958 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11959 smsatFreeIntIoResource( smRoot,
11966 SM_DBG1(("smsatDeResetDeviceCB: success !!!\n"));
11967 SM_DBG1(("smsatDeResetDeviceCB: TMF %d!!!\n", satOrgIOContext->TMF));
11969 if (satOrgIOContext->TMF == AG_ABORT_TASK)
11973 if (AbortTM == agTRUE)
11975 SM_DBG1(("smsatDeResetDeviceCB: calling satAbort!!!\n"));
11976 smsatAbort(smRoot, agRoot, satOrgIOContext->satToBeAbortedIOContext);
11978 oneDeviceData->satTmTaskTag = agNULL;
11979 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
11980 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
11982 SM_DBG1(("smsatDeResetDeviceCB: satPendingIO %d satNCQMaxIO %d!!!\n", oneDeviceData->satPendingIO, oneDeviceData->satNCQMaxIO ));
11983 SM_DBG1(("smsatDeResetDeviceCB: satPendingNCQIO %d satPendingNONNCQIO %d!!!\n", oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
11984 smsatFreeIntIoResource( smRoot, oneDeviceData, satIntIo );
11987 tdsmEventCB( smRoot,
11989 smIntrEventTypeTaskManagement,
11991 oneDeviceData->satTmTaskTag);
11992 SM_DBG5(("smsatDeResetDeviceCB: device %p pending IO %d\n", oneDeviceData, oneDeviceData->satPendingIO));
11993 SM_DBG6(("smsatDeResetDeviceCB: end\n"));
11999 agsaRoot_t *agRoot,
12000 agsaIORequest_t *agIORequest,
12005 smRoot_t *smRoot = gsmRoot;
12006 smIORequestBody_t *smIORequestBody = agNULL;
12007 smSatIOContext_t *satIOContext;
12008 smDeviceHandle_t *smDeviceHandle;
12009 smDeviceData_t *oneDeviceData = agNULL;
12011 SM_DBG1(("smaSATAAbortCB: start\n"));
12013 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
12014 if (smIORequestBody == agNULL)
12016 SM_DBG1(("smaSATAAbortCB: smIORequestBody is NULL!!! \n"));
12020 satIOContext = &(smIORequestBody->transport.SATA.satIOContext);
12021 if (satIOContext == agNULL)
12023 SM_DBG1(("smaSATAAbortCB: satIOContext is NULL!!! \n"));
12024 if (smIORequestBody->IOType.InitiatorTMIO.osMemHandle != agNULL)
12026 tdsmFreeMemory(smRoot,
12027 smIORequestBody->IOType.InitiatorTMIO.osMemHandle,
12028 sizeof(smIORequestBody_t)
12034 smDeviceHandle = smIORequestBody->smDevHandle;
12035 if (smDeviceHandle == agNULL)
12037 SM_DBG1(("smaSATAAbortCB: smDeviceHandle is NULL!!!\n"));
12038 if (smIORequestBody->IOType.InitiatorTMIO.osMemHandle != agNULL)
12040 tdsmFreeMemory(smRoot,
12041 smIORequestBody->IOType.InitiatorTMIO.osMemHandle,
12042 sizeof(smIORequestBody_t)
12048 oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData;
12049 if (oneDeviceData == agNULL)
12051 SM_DBG1(("smaSATAAbortCB: oneDeviceData is NULL!!!\n"));
12052 if (smIORequestBody->IOType.InitiatorTMIO.osMemHandle != agNULL)
12054 tdsmFreeMemory(smRoot,
12055 smIORequestBody->IOType.InitiatorTMIO.osMemHandle,
12056 sizeof(smIORequestBody_t)
12065 /* abort per port */
12066 SM_DBG1(("smaSATAAbortCB: abort per port, not yet!!!\n"));
12068 else if (flag == 1)
12070 SM_DBG1(("smaSATAAbortCB: abort all!!!\n"));
12071 if (oneDeviceData->OSAbortAll == agTRUE)
12073 oneDeviceData->OSAbortAll = agFALSE;
12075 ostiInitiatorEvent( tiRoot,
12078 tiIntrEventTypeLocalAbort,
12083 tdsmEventCB( smRoot,
12085 smIntrEventTypeLocalAbort,
12091 if (smIORequestBody->IOType.InitiatorTMIO.osMemHandle != agNULL)
12093 tdsmFreeMemory(smRoot,
12094 smIORequestBody->IOType.InitiatorTMIO.osMemHandle,
12095 sizeof(smIORequestBody_t)
12099 else if (flag == 0)
12101 SM_DBG1(("smaSATAAbortCB: abort one\n"));
12102 if (status == OSSA_IO_SUCCESS)
12104 SM_DBG1(("smaSATAAbortCB: OSSA_IO_SUCCESS\n"));
12106 else if (status == OSSA_IO_NOT_VALID)
12108 SM_DBG1(("smaSATAAbortCB: OSSA_IO_NOT_VALID\n"));
12110 else if (status == OSSA_IO_NO_DEVICE)
12112 SM_DBG1(("smaSATAAbortCB: OSSA_IO_NO_DEVICE\n"));
12114 else if (status == OSSA_IO_ABORT_IN_PROGRESS)
12116 SM_DBG1(("smaSATAAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
12119 else if (status == OSSA_IO_ABORT_DELAYED)
12121 SM_DBG1(("smaSATAAbortCB: OSSA_IO_ABORT_DELAYED\n"));
12126 SM_DBG1(("smaSATAAbortCB: unspecified status 0x%x\n", status ));
12128 if (smIORequestBody->IOType.InitiatorTMIO.osMemHandle != agNULL)
12130 tdsmFreeMemory(smRoot,
12131 smIORequestBody->IOType.InitiatorTMIO.osMemHandle,
12132 sizeof(smIORequestBody_t)
12138 SM_DBG1(("smaSATAAbortCB: wrong flag %d\n", flag));
12145 smLocalPhyControlCB(
12146 agsaRoot_t *agRoot,
12147 agsaContext_t *agContext,
12149 bit32 phyOperation,
12154 smRoot_t *smRoot = gsmRoot;
12155 smIORequestBody_t *smIORequestBody = agNULL;
12156 smDeviceHandle_t *smDeviceHandle;
12157 smDeviceData_t *oneDeviceData = agNULL;
12158 smIORequest_t *currentTaskTag;
12159 agsaDevHandle_t *agDevHandle = agNULL;
12161 SM_DBG1(("smLocalPhyControlCB: start phyId 0x%x phyOperation 0x%x status 0x%x\n",phyId,phyOperation,status));
12163 if (agContext == agNULL)
12165 SM_DBG1(("smLocalPhyControlCB: agContext is NULL!!!\n"));
12168 currentTaskTag = (smIORequest_t *)agContext->osData;
12169 if (currentTaskTag == agNULL)
12171 SM_DBG1(("smLocalPhyControlCB: currentTaskTag is NULL!!!\n"));
12174 smIORequestBody = (smIORequestBody_t *)currentTaskTag->smData;
12175 if (smIORequestBody == agNULL)
12177 SM_DBG1(("smLocalPhyControlCB: smIORequestBody is NULL!!!\n"));
12180 smDeviceHandle = smIORequestBody->smDevHandle;
12181 if (smDeviceHandle == agNULL)
12183 SM_DBG1(("smLocalPhyControlCB: smDeviceHandle is NULL!!!\n"));
12186 oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData;
12187 if (oneDeviceData == agNULL)
12189 SM_DBG1(("smLocalPhyControlCB: oneDeviceData is NULL!!!\n"));
12192 switch (phyOperation)
12194 case AGSA_PHY_LINK_RESET: /* fall through */
12195 case AGSA_PHY_HARD_RESET:
12196 if (status == OSSA_SUCCESS)
12198 SM_DBG2(("smLocalPhyControlCB: callback to TD layer with success\n"));
12199 agDevHandle = oneDeviceData->agDevHandle;
12200 SM_DBG2(("smLocalPhyControlCB: satPendingIO %d satNCQMaxIO %d\n", oneDeviceData->satPendingIO, oneDeviceData->satNCQMaxIO ));
12201 SM_DBG1(("smLocalPhyControlCB: satPendingNCQIO %d satPendingNONNCQIO %d\n", oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO));
12202 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL;
12204 saSetDeviceState(agRoot,
12206 tdsmRotateQnumber(smRoot, smDeviceHandle),
12211 tdsmEventCB( smRoot,
12213 smIntrEventTypeTaskManagement,
12220 SM_DBG1(("smLocalPhyControlCB: callback to TD layer with failure!!!\n"));
12222 tdsmEventCB( smRoot,
12224 smIntrEventTypeTaskManagement,
12230 SM_DBG1(("ossaLocalPhyControlCB: error default case. phyOperation is %d!!!\n", phyOperation));
12232 tdsmEventCB( smRoot,
12234 smIntrEventTypeTaskManagement,
12243 smsatSetFeaturesAACB(
12244 agsaRoot_t *agRoot,
12245 agsaIORequest_t *agIORequest,
12247 agsaFisHeader_t *agFirstDword,
12253 smRoot_t *smRoot = agNULL;
12254 smIntRoot_t *smIntRoot = agNULL;
12255 smIntContext_t *smAllShared = agNULL;
12256 smIORequestBody_t *smIORequestBody;
12257 smIORequestBody_t *smOrgIORequestBody = agNULL;
12258 smSatIOContext_t *satIOContext;
12259 smSatIOContext_t *satOrgIOContext;
12260 smSatInternalIo_t *satIntIo;
12261 smDeviceData_t *oneDeviceData;
12262 smIORequest_t *smOrgIORequest;
12263 smDeviceHandle_t *smDeviceHandle;
12264 smIORequest_t *smIORequest;
12265 bit32 ataStatus = 0;
12266 bit32 ataError = 0;
12267 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
12269 SM_DBG2(("smsatSetFeaturesAACB: start\n"));
12270 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
12271 satIOContext = (smSatIOContext_t *) ioContext;
12272 if (satIOContext == agNULL)
12274 SM_DBG1(("smsatSetFeaturesAACB: satIOContext is NULL\n"));
12277 satIntIo = satIOContext->satIntIoContext;
12278 oneDeviceData = satIOContext->pSatDevData;
12279 smDeviceHandle = satIOContext->psmDeviceHandle;
12280 smRoot = oneDeviceData->smRoot;
12281 smIntRoot = (smIntRoot_t *)smRoot->smData;
12282 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
12283 if (satIntIo == agNULL)
12285 SM_DBG5(("smsatSetFeaturesAACB: External smSatInternalIo_t satIntIoContext\n"));
12286 satOrgIOContext = satIOContext;
12287 smOrgIORequest = smIORequestBody->smIORequest;
12288 smIORequest = smOrgIORequest;
12292 SM_DBG5(("smsatSetFeaturesAACB: Internal smSatInternalIo_t satIntIoContext\n"));
12293 satOrgIOContext = satIOContext->satOrgIOContext;
12294 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
12295 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
12297 smIORequest = smOrgIORequestBody->smIORequest;
12298 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
12299 smIORequestBody->ioCompleted = agTRUE;
12300 smIORequestBody->ioStarted = agFALSE;
12301 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
12303 SM_DBG1(("smsatSetFeaturesAACB: fail, case 1 agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
12305 if (agIOStatus != OSSA_IO_SUCCESS)
12307 SM_DBG1(("smsatSetFeaturesAACB: fail, case 2 status %d!!!\n", agIOStatus));
12309 if (agIOInfoLen != 0 && agIOStatus == OSSA_IO_SUCCESS)
12311 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
12312 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
12313 ataError = statDevToHostFisHeader->error; /* ATA Eror register */
12314 if ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
12316 SM_DBG1(("smsatSetFeaturesAACB: fail, case 3 ataStatus %d ataError %d!!!\n", ataStatus, ataError));
12320 SM_DBG1(("smsatSetFeaturesAACB: fail, case 4 ataStatus %d ataError %d!!!\n", ataStatus, ataError));
12323 /* interal structure free */
12324 smsatFreeIntIoResource(smRoot,oneDeviceData, satIntIo);
12325 if (smIORequest->tdData == smIORequest->smData)
12327 SM_DBG1(("smsatSetFeaturesAACB: the same tdData and smData error!\n"));
12329 /*Complete this identify device IO */
12330 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12331 SM_DBG2(("smsatSetFeaturesAACB: end\n"));
12334 /*****************************************************************************
12335 *! \brief smsatSetFeaturesDMACB
12337 * This routine is a callback function called from smllSATACompleted().
12338 * This CB routine deals with normal non-chained data I/O SATA request.
12340 * \param agRoot: Handles for this instance of SAS/SATA hardware
12341 * \param agIORequest: Pointer to the LL I/O request context for this I/O.
12342 * \param agIOStatus: Status of completed I/O.
12343 * \param agFirstDword:Pointer to the four bytes of FIS.
12344 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS
12346 * \param agParam: Additional info based on status.
12347 * \param ioContext: Pointer to smSatIOContext_t.
12351 *****************************************************************************/
12353 smsatSetFeaturesDMACB(
12354 agsaRoot_t *agRoot,
12355 agsaIORequest_t *agIORequest,
12357 agsaFisHeader_t *agFirstDword,
12363 smRoot_t *smRoot = agNULL;
12364 smIntRoot_t *smIntRoot = agNULL;
12365 smIntContext_t *smAllShared = agNULL;
12366 smIORequestBody_t *smIORequestBody;
12367 smIORequestBody_t *smOrgIORequestBody = agNULL;
12368 smSatIOContext_t *satIOContext;
12369 smSatIOContext_t *satOrgIOContext;
12370 smSatIOContext_t *satNewIOContext;
12371 smSatInternalIo_t *satIntIo;
12372 smSatInternalIo_t *satNewIntIo = agNULL;
12373 smDeviceData_t *oneDeviceData;
12374 smIniScsiCmnd_t *scsiCmnd;
12375 smIORequest_t *smOrgIORequest;
12376 smDeviceHandle_t *smDeviceHandle;
12377 bit32 status = SM_RC_FAILURE;
12378 smIORequest_t *smIORequest;
12380 SM_DBG2(("smsatSetFeaturesDMACB: start\n"));
12381 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
12382 satIOContext = (smSatIOContext_t *) ioContext;
12383 if (satIOContext == agNULL)
12385 SM_DBG1(("smsatSetFeaturesDMACB: satIOContext is NULL\n"));
12388 satIntIo = satIOContext->satIntIoContext;
12389 oneDeviceData = satIOContext->pSatDevData;
12390 smDeviceHandle = satIOContext->psmDeviceHandle;
12391 smRoot = oneDeviceData->smRoot;
12392 smIntRoot = (smIntRoot_t *)smRoot->smData;
12393 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
12394 if (satIntIo == agNULL)
12396 SM_DBG2(("smsatSetFeaturesDMACB: External smSatInternalIo_t satIntIoContext\n"));
12397 satOrgIOContext = satIOContext;
12398 smOrgIORequest = smIORequestBody->smIORequest;
12399 scsiCmnd = satIOContext->pScsiCmnd;
12403 SM_DBG2(("smsatSetFeaturesDMACB: Internal smSatInternalIo_t satIntIoContext\n"));
12404 satOrgIOContext = satIOContext->satOrgIOContext;
12405 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
12406 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
12407 scsiCmnd = satOrgIOContext->pScsiCmnd;
12409 smIORequest = smOrgIORequestBody->smIORequest;
12410 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
12411 smIORequestBody->ioCompleted = agTRUE;
12412 smIORequestBody->ioStarted = agFALSE;
12414 oneDeviceData->satDMAEnabled = agTRUE;
12415 /* interal structure free */
12416 smsatFreeIntIoResource(smRoot,
12420 if (smIORequest->tdData == smIORequest->smData)
12422 SM_DBG1(("smsatSetFeaturesDMACB: the same tdData and smData error!\n"));
12424 SM_DBG2(("smsatSetFeaturesDMACB: agIOStatus 0x%x\n", agIOStatus));
12425 /* check the agIOStatus */
12426 if (agIOStatus == OSSA_IO_ABORTED ||
12427 agIOStatus == OSSA_IO_NO_DEVICE ||
12428 agIOStatus == OSSA_IO_PORT_IN_RESET ||
12429 agIOStatus == OSSA_IO_DS_NON_OPERATIONAL ||
12430 agIOStatus == OSSA_IO_DS_IN_RECOVERY ||
12431 agIOStatus == OSSA_IO_DS_IN_ERROR ||
12432 agIOStatus == OSSA_IO_DS_INVALID
12435 SM_DBG1(("smsatSetFeaturesDMACB: error status 0x%x\n", agIOStatus));
12436 SM_DBG1(("smsatSetFeaturesDMACB: did %d!!!\n", oneDeviceData->id));
12437 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12440 if (oneDeviceData->satDeviceType == SATA_ATAPI_DEVICE)
12442 /*if ATAPI device, only need to enable PIO and DMA transfer mode, then complete this identify device command */
12443 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12447 /* enble read look-ahead feature*/
12448 if (oneDeviceData->satReadLookAheadSupport == agTRUE)
12450 satNewIntIo = smsatAllocIntIoResource(smRoot,
12455 if (satNewIntIo == agNULL)
12457 SM_DBG1(("smsatSetFeaturesDMACB: memory allocation fails\n"));
12458 /*Complete this identify packet device IO */
12459 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12461 } /* end memory allocation */
12463 satNewIOContext = smsatPrepareNewIO(satNewIntIo,
12469 /* sends SET FEATURES command to enable Read Look-Ahead */
12470 status = smsatSetFeaturesReadLookAhead(smRoot,
12471 &satNewIntIo->satIntSmIORequest,
12472 satNewIOContext->psmDeviceHandle,
12473 &satNewIntIo->satIntSmScsiXchg,
12476 if (status != SM_RC_SUCCESS)
12478 smsatFreeIntIoResource(smRoot, oneDeviceData, satNewIntIo);
12479 SM_DBG1(("smsatSetFeaturesDMACB: failed to call smsatSetFeatures()\n"));
12480 /*Complete this identify device IO */
12481 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12483 SM_DBG2(("smsatSetFeaturesDMACB: end\n"));
12486 /* enble Volatile Write Cache feature*/
12487 if (oneDeviceData->satVolatileWriteCacheSupport == agTRUE)
12489 satNewIntIo = smsatAllocIntIoResource(smRoot,
12494 if (satNewIntIo == agNULL)
12496 SM_DBG1(("smsatSetFeaturesDMACB: memory allocation fails\n"));
12497 /*Complete this identify packet device IO */
12498 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12500 } /* end memory allocation */
12501 satNewIOContext = smsatPrepareNewIO(satNewIntIo,
12507 /* sends SET FEATURES command to enable Volatile Write Cache */
12508 status = smsatSetFeaturesVolatileWriteCache(smRoot,
12509 &satNewIntIo->satIntSmIORequest,
12510 satNewIOContext->psmDeviceHandle,
12511 &satNewIntIo->satIntSmScsiXchg,
12514 if (status != SM_RC_SUCCESS)
12516 smsatFreeIntIoResource(smRoot, oneDeviceData, satNewIntIo);
12517 SM_DBG1(("smsatSetFeaturesDMACB: failed to call smsatSetFeatures()\n"));
12518 /*Complete this identify device IO */
12519 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12521 SM_DBG2(("smsatSetFeaturesDMACB: end\n"));
12524 /* turn on DMA Setup FIS auto-activate by sending set feature FIS */
12525 if (oneDeviceData->satNCQ == agTRUE && oneDeviceData->satDMASetupAA == agTRUE)
12527 satNewIntIo = smsatAllocIntIoResource( smRoot,
12533 if (satNewIntIo == agNULL)
12535 SM_DBG1(("smsatSetFeaturesDMACB: momory allocation fails; can't send set feature\n"));
12536 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12538 } /* end memory allocation */
12539 satNewIOContext = smsatPrepareNewIO(satNewIntIo,
12545 /* send the Set Feature ATA command to SATA device for enable DMA Setup FIS auto-activate */
12546 status = smsatSetFeaturesAA(smRoot,
12547 &satNewIntIo->satIntSmIORequest,
12548 satNewIOContext->psmDeviceHandle,
12549 &satNewIntIo->satIntSmScsiXchg, /* orginal from OS layer */
12551 if (status != SM_RC_SUCCESS)
12553 SM_DBG1(("smsatSetFeaturesDMACB: failed to send set feature!!!\n"));
12554 smsatFreeIntIoResource( smRoot,
12557 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData));
12562 /*Complete this identify device IO */
12563 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12565 SM_DBG2(("smsatSetFeaturesDMACB: end\n"));
12568 /*****************************************************************************
12569 *! \brief smsatSetFeaturesReadLookAheadCB
12571 * This routine is a callback function called from smllSATACompleted().
12572 * This CB routine deals with normal non-chained data I/O SATA request.
12574 * \param agRoot: Handles for this instance of SAS/SATA hardware
12575 * \param agIORequest: Pointer to the LL I/O request context for this I/O.
12576 * \param agIOStatus: Status of completed I/O.
12577 * \param agFirstDword:Pointer to the four bytes of FIS.
12578 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS
12580 * \param agParam: Additional info based on status.
12581 * \param ioContext: Pointer to smSatIOContext_t.
12585 *****************************************************************************/
12587 smsatSetFeaturesReadLookAheadCB(
12588 agsaRoot_t *agRoot,
12589 agsaIORequest_t *agIORequest,
12591 agsaFisHeader_t *agFirstDword,
12597 smRoot_t *smRoot = agNULL;
12598 smIntRoot_t *smIntRoot = agNULL;
12599 smIntContext_t *smAllShared = agNULL;
12600 smIORequestBody_t *smIORequestBody;
12601 smIORequestBody_t *smOrgIORequestBody = agNULL;
12602 smSatIOContext_t *satIOContext;
12603 smSatIOContext_t *satOrgIOContext;
12604 smSatIOContext_t *satNewIOContext;
12605 smSatInternalIo_t *satIntIo;
12606 smSatInternalIo_t *satNewIntIo = agNULL;
12607 smDeviceData_t *oneDeviceData;
12608 smIniScsiCmnd_t *scsiCmnd;
12609 smIORequest_t *smOrgIORequest;
12610 smDeviceHandle_t *smDeviceHandle;
12611 bit32 status = SM_RC_FAILURE;
12612 smIORequest_t *smIORequest;
12614 SM_DBG2(("smsatSetFeaturesReadLookAheadCB: start\n"));
12615 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
12616 satIOContext = (smSatIOContext_t *) ioContext;
12617 if (satIOContext == agNULL)
12619 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: satIOContext is NULL\n"));
12622 satIntIo = satIOContext->satIntIoContext;
12623 oneDeviceData = satIOContext->pSatDevData;
12624 smDeviceHandle = satIOContext->psmDeviceHandle;
12625 smRoot = oneDeviceData->smRoot;
12626 smIntRoot = (smIntRoot_t *)smRoot->smData;
12627 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
12629 if (satIntIo == agNULL)
12631 SM_DBG2(("smsatSetFeaturesReadLookAheadCB: External smSatInternalIo_t satIntIoContext\n"));
12632 satOrgIOContext = satIOContext;
12633 smOrgIORequest = smIORequestBody->smIORequest;
12634 scsiCmnd = satIOContext->pScsiCmnd;
12638 SM_DBG2(("smsatSetFeaturesReadLookAheadCB: Internal smSatInternalIo_t satIntIoContext\n"));
12639 satOrgIOContext = satIOContext->satOrgIOContext;
12640 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
12641 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
12642 scsiCmnd = satOrgIOContext->pScsiCmnd;
12644 smIORequest = smOrgIORequestBody->smIORequest;
12645 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
12647 smIORequestBody->ioCompleted = agTRUE;
12648 smIORequestBody->ioStarted = agFALSE;
12650 oneDeviceData->satLookAheadEnabled = agTRUE;
12652 /* interal structure free */
12653 smsatFreeIntIoResource(smRoot,
12657 /* check the agIOStatus */
12658 if (agIOStatus == OSSA_IO_ABORTED ||
12659 agIOStatus == OSSA_IO_NO_DEVICE ||
12660 agIOStatus == OSSA_IO_PORT_IN_RESET ||
12661 agIOStatus == OSSA_IO_DS_NON_OPERATIONAL ||
12662 agIOStatus == OSSA_IO_DS_IN_RECOVERY ||
12663 agIOStatus == OSSA_IO_DS_IN_ERROR ||
12664 agIOStatus == OSSA_IO_DS_INVALID
12667 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: error status 0x%x\n", agIOStatus));
12668 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: did %d!!!\n", oneDeviceData->id));
12669 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12675 /* enble Volatile Write Cache feature*/
12676 if (oneDeviceData->satVolatileWriteCacheSupport == agTRUE)
12678 satNewIntIo = smsatAllocIntIoResource(smRoot,
12683 if (satNewIntIo == agNULL)
12685 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: memory allocation fails\n"));
12686 /*Complete this identify packet device IO */
12687 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12689 } /* end memory allocation */
12691 satNewIOContext = smsatPrepareNewIO(satNewIntIo,
12697 /* sends SET FEATURES command to enable Volatile Write Cache */
12698 status = smsatSetFeaturesVolatileWriteCache(smRoot,
12699 &satNewIntIo->satIntSmIORequest,
12700 satNewIOContext->psmDeviceHandle,
12701 &satNewIntIo->satIntSmScsiXchg,
12704 if (status != SM_RC_SUCCESS)
12706 smsatFreeIntIoResource(smRoot, oneDeviceData, satNewIntIo);
12707 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: failed to call smsatSetFeatures()\n"));
12708 /*Complete this identify device IO */
12709 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12711 SM_DBG2(("smsatSetFeaturesReadLookAheadCB: end\n"));
12716 /* turn on DMA Setup FIS auto-activate by sending set feature FIS */
12717 if (oneDeviceData->satNCQ == agTRUE && oneDeviceData->satDMASetupAA == agTRUE)
12719 satNewIntIo = smsatAllocIntIoResource( smRoot,
12725 if (satNewIntIo == agNULL)
12727 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: momory allocation fails; can't send set feature\n"));
12728 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12730 } /* end memory allocation */
12732 satNewIOContext = smsatPrepareNewIO(satNewIntIo,
12738 /* send the Set Feature ATA command to SATA device for enable DMA Setup FIS auto-activate */
12739 status = smsatSetFeaturesAA(smRoot,
12740 &satNewIntIo->satIntSmIORequest,
12741 satNewIOContext->psmDeviceHandle,
12742 &satNewIntIo->satIntSmScsiXchg, /* orginal from OS layer */
12745 if (status != SM_RC_SUCCESS)
12747 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: failed to send set feature!!!\n"));
12748 smsatFreeIntIoResource( smRoot,
12751 /* clean up TD layer's IORequestBody */
12752 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData));
12757 /*Complete this identify device IO */
12758 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12760 SM_DBG2(("smsatSetFeaturesReadLookAheadCB: end\n"));
12762 /*****************************************************************************
12763 *! \brief smsatSetFeaturesVolatileWriteCacheCB
12765 * This routine is a callback function called from smllSATACompleted().
12766 * This CB routine deals with normal non-chained data I/O SATA request.
12768 * \param agRoot: Handles for this instance of SAS/SATA hardware
12769 * \param agIORequest: Pointer to the LL I/O request context for this I/O.
12770 * \param agIOStatus: Status of completed I/O.
12771 * \param agFirstDword:Pointer to the four bytes of FIS.
12772 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS
12774 * \param agParam: Additional info based on status.
12775 * \param ioContext: Pointer to smSatIOContext_t.
12779 *****************************************************************************/
12781 smsatSetFeaturesVolatileWriteCacheCB(
12782 agsaRoot_t *agRoot,
12783 agsaIORequest_t *agIORequest,
12785 agsaFisHeader_t *agFirstDword,
12791 smRoot_t *smRoot = agNULL;
12792 smIntRoot_t *smIntRoot = agNULL;
12793 smIntContext_t *smAllShared = agNULL;
12794 smIORequestBody_t *smIORequestBody;
12795 smIORequestBody_t *smOrgIORequestBody = agNULL;
12796 smSatIOContext_t *satIOContext;
12797 smSatIOContext_t *satOrgIOContext;
12798 smSatIOContext_t *satNewIOContext;
12799 smSatInternalIo_t *satIntIo;
12800 smSatInternalIo_t *satNewIntIo = agNULL;
12801 smDeviceData_t *oneDeviceData;
12802 smIORequest_t *smOrgIORequest;
12803 smDeviceHandle_t *smDeviceHandle;
12804 smIORequest_t *smIORequest;
12805 bit32 ataStatus = 0;
12806 bit32 ataError = 0;
12807 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
12808 bit32 status = SM_RC_FAILURE;
12810 SM_DBG2(("smsatSetFeaturesVolatileWriteCacheCB: start\n"));
12811 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
12812 satIOContext = (smSatIOContext_t *) ioContext;
12813 if (satIOContext == agNULL)
12815 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: satIOContext is NULL\n"));
12818 satIntIo = satIOContext->satIntIoContext;
12819 oneDeviceData = satIOContext->pSatDevData;
12820 smDeviceHandle = satIOContext->psmDeviceHandle;
12821 smRoot = oneDeviceData->smRoot;
12822 smIntRoot = (smIntRoot_t *)smRoot->smData;
12823 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
12824 if (satIntIo == agNULL)
12826 SM_DBG5(("smsatSetFeaturesVolatileWriteCacheCB: External smSatInternalIo_t satIntIoContext\n"));
12827 satOrgIOContext = satIOContext;
12828 smOrgIORequest = smIORequestBody->smIORequest;
12829 smIORequest = smOrgIORequest;
12833 SM_DBG5(("smsatSetFeaturesVolatileWriteCacheCB: Internal smSatInternalIo_t satIntIoContext\n"));
12834 satOrgIOContext = satIOContext->satOrgIOContext;
12835 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
12836 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
12838 smIORequest = smOrgIORequestBody->smIORequest;
12839 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
12841 smIORequestBody->ioCompleted = agTRUE;
12842 smIORequestBody->ioStarted = agFALSE;
12843 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
12845 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: fail, case 1 agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
12847 if (agIOStatus != OSSA_IO_SUCCESS)
12849 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: fail, case 2 status %d!!!\n", agIOStatus));
12851 if (agIOInfoLen != 0 && agIOStatus == OSSA_IO_SUCCESS)
12853 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
12854 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
12855 ataError = statDevToHostFisHeader->error; /* ATA Eror register */
12856 if ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
12858 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: fail, case 3 ataStatus %d ataError %d!!!\n", ataStatus, ataError));
12862 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: fail, case 4 ataStatus %d ataError %d!!!\n", ataStatus, ataError));
12866 oneDeviceData->satWriteCacheEnabled = agTRUE;
12868 /* interal structure free */
12869 smsatFreeIntIoResource(smRoot,oneDeviceData, satIntIo);
12870 /* check the agIOStatus */
12871 if (agIOStatus == OSSA_IO_ABORTED ||
12872 agIOStatus == OSSA_IO_NO_DEVICE ||
12873 agIOStatus == OSSA_IO_PORT_IN_RESET ||
12874 agIOStatus == OSSA_IO_DS_NON_OPERATIONAL ||
12875 agIOStatus == OSSA_IO_DS_IN_RECOVERY ||
12876 agIOStatus == OSSA_IO_DS_IN_ERROR ||
12877 agIOStatus == OSSA_IO_DS_INVALID
12880 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: error status 0x%x\n", agIOStatus));
12881 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: did %d!!!\n", oneDeviceData->id));
12882 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12885 /* turn on DMA Setup FIS auto-activate by sending set feature FIS */
12886 if (oneDeviceData->satNCQ == agTRUE && oneDeviceData->satDMASetupAA == agTRUE)
12888 satNewIntIo = smsatAllocIntIoResource( smRoot,
12893 if (satNewIntIo == agNULL)
12895 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: momory allocation fails; can't send set feature\n"));
12896 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12898 } /* end memory allocation */
12899 satNewIOContext = smsatPrepareNewIO(satNewIntIo,
12905 /* send the Set Feature ATA command to SATA device for enable DMA Setup FIS auto-activate */
12906 status = smsatSetFeaturesAA(smRoot,
12907 &satNewIntIo->satIntSmIORequest,
12908 satNewIOContext->psmDeviceHandle,
12909 &satNewIntIo->satIntSmScsiXchg, /* orginal from OS layer */
12911 if (status != SM_RC_SUCCESS)
12913 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: failed to send set feature!!!\n"));
12914 smsatFreeIntIoResource( smRoot,
12917 /* clean up TD layer's IORequestBody */
12918 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData));
12923 /*Complete this identify device IO */
12924 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData));
12926 SM_DBG2(("smsatSetFeaturesVolatileWriteCacheCB: end\n"));
12931 smsatSMARTEnablePassCB(
12932 agsaRoot_t *agRoot,
12933 agsaIORequest_t *agIORequest,
12935 agsaFisHeader_t *agFirstDword,
12937 agsaFrameHandle_t agFrameHandle,
12942 smRoot_t *smRoot = agNULL;
12943 smIntRoot_t *smIntRoot = agNULL;
12944 smIntContext_t *smAllShared = agNULL;
12945 smIORequestBody_t *smIORequestBody;
12946 smIORequestBody_t *smOrgIORequestBody;
12947 smSatIOContext_t *satIOContext;
12948 smSatIOContext_t *satOrgIOContext;
12949 //smSatIOContext_t *satNewIOContext;
12950 smSatInternalIo_t *satIntIo;
12951 //smSatInternalIo_t *satNewIntIo = agNULL;
12952 // satDeviceData_t *satDevData;
12953 smDeviceData_t *oneDeviceData;
12954 smIniScsiCmnd_t *scsiCmnd;
12955 smIORequest_t *smOrgIORequest;
12957 smScsiRspSense_t *pSense;
12958 bit8 bSenseKey = 0;
12959 bit16 bSenseCodeInfo = 0;
12962 SM_DBG2(("smsatSMARTEnablePassCB: start\n"));
12963 SM_DBG4(("smsatSMARTEnablePassCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
12965 /* internally generate tiIOContext */
12966 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
12967 satIOContext = (smSatIOContext_t *) ioContext;
12968 satIntIo = satIOContext->satIntIoContext;
12969 oneDeviceData = satIOContext->pSatDevData;
12970 smRoot = oneDeviceData->smRoot;
12971 smIntRoot = (smIntRoot_t *)smRoot->smData;
12972 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
12974 if (satIntIo == agNULL)
12976 SM_DBG4(("smsatSMARTEnablePassCB: External smSatInternalIo_t satIntIoContext\n"));
12977 satOrgIOContext = satIOContext;
12978 smOrgIORequest = smIORequestBody->smIORequest;
12979 scsiCmnd = satOrgIOContext->pScsiCmnd;
12980 pSense = satOrgIOContext->pSense;
12984 SM_DBG4(("smsatSMARTEnablePassCB: Internal smSatInternalIo_t satIntIoContext\n"));
12985 satOrgIOContext = satIOContext->satOrgIOContext;
12986 if (satOrgIOContext == agNULL)
12988 SM_DBG4(("smsatSMARTEnablePassCB: satOrgIOContext is NULL, wrong\n"));
12993 SM_DBG4(("smsatSMARTEnablePassCB: satOrgIOContext is NOT NULL\n"));
12995 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
12996 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
12997 scsiCmnd = satOrgIOContext->pScsiCmnd;
12998 pSense = satOrgIOContext->pSense;
13000 smIORequestBody->ioCompleted = agTRUE;
13001 smIORequestBody->ioStarted = agFALSE;
13003 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
13005 SM_DBG1(("smsatSMARTEnablePassCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
13010 smDetailOtherError,
13012 satOrgIOContext->interruptContext
13014 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13015 smsatFreeIntIoResource( smRoot,
13021 checking IO status, FIS type and error status
13023 if (agIOStatus != OSSA_IO_SUCCESS)
13025 SM_DBG1(("smsatSMARTEnablePassCB: not success status, status %d!!!\n", agIOStatus));
13026 if (agIOStatus == OSSA_IO_ABORTED)
13028 smsatProcessAbort(smRoot,
13033 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13034 smsatFreeIntIoResource( smRoot,
13040 smsatTranslateATAErrorsToSCSIErrors(
13041 agFirstDword->D2H.status,
13042 agFirstDword->D2H.error,
13046 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext);
13047 tdsmIOCompletedCB(smRoot,
13050 SCSI_STAT_CHECK_CONDITION,
13051 satOrgIOContext->pSmSenseData,
13052 satOrgIOContext->interruptContext );
13055 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13057 smsatFreeIntIoResource( smRoot,
13063 /* process success case */
13064 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13065 smsatFreeIntIoResource( smRoot,
13069 SM_DBG1(("smsatSMARTEnablePassCB:success status, status %d!!!\n", agIOStatus));
13076 satOrgIOContext->interruptContext
13085 smsatSMARTRStatusPassCB(
13086 agsaRoot_t *agRoot,
13087 agsaIORequest_t *agIORequest,
13089 agsaFisHeader_t *agFirstDword,
13098 smRoot_t *smRoot = agNULL;
13099 smIntRoot_t *smIntRoot = agNULL;
13100 smIntContext_t *smAllShared = agNULL;
13101 smIORequestBody_t *smIORequestBody;
13102 smIORequestBody_t *smOrgIORequestBody;
13103 smSatIOContext_t *satIOContext;
13104 smSatIOContext_t *satOrgIOContext;
13105 smSatInternalIo_t *satIntIo;
13106 // satDeviceData_t *satDevData;
13107 smDeviceData_t *oneDeviceData;
13109 smScsiRspSense_t *pSense;
13110 smIORequest_t *smOrgIORequest;
13112 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
13113 bit32 ataStatus = 0;
13114 smScsiInitiatorRequest_t *smScsiRequest; /* tiScsiXchg */
13115 smScsiInitiatorRequest_t *smOrgScsiRequest; /* tiScsiXchg */
13116 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
13117 // agsaFisRegD2HData_t statDevToHostFisData;
13118 smIniScsiCmnd_t *scsiCmnd;
13119 bit8 bSenseKey = 0;
13120 bit16 bSenseCodeInfo = 0;
13123 SM_DBG2(("smsatSMARTRStatusPassCB: start\n"));
13124 SM_DBG5(("smsatSMARTRStatusPassCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
13126 /* internally generate smIOContext */
13127 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
13128 satIOContext = (smSatIOContext_t *) ioContext;
13129 satIntIo = satIOContext->satIntIoContext;
13130 oneDeviceData = satIOContext->pSatDevData;
13131 hostToDevFis = satIOContext->pFis;
13132 smRoot = oneDeviceData->smRoot;
13133 smIntRoot = (smIntRoot_t *)smRoot->smData;
13134 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
13136 if (satIntIo == agNULL)
13138 SM_DBG4(("smsatSMARTRStatusPassCB: External smSatInternalIo_t satIntIoContext\n"));
13139 satOrgIOContext = satIOContext;
13140 smOrgIORequest = smIORequestBody->smIORequest;
13141 pSense = satOrgIOContext->pSense;
13142 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
13143 /* ATA command response payload */
13144 smScsiRequest = satOrgIOContext->smScsiXchg;
13145 scsiCmnd = satOrgIOContext->pScsiCmnd;
13146 SM_DBG1((" 0x%02x, 0x%02x, 0x%02x, 0x%02x,\n", scsiCmnd->cdb[0], scsiCmnd->cdb[1],scsiCmnd->cdb[2], scsiCmnd->cdb[3]));
13147 SM_DBG1((" 0x%02x, 0x%02x, 0x%02x, 0x%02x,\n", scsiCmnd->cdb[4], scsiCmnd->cdb[5],scsiCmnd->cdb[6], scsiCmnd->cdb[7]));
13148 SM_DBG1((" 0x%02x, 0x%02x, 0x%02x, 0x%02x,\n", scsiCmnd->cdb[8], scsiCmnd->cdb[9],scsiCmnd->cdb[10], scsiCmnd->cdb[11]));
13154 SM_DBG4(("smsatSMARTRStatusPassCB: Internal smSatInternalIo_t satIntIoContext\n"));
13155 satOrgIOContext = satIOContext->satOrgIOContext;
13156 if (satOrgIOContext == agNULL)
13158 SM_DBG4(("smsatSMARTRStatusPassCB: satOrgIOContext is NULL\n"));
13165 SM_DBG4(("smsatSMARTRStatusPassCB: satOrgIOContext is NOT NULL\n"));
13167 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
13168 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
13170 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
13171 /* ATA command response payload */
13172 smScsiRequest = (smScsiInitiatorRequest_t *)&(satIntIo->satIntSmScsiXchg);
13173 scsiCmnd = satOrgIOContext->pScsiCmnd;
13174 pSense = satOrgIOContext->pSense;
13177 smIORequestBody->ioCompleted = agTRUE;
13178 smIORequestBody->ioStarted = agFALSE;
13180 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
13182 SM_DBG1(("smsatSMARTRStatusPassCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
13187 smDetailOtherError,
13189 satOrgIOContext->interruptContext
13191 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13193 smsatFreeIntIoResource( smRoot,
13199 if( agIOStatus != OSSA_IO_SUCCESS)
13202 /* non-data -> device to host fis are expected */
13204 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
13205 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
13207 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) ||
13208 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
13211 /* for debugging */
13212 if( agIOStatus != OSSA_IO_SUCCESS)
13214 SM_DBG1(("smsatSMARTRStatusPassCB: FAILED, NOT IO_SUCCESS!!!\n"));
13216 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
13218 SM_DBG1(("smsatSMARTRStatusPassCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
13220 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
13221 (ataStatus & DF_ATA_STATUS_MASK)
13224 SM_DBG1(("smsatSMARTRStatusPassCB: FAILED, FAILED, error status!!!\n"));
13227 /* Process abort case */
13228 if (agIOStatus == OSSA_IO_ABORTED)
13230 smsatProcessAbort(smRoot,
13235 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13237 smsatFreeIntIoResource( smRoot,
13243 smsatTranslateATAErrorsToSCSIErrors(
13244 agFirstDword->D2H.status,
13245 agFirstDword->D2H.error,
13249 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext);
13250 tdsmIOCompletedCB(smRoot,
13253 SCSI_STAT_CHECK_CONDITION,
13254 satOrgIOContext->pSmSenseData,
13255 satOrgIOContext->interruptContext );
13258 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13260 smsatFreeIntIoResource( smRoot,
13265 } /* error checking */
13268 /* prcessing the success case */
13269 SM_DBG5(("smsatSMARTRStatusPassCB: SAT_SMART_RETURN_STATUS success\n"));
13271 tdsmIOCompletedCB( smRoot,
13276 satOrgIOContext->interruptContext);
13279 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13281 smsatFreeIntIoResource( smRoot,
13290 smsatSMARTReadLogCB(
13291 agsaRoot_t *agRoot,
13292 agsaIORequest_t *agIORequest,
13294 agsaFisHeader_t *agFirstDword,
13301 smRoot_t *smRoot = agNULL;
13302 smIntRoot_t *smIntRoot = agNULL;
13303 smIntContext_t *smAllShared = agNULL;
13304 smIORequestBody_t *smIORequestBody;
13305 smIORequestBody_t *smOrgIORequestBody;
13306 smSatIOContext_t *satIOContext;
13307 smSatIOContext_t *satOrgIOContext;
13308 smSatInternalIo_t *satIntIo;
13309 // satDeviceData_t *satDevData;
13310 smDeviceData_t *oneDeviceData;
13312 smScsiRspSense_t *pSense;
13313 smIORequest_t *smOrgIORequest;
13315 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
13316 bit32 ataStatus = 0;
13317 smScsiInitiatorRequest_t *smScsiRequest; /* tiScsiXchg */
13318 smScsiInitiatorRequest_t *smOrgScsiRequest; /* tiScsiXchg */
13319 // satReadLogExtSelfTest_t *virtAddr1;
13320 // satSmartReadLogSelfTest_t *virtAddr2;
13322 // bit8 SelfTestExecutionStatus = 0;
13325 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
13326 // agsaFisRegD2HData_t statDevToHostFisData;
13327 smIniScsiCmnd_t *scsiCmnd;
13328 // bit32 lenReceived = 0;
13329 bit8 bSenseKey = 0;
13330 bit16 bSenseCodeInfo = 0;
13332 SM_DBG2(("smsatSMARTReadLogCB: start\n"));
13333 SM_DBG5(("smsatSMARTReadLogCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
13335 /* internally generate smIOContext */
13336 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
13337 satIOContext = (smSatIOContext_t *) ioContext;
13338 satIntIo = satIOContext->satIntIoContext;
13339 oneDeviceData = satIOContext->pSatDevData;
13340 hostToDevFis = satIOContext->pFis;
13341 smRoot = oneDeviceData->smRoot;
13342 smIntRoot = (smIntRoot_t *)smRoot->smData;
13343 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
13345 if (satIntIo == agNULL)
13347 SM_DBG4(("smsatSMARTReadLogCB: External smSatInternalIo_t satIntIoContext\n"));
13348 satOrgIOContext = satIOContext;
13349 smOrgIORequest = smIORequestBody->smIORequest;
13350 pSense = satOrgIOContext->pSense;
13351 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
13353 /* ATA command response payload */
13354 smScsiRequest = satOrgIOContext->smScsiXchg;
13355 scsiCmnd = satOrgIOContext->pScsiCmnd;
13361 SM_DBG4(("smsatSMARTReadLogCB: Internal smSatInternalIo_t satIntIoContext\n"));
13362 satOrgIOContext = satIOContext->satOrgIOContext;
13363 if (satOrgIOContext == agNULL)
13365 SM_DBG4(("smsatSMARTReadLogCB: satOrgIOContext is NULL\n"));
13372 SM_DBG4(("smsatSMARTReadLogCB: satOrgIOContext is NOT NULL\n"));
13374 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
13375 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
13377 pSense = satOrgIOContext->pSense;
13378 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
13380 /* ATA command response payload */
13381 smScsiRequest = (smScsiInitiatorRequest_t *)&(satIntIo->satIntSmScsiXchg);
13382 scsiCmnd = satOrgIOContext->pScsiCmnd;
13385 smIORequestBody->ioCompleted = agTRUE;
13386 smIORequestBody->ioStarted = agFALSE;
13388 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
13390 SM_DBG1(("smsatSMARTReadLogCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
13395 smDetailOtherError,
13397 satOrgIOContext->interruptContext
13399 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13401 smsatFreeIntIoResource( smRoot,
13408 if(agFirstDword != NULL)
13410 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
13411 SM_DBG1(("smsatSMARTReadLogCB: statDevToHostFisHeader->status, status %d!!!\n", statDevToHostFisHeader->status));
13413 if ((agIOStatus != OSSA_IO_SUCCESS) && (agFirstDword != NULL))
13415 /* non-data and pio read -> device to host and pio setup fis are expected */
13417 first, assumed to be Reg Device to Host FIS
13418 This is OK to just find fis type
13420 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
13421 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
13424 if( agIOStatus != OSSA_IO_SUCCESS)
13426 if ( ((statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) &&
13427 (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS)) ||
13428 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
13431 /* for debugging */
13432 if( agIOStatus != OSSA_IO_SUCCESS)
13434 SM_DBG1(("smsatSMARTReadLogCB: FAILED, NOT IO_SUCCESS!!!\n"));
13436 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
13438 SM_DBG1(("smsatSMARTReadLogCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
13440 else if (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS)
13442 SM_DBG1(("smsatSMARTReadLogCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
13444 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
13445 (ataStatus & DF_ATA_STATUS_MASK)
13448 SM_DBG1(("smsatSMARTReadLogCB: FAILED, FAILED, error status!!!\n"));
13451 /* Process abort case */
13452 if (agIOStatus == OSSA_IO_ABORTED)
13454 smsatProcessAbort(smRoot,
13459 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13461 smsatFreeIntIoResource( smRoot,
13467 /* for debugging */
13469 if (hostToDevFis->h.command == SAT_SMART)
13471 if (hostToDevFis->h.features == SAT_SMART_READ_LOG)
13473 SM_DBG1(("smsatSMARTReadLogCB: SAT_SMART_READ_LOG failed!!!\n"));
13477 SM_DBG1(("smsatSMARTReadLogCB: error unknown command 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features));
13482 SM_DBG1(("smsatSMARTReadLogCB: error default case command 0x%x!!!\n", hostToDevFis->h.command));
13485 smsatTranslateATAErrorsToSCSIErrors(
13486 agFirstDword->D2H.status,
13487 agFirstDword->D2H.error,
13491 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext);
13492 tdsmIOCompletedCB(smRoot,
13495 SCSI_STAT_CHECK_CONDITION,
13496 satOrgIOContext->pSmSenseData,
13497 satOrgIOContext->interruptContext );
13500 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13502 smsatFreeIntIoResource( smRoot,
13507 } /* error checking */
13510 /* prcessing the success case */
13513 tdsmIOCompletedCB( smRoot,
13518 satOrgIOContext->interruptContext);
13520 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13522 smsatFreeIntIoResource( smRoot,
13530 smsatPassthroughCB(
13531 agsaRoot_t *agRoot,
13532 agsaIORequest_t *agIORequest,
13534 agsaFisHeader_t *agFirstDword,
13540 smRoot_t *smRoot = agNULL;
13541 smIntRoot_t *smIntRoot = agNULL;
13542 smIntContext_t *smAllShared = agNULL;
13543 smIORequestBody_t *smIORequestBody;
13544 smIORequestBody_t *smOrgIORequestBody;
13545 smSatIOContext_t *satIOContext;
13546 smSatIOContext_t *satOrgIOContext;
13547 smSatInternalIo_t *satIntIo;
13548 smDeviceData_t *oneDeviceData;
13549 smScsiRspSense_t *pSense;
13550 smIORequest_t *smOrgIORequest;
13551 agsaFisRegHostToDevice_t *hostToDevFis = agNULL;
13552 bit32 ataStatus = 0;
13553 smScsiInitiatorRequest_t *smScsiRequest; /* tiScsiXchg */
13554 smScsiInitiatorRequest_t *smOrgScsiRequest; /* tiScsiXchg */
13556 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL;
13557 smIniScsiCmnd_t *scsiCmnd;
13558 bit8 bSenseKey = 0;
13559 bit16 bSenseCodeInfo = 0;
13561 SM_DBG2(("smsatPassthroughCB: start\n"));
13562 SM_DBG5(("smsatPassthroughCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen));
13564 /* internally generate smIOContext */
13565 smIORequestBody = (smIORequestBody_t *)agIORequest->osData;
13566 satIOContext = (smSatIOContext_t *) ioContext;
13567 satIntIo = satIOContext->satIntIoContext;
13568 oneDeviceData = satIOContext->pSatDevData;
13569 hostToDevFis = satIOContext->pFis;
13570 smRoot = oneDeviceData->smRoot;
13571 smIntRoot = (smIntRoot_t *)smRoot->smData;
13572 smAllShared = (smIntContext_t *)&smIntRoot->smAllShared;
13574 if (satIntIo == agNULL)
13576 SM_DBG4(("smsatPassthroughCB: External smSatInternalIo_t satIntIoContext\n"));
13577 satOrgIOContext = satIOContext;
13578 smOrgIORequest = smIORequestBody->smIORequest;
13579 pSense = satOrgIOContext->pSense;
13580 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
13582 /* ATA command response payload */
13583 smScsiRequest = satOrgIOContext->smScsiXchg;
13584 scsiCmnd = satOrgIOContext->pScsiCmnd;
13588 SM_DBG4(("smsatPassthroughCB: Internal smSatInternalIo_t satIntIoContext\n"));
13589 satOrgIOContext = satIOContext->satOrgIOContext;
13590 if (satOrgIOContext == agNULL)
13592 SM_DBG4(("smsatPassthroughCB: satOrgIOContext is NULL\n"));
13597 SM_DBG4(("smsatPassthroughCB: satOrgIOContext is NOT NULL\n"));
13599 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody;
13600 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest;
13602 pSense = satOrgIOContext->pSense;
13603 smOrgScsiRequest = satOrgIOContext->smScsiXchg;
13605 /* ATA command response payload */
13606 smScsiRequest = (smScsiInitiatorRequest_t *)&(satIntIo->satIntSmScsiXchg);
13607 scsiCmnd = satOrgIOContext->pScsiCmnd;
13610 smIORequestBody->ioCompleted = agTRUE;
13611 smIORequestBody->ioStarted = agFALSE;
13614 if (agIOStatus == OSSA_IO_UNDERFLOW)
13616 SM_DBG1(("smsatPassthroughCB: IO_UNDERFLOW, status %d!!!\n", agIOStatus));
13617 tdsmIOCompletedCB( smRoot,
13622 satOrgIOContext->interruptContext
13624 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13626 smsatFreeIntIoResource( smRoot,
13633 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS)
13635 SM_DBG1(("smsatPassthroughCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus));
13636 tdsmIOCompletedCB( smRoot,
13639 smDetailOtherError,
13641 satOrgIOContext->interruptContext
13643 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13645 smsatFreeIntIoResource( smRoot,
13653 if ((agIOStatus != OSSA_IO_SUCCESS) && (agFirstDword != NULL))
13655 /* non-data and pio read -> device to host and pio setup fis are expected */
13657 first, assumed to be Reg Device to Host FIS
13658 This is OK to just find fis type
13660 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
13661 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */
13663 if( agIOStatus != OSSA_IO_SUCCESS)
13665 if ( ((statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) &&
13666 (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS)) ||
13667 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK))
13670 /* for debugging */
13671 if( agIOStatus != OSSA_IO_SUCCESS)
13673 SM_DBG1(("smsatPassthroughCB: FAILED, NOT IO_SUCCESS!!!\n"));
13675 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS)
13677 SM_DBG1(("smsatPassthroughCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
13679 else if (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS)
13681 SM_DBG1(("smsatPassthroughCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType));
13683 else if ( (ataStatus & ERR_ATA_STATUS_MASK) ||
13684 (ataStatus & DF_ATA_STATUS_MASK)
13687 SM_DBG1(("smsatPassthroughCB: FAILED, FAILED, error status!!!\n"));
13690 /* Process abort case */
13691 if (agIOStatus == OSSA_IO_ABORTED)
13693 smsatProcessAbort( smRoot,
13697 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13699 smsatFreeIntIoResource( smRoot,
13705 smsatTranslateATAErrorsToSCSIErrors( agFirstDword->D2H.status,
13706 agFirstDword->D2H.error,
13710 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext);
13711 tdsmIOCompletedCB( smRoot,
13714 SCSI_STAT_CHECK_CONDITION,
13715 satOrgIOContext->pSmSenseData,
13716 satOrgIOContext->interruptContext );
13719 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13720 smsatFreeIntIoResource( smRoot,
13725 } /* error checking */
13728 /* prcessing the success case */
13729 if(agFirstDword != NULL)
13731 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H);
13732 SM_DBG1(("smsatPassthroughCB: statDevToHostFisHeader->status, status %d!!!\n", statDevToHostFisHeader->status));
13733 smsatTranslateATAErrorsToSCSIErrors( agFirstDword->D2H.status,
13734 agFirstDword->D2H.error,
13737 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext);
13738 if(agFirstDword->D2H.status & 0x01)
13740 tdsmIOCompletedCB( smRoot,
13743 SCSI_STAT_CHECK_CONDITION,
13744 satOrgIOContext->pSmSenseData,
13745 satOrgIOContext->interruptContext );
13746 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13747 smsatFreeIntIoResource( smRoot,
13754 tdsmIOCompletedCB( smRoot,
13759 satOrgIOContext->interruptContext);
13761 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext);
13763 smsatFreeIntIoResource( smRoot,