1 /******************************************************************************* 2 *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved. 3 * 4 *Redistribution and use in source and binary forms, with or without modification, are permitted provided 5 *that the following conditions are met: 6 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the 7 *following disclaimer. 8 *2. Redistributions in binary form must reproduce the above copyright notice, 9 *this list of conditions and the following disclaimer in the documentation and/or other materials provided 10 *with the distribution. 11 * 12 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED 13 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 14 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 15 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 16 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 17 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 18 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 19 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE 20 21 ********************************************************************************/ 22 #include <sys/cdefs.h> 23 __FBSDID("$FreeBSD$"); 24 #include <dev/pms/config.h> 25 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> 29 30 #include <dev/pms/RefTisa/tisa/api/titypes.h> 31 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> 35 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> 39 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> 43 44 extern smRoot_t *gsmRoot; 45 46 /******************************** completion ***********************************************************/ 47 48 FORCEINLINE void 49 smllSATACompleted( 50 agsaRoot_t *agRoot, 51 agsaIORequest_t *agIORequest, 52 bit32 agIOStatus, 53 void *agFirstDword, 54 bit32 agIOInfoLen, 55 void *agParam 56 ) 57 { 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; 66 67 SM_DBG2(("smllSATACompleted: start\n")); 68 69 if (agIORequest == agNULL) 70 { 71 SM_DBG1(("smllSATACompleted: agIORequest is NULL!!!\n")); 72 return; 73 } 74 75 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 76 77 if (smIORequestBody == agNULL) 78 { 79 SM_DBG1(("smllSATACompleted: smIORequestBody is NULL!!!\n")); 80 return; 81 } 82 83 /* for debugging */ 84 if (smIORequestBody->ioCompleted == agTRUE) 85 { 86 smDeviceHandle = smIORequestBody->smDevHandle; 87 if (smDeviceHandle == agNULL) 88 { 89 SM_DBG1(("smllSATACompleted: smDeviceHandle is NULL!!!\n")); 90 return; 91 } 92 oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData; 93 SM_DBG1(("smllSATACompleted: Error!!!!!! double completion!!!, ID %d!!!\n", smIORequestBody->id)); 94 if (oneDeviceData == agNULL) 95 { 96 SM_DBG1(("smllSATACompleted: oneDeviceData is NULL!!!\n")); 97 return; 98 } 99 SM_DBG1(("smllSATACompleted: did %d!!!\n", oneDeviceData->id)); 100 return; 101 } 102 103 smIORequestBody->ioCompleted = agTRUE; 104 satIOContext = &(smIORequestBody->transport.SATA.satIOContext); 105 106 if (satIOContext == agNULL) 107 { 108 SM_DBG1(("smllSATACompleted: satIOContext is NULL!!!\n")); 109 return; 110 } 111 112 pSatDevData = satIOContext->pSatDevData; 113 114 if (pSatDevData == agNULL) 115 { 116 SM_DBG1(("smllSATACompleted: pSatDevData is NULL loc 1, wrong!!!\n")); 117 if (satIOContext->satIntIoContext == agNULL) 118 { 119 SM_DBG1(("smllSATACompleted: external command!!!\n")); 120 } 121 else 122 { 123 SM_DBG1(("smllSATACompleted: internal command!!!\n")); 124 } 125 return; 126 } 127 128 smDeviceHandle = smIORequestBody->smDevHandle; 129 130 if (smDeviceHandle == agNULL) 131 { 132 SM_DBG1(("smllSATACompleted: smDeviceHandle is NULL!!!!\n")); 133 return; 134 } 135 136 oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData; 137 138 if (oneDeviceData != pSatDevData) 139 { 140 SM_DBG1(("smllSATACompleted: diff device handle!!!\n")); 141 if (satIOContext->satIntIoContext == agNULL) 142 { 143 SM_DBG1(("smllSATACompleted: external command!!!\n")); 144 } 145 else 146 { 147 SM_DBG1(("smllSATACompleted: internal command!!!\n")); 148 } 149 return; 150 } 151 152 if (oneDeviceData == agNULL) 153 { 154 SM_DBG1(("smllSATACompleted: oneDeviceData is NULL!!!!\n")); 155 if (satIOContext->satIntIoContext == agNULL) 156 { 157 SM_DBG1(("smllSATACompleted: external command!!!\n")); 158 } 159 else 160 { 161 SM_DBG1(("smllSATACompleted: internal command!!!\n")); 162 } 163 return; 164 } 165 166 smRoot = oneDeviceData->smRoot; 167 168 /* release tag value for SATA */ 169 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 170 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 171 { 172 smsatTagRelease(smRoot, pSatDevData, satIOContext->sataTag); 173 SM_DBG3(("smllSATACompleted: ncq tag 0x%x\n",satIOContext->sataTag)); 174 } 175 176 /* just for debugging */ 177 if (agIOStatus == OSSA_IO_DS_NON_OPERATIONAL) 178 { 179 SM_DBG1(("smllSATACompleted: agIOStatus is OSSA_IO_DS_NON_OPERATIONAL!!!\n")); 180 } 181 if (agIOStatus == OSSA_IO_DS_IN_RECOVERY) 182 { 183 SM_DBG1(("smllSATACompleted: agIOStatus is OSSA_IO_DS_IN_RECOVERY!!!\n")); 184 } 185 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS) 186 { 187 SM_DBG1(("smllSATACompleted: agIOStatus is OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS!!!\n")); 188 } 189 190 satIOContext->satCompleteCB( agRoot, 191 agIORequest, 192 agIOStatus, 193 agFirstDword, 194 agIOInfoLen, 195 agParam, 196 satIOContext); 197 198 199 200 return; 201 } 202 /***************************************************************************** 203 *! \brief smsatPacketCB 204 * 205 * This routine is a callback function called from smllSATACompleted(). 206 * This CB routine deals with normal Packet command I/O SATA request. 207 * 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 213 * length. 214 * \param agParam: Additional info based on status. 215 * \param ioContext: Pointer to smSatIOContext_t. 216 * 217 * \return: none 218 * 219 *****************************************************************************/ 220 221 osGLOBAL void 222 smsatPacketCB( 223 agsaRoot_t *agRoot, 224 agsaIORequest_t *agIORequest, 225 bit32 agIOStatus, 226 agsaFisHeader_t *agFirstDword, 227 bit32 agIOInfoLen, 228 void *agParam, 229 void *ioContext 230 ) 231 { 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; 248 // bit32 ataError; 249 250 bit32 status = SM_RC_SUCCESS; 251 // agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 252 // bit32 dataLength; 253 bit8 bSenseKey = 0; 254 bit16 bSenseCodeInfo = 0; 255 256 SM_DBG3(("smsatPacketCB: start\n")); 257 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 258 satIOContext = (smSatIOContext_t *) ioContext; 259 if (satIOContext == agNULL) 260 { 261 SM_DBG1(("smsatPacketCB: satIOContext is NULL\n")); 262 return; 263 } 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; 270 271 if (satIntIo == agNULL) 272 { 273 SM_DBG5(("smsatPacketCB: External smSatInternalIo_t satIntIoContext\n")); 274 satOrgIOContext = satIOContext; 275 smOrgIORequest = smIORequestBody->smIORequest; 276 pSense = satIOContext->pSense; 277 scsiCmnd = satIOContext->pScsiCmnd; 278 } 279 else 280 { 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; 287 } 288 289 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 290 291 smIORequestBody->ioCompleted = agTRUE; 292 smIORequestBody->ioStarted = agFALSE; 293 294 /* interal structure free */ 295 smsatFreeIntIoResource( smRoot, oneDeviceData, satIntIo); 296 if( agIOStatus == OSSA_IO_SUCCESS && agIOInfoLen == 0 && agFirstDword == agNULL) 297 { 298 SM_DBG3(("smsatPacketCB: First, agIOStatus == OSSA_IO_SUCCESS, agFirstDword == agNULL, agIOInfoLen = %d\n", agIOInfoLen)); 299 tdsmIOCompletedCB(smRoot, 300 smOrgIORequest, 301 smIOSuccess, 302 SCSI_STAT_GOOD, 303 agNULL, 304 interruptContext); 305 } 306 else if (agIOStatus == OSSA_IO_SUCCESS && !(agIOInfoLen == 0 && agFirstDword == agNULL)) 307 { 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, 311 smOrgIORequest, 312 oneDeviceData, 313 SENSE_DATA_LENGTH, 314 satNewIntIo); 315 if (satNewIntIo == agNULL) 316 { 317 /* memory allocation failure */ 318 /* just translate the ATAPI error register to sense information */ 319 smsatTranslateATAPIErrorsToSCSIErrors( 320 scsiCmnd->cdb[0], 321 agFirstDword->D2H.status, 322 agFirstDword->D2H.error, 323 &bSenseKey, 324 &bSenseCodeInfo 325 ); 326 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 327 tdsmIOCompletedCB( smRoot, 328 smOrgIORequest, 329 smIOSuccess, 330 SCSI_STAT_CHECK_CONDITION, 331 satOrgIOContext->pSmSenseData, 332 interruptContext); 333 SM_DBG1(("smsatPacketCB: momory allocation fails\n")); 334 return; 335 } /* end memory allocation */ 336 337 satNewIOContext = smsatPrepareNewIO(satNewIntIo, 338 smOrgIORequest, 339 oneDeviceData, 340 scsiCmnd, 341 satOrgIOContext 342 ); 343 /* sends request sense to ATAPI device for acquiring sense information */ 344 status = smsatRequestSenseForATAPI(smRoot, 345 &satNewIntIo->satIntSmIORequest, 346 satNewIOContext->psmDeviceHandle, 347 &satNewIntIo->satIntSmScsiXchg, 348 satNewIOContext 349 ); 350 if (status != SM_RC_SUCCESS) 351 { 352 smsatFreeIntIoResource( smRoot, 353 oneDeviceData, 354 satNewIntIo); 355 /* just translate the ATAPI error register to sense information */ 356 smsatTranslateATAPIErrorsToSCSIErrors( 357 scsiCmnd->cdb[0], 358 agFirstDword->D2H.status, 359 agFirstDword->D2H.error, 360 &bSenseKey, 361 &bSenseCodeInfo 362 ); 363 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 364 tdsmIOCompletedCB(smRoot, 365 smOrgIORequest, 366 smIOSuccess, 367 SCSI_STAT_CHECK_CONDITION, 368 satOrgIOContext->pSmSenseData, 369 interruptContext); 370 SM_DBG1(("smsatPacketCB: failed to call satRequestSenseForATAPI()\n")); 371 } 372 } 373 else if (agIOStatus != OSSA_IO_SUCCESS ) 374 { 375 SM_DBG2(("smsatPacketCB: agIOStatus != OSSA_IO_SUCCESS, status %d\n", agIOStatus)); 376 smsatProcessAbnormalCompletion( 377 agRoot, 378 agIORequest, 379 agIOStatus, 380 agFirstDword, 381 agIOInfoLen, 382 agParam, 383 satIOContext); 384 } 385 else 386 { 387 SM_DBG1(("smsatPacketCB: Unknown error \n")); 388 tdsmIOCompletedCB(smRoot, 389 smOrgIORequest, 390 smIOFailed, 391 smDetailOtherError, 392 agNULL, 393 interruptContext); 394 } 395 } 396 /***************************************************************************** 397 *! \brief smsatRequestSenseForATAPICB 398 * 399 * This routine is a callback function called from smllSATACompleted(). 400 * This CB routine deals with normal non-chained data I/O SATA request. 401 * 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 407 * length. 408 * \param agParam: Additional info based on status. 409 * \param ioContext: Pointer to smSatIOContext_t. 410 * 411 * \return: none 412 * 413 *****************************************************************************/ 414 osGLOBAL void 415 smsatRequestSenseForATAPICB( 416 agsaRoot_t *agRoot, 417 agsaIORequest_t *agIORequest, 418 bit32 agIOStatus, 419 agsaFisHeader_t *agFirstDword, 420 bit32 agIOInfoLen, 421 void *agParam, 422 void *ioContext 423 ) 424 { 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; 437 bit8 dataLength; 438 smIniScsiCmnd_t *scsiCmnd; 439 smIORequest_t *smOrgIORequest; 440 441 SM_DBG3(("smsatRequestSenseForATAPICB: start\n")); 442 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 443 satIOContext = (smSatIOContext_t *) ioContext; 444 if (satIOContext == agNULL) 445 { 446 SM_DBG1(("smsatRequestSenseForATAPICB: satIOContext is NULL\n")); 447 return; 448 } 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) 456 { 457 SM_DBG5(("smsatRequestSenseForATAPICB: External smSatInternalIo_t satIntIoContext\n")); 458 satOrgIOContext = satIOContext; 459 smOrgIORequest = smIORequestBody->smIORequest; 460 scsiCmnd = satIOContext->pScsiCmnd; 461 } 462 else 463 { 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; 469 } 470 471 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 472 smIORequestBody->ioCompleted = agTRUE; 473 smIORequestBody->ioStarted = agFALSE; 474 if ( (agIOStatus == OSSA_IO_SUCCESS && agIOInfoLen == 0 && agFirstDword == agNULL)) 475 { 476 /* copy the request sense buffer to original IO buffer*/ 477 if (satIntIo) 478 { 479 sm_memcpy(satOrgIOContext->pSmSenseData->senseData, satIntIo->satIntDmaMem.virtPtr, SENSE_DATA_LENGTH); 480 } 481 satOrgIOContext->pSmSenseData->senseLen = SENSE_DATA_LENGTH; 482 /* interal structure free */ 483 smsatFreeIntIoResource( smRoot, oneDeviceData, satIntIo); 484 485 /* notify the OS to complete this SRB */ 486 tdsmIOCompletedCB( smRoot, 487 smOrgIORequest, 488 smIOSuccess, 489 SCSI_STAT_CHECK_CONDITION, 490 satOrgIOContext->pSmSenseData, 491 interruptContext); 492 } 493 else if (agIOStatus == OSSA_IO_UNDERFLOW ) 494 { 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); 498 if (satIntIo) 499 { 500 sm_memcpy(satOrgIOContext->pSmSenseData->senseData, satIntIo->satIntDmaMem.virtPtr, dataLength); 501 } 502 satOrgIOContext->pSmSenseData->senseLen = dataLength; 503 /* interal structure free */ 504 smsatFreeIntIoResource( smRoot, oneDeviceData, satIntIo); 505 506 /* notify the OS to complete this SRB */ 507 tdsmIOCompletedCB( smRoot, 508 smOrgIORequest, 509 smIOSuccess, 510 SCSI_STAT_CHECK_CONDITION, 511 satOrgIOContext->pSmSenseData, 512 interruptContext); 513 } 514 else 515 { 516 SM_DBG1(("smsatRequestSenseForATAPICB: failed, agIOStatus error = 0x%x agIOInfoLen = %d\n", agIOStatus, agIOInfoLen)); 517 /* interal structure free */ 518 smsatFreeIntIoResource( smRoot, oneDeviceData, satIntIo); 519 520 /* notify the OS to complete this SRB */ 521 tdsmIOCompletedCB( smRoot, 522 smOrgIORequest, 523 smIOFailed, 524 smDetailOtherError, 525 agNULL, 526 interruptContext); 527 } 528 SM_DBG3(("smsatRequestSenseForATAPICB: end\n")); 529 } 530 531 /***************************************************************************** 532 *! \brief smsatSetFeaturesPIOCB 533 * 534 * This routine is a callback function called from smllSATACompleted(). 535 * This CB routine deals with normal non-chained data I/O SATA request. 536 * 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 542 * length. 543 * \param agParam: Additional info based on status. 544 * \param ioContext: Pointer to smSatIOContext_t. 545 * 546 * \return: none 547 * 548 *****************************************************************************/ 549 osGLOBAL void 550 smsatSetFeaturesPIOCB( 551 agsaRoot_t *agRoot, 552 agsaIORequest_t *agIORequest, 553 bit32 agIOStatus, 554 agsaFisHeader_t *agFirstDword, 555 bit32 agIOInfoLen, 556 void *agParam, 557 void *ioContext 558 ) 559 { 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; 576 577 SM_DBG2(("smsatSetFeaturesPIOCB: start\n")); 578 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 579 satIOContext = (smSatIOContext_t *) ioContext; 580 if (satIOContext == agNULL) 581 { 582 SM_DBG1(("smsatSetFeaturesPIOCB: satIOContext is NULL\n")); 583 return; 584 } 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) 592 { 593 SM_DBG2(("smsatSetFeaturesPIOCB: External smSatInternalIo_t satIntIoContext\n")); 594 satOrgIOContext = satIOContext; 595 smOrgIORequest = smIORequestBody->smIORequest; 596 scsiCmnd = satIOContext->pScsiCmnd; 597 } 598 else 599 { 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; 605 } 606 smIORequest = smOrgIORequestBody->smIORequest; 607 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 608 smIORequestBody->ioCompleted = agTRUE; 609 smIORequestBody->ioStarted = agFALSE; 610 /* interal structure free */ 611 smsatFreeIntIoResource(smRoot, 612 oneDeviceData, 613 satIntIo); 614 if (smIORequest->tdData == smIORequest->smData) 615 { 616 SM_DBG1(("smsatSetFeaturesPIOCB: the same tdData and smData error!\n")); 617 } 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 626 ) 627 { 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)); 631 return; 632 } 633 /*if the ATAPI device support DMA, then enble this feature*/ 634 if (oneDeviceData->satDMASupport) 635 { 636 satNewIntIo = smsatAllocIntIoResource(smRoot, 637 smOrgIORequest, 638 oneDeviceData, 639 0, 640 satNewIntIo); 641 if (satNewIntIo == agNULL) 642 { 643 SM_DBG1(("smsatSetFeaturesPIOCB: memory allocation fails\n")); 644 /*Complete this identify packet device IO */ 645 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 646 return; 647 } /* end memory allocation */ 648 649 satNewIOContext = smsatPrepareNewIO(satNewIntIo, 650 smOrgIORequest, 651 oneDeviceData, 652 scsiCmnd, 653 satOrgIOContext 654 ); 655 /* sends another ATA SET FEATURES based on DMA bit */ 656 status = smsatSetFeaturesDMA(smRoot, 657 &satNewIntIo->satIntSmIORequest, 658 satNewIOContext->psmDeviceHandle, 659 &satNewIntIo->satIntSmScsiXchg, 660 satNewIOContext 661 ); 662 if (status != SM_RC_SUCCESS) 663 { 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)); 668 } 669 } 670 else 671 { 672 /*Complete this identify packet device IO */ 673 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 674 } 675 SM_DBG2(("smsatSetFeaturesPIOCB: exit, agIOStatus 0x%x\n", agIOStatus)); 676 } 677 678 /***************************************************************************** 679 *! \brief smsatDeviceResetCB 680 * 681 * This routine is a callback function called from smllSATACompleted(). 682 * This CB routine deals with normal non-chained data I/O SATA request. 683 * 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 689 * length. 690 * \param agParam: Additional info based on status. 691 * \param ioContext: Pointer to smSatIOContext_t. 692 * 693 * \return: none 694 * 695 *****************************************************************************/ 696 osGLOBAL void 697 smsatDeviceResetCB( 698 agsaRoot_t *agRoot, 699 agsaIORequest_t *agIORequest, 700 bit32 agIOStatus, 701 agsaFisHeader_t *agFirstDword, 702 bit32 agIOInfoLen, 703 void *agParam, 704 void *ioContext 705 ) 706 { 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; 719 bit32 ataStatus = 0; 720 bit32 ataError; 721 #endif 722 // bit32 status; 723 bit32 AbortTM = agFALSE; 724 smDeviceHandle_t *smDeviceHandle; 725 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) 736 { 737 SM_DBG6(("smsatDeviceResetCB: External, OS generated\n")); 738 satOrgIOContext = satIOContext; 739 } 740 else 741 { 742 SM_DBG6(("smsatDeviceResetCB: Internal, TD generated\n")); 743 satOrgIOContext = satIOContext->satOrgIOContext; 744 if (satOrgIOContext == agNULL) 745 { 746 SM_DBG6(("smsatDeviceResetCB: satOrgIOContext is NULL, wrong\n")); 747 return; 748 } 749 else 750 { 751 SM_DBG6(("smsatDeviceResetCB: satOrgIOContext is NOT NULL\n")); 752 } 753 } 754 smIORequestBody->ioCompleted = agTRUE; 755 smIORequestBody->ioStarted = agFALSE; 756 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 757 { 758 SM_DBG1(("smsatDeviceResetCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 759 /* TM completed */ 760 tdsmEventCB( smRoot, 761 smDeviceHandle, 762 smIntrEventTypeTaskManagement, 763 smTMFailed, 764 oneDeviceData->satTmTaskTag); 765 oneDeviceData->satTmTaskTag = agNULL; 766 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 767 smsatFreeIntIoResource( smRoot, 768 oneDeviceData, 769 satIntIo); 770 return; 771 } 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 781 ) 782 { 783 SM_DBG1(("smsatDeviceResetCB: OSSA_IO_OPEN_CNX_ERROR!!!\n")); 784 /* TM completed */ 785 tdsmEventCB( smRoot, 786 smDeviceHandle, 787 smIntrEventTypeTaskManagement, 788 smTMFailed, 789 oneDeviceData->satTmTaskTag); 790 oneDeviceData->satTmTaskTag = agNULL; 791 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 792 smsatFreeIntIoResource( smRoot, 793 oneDeviceData, 794 satIntIo); 795 return; 796 } 797 if (agIOStatus != OSSA_IO_SUCCESS) 798 { 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 */ 804 #endif 805 SM_DBG1(("smsatDeviceResetCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError)); 806 /* TM completed */ 807 tdsmEventCB( smRoot, 808 smDeviceHandle, 809 smIntrEventTypeTaskManagement, 810 smTMFailed, 811 oneDeviceData->satTmTaskTag); 812 oneDeviceData->satTmTaskTag = agNULL; 813 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 814 smsatFreeIntIoResource( smRoot, 815 oneDeviceData, 816 satIntIo); 817 return; 818 } 819 /*success */ 820 if (satOrgIOContext->TMF == AG_ABORT_TASK) 821 { 822 AbortTM = agTRUE; 823 } 824 if (AbortTM == agTRUE) 825 { 826 SM_DBG1(("smsatDeviceResetCB: calling satAbort!!!\n")); 827 smsatAbort(smRoot, agRoot, satOrgIOContext->satToBeAbortedIOContext); 828 } 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, 835 oneDeviceData, 836 satIntIo); 837 /* TM completed */ 838 tdsmEventCB( smRoot, 839 smDeviceHandle, 840 smIntrEventTypeTaskManagement, 841 smTMOK, 842 oneDeviceData->satTmTaskTag); 843 844 845 SM_DBG3(("smsatDeviceResetCB: return\n")); 846 } 847 848 849 /***************************************************************************** 850 *! \brief smsatExecuteDeviceDiagnosticCB 851 * 852 * This routine is a callback function called from smllSATACompleted(). 853 * This CB routine deals with normal non-chained data I/O SATA request. 854 * 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 860 * length. 861 * \param agParam: Additional info based on status. 862 * \param ioContext: Pointer to smSatIOContext_t. 863 * 864 * \return: none 865 * 866 *****************************************************************************/ 867 osGLOBAL void 868 smsatExecuteDeviceDiagnosticCB( 869 agsaRoot_t *agRoot, 870 agsaIORequest_t *agIORequest, 871 bit32 agIOStatus, 872 agsaFisHeader_t *agFirstDword, 873 bit32 agIOInfoLen, 874 void *agParam, 875 void *ioContext 876 ) 877 { 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; 888 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) 898 { 899 SM_DBG5(("smsatExecuteDeviceDiagnosticCB: External smSatInternalIo_t satIntIoContext\n")); 900 satOrgIOContext = satIOContext; 901 } 902 else 903 { 904 SM_DBG5(("smsatExecuteDeviceDiagnosticCB: Internal smSatInternalIo_t satIntIoContext\n")); 905 satOrgIOContext = satIOContext->satOrgIOContext; 906 if (satOrgIOContext == agNULL) 907 { 908 SM_DBG5(("smsatExecuteDeviceDiagnosticCB: satOrgIOContext is NULL\n")); 909 } 910 else 911 { 912 SM_DBG5(("smsatExecuteDeviceDiagnosticCB: satOrgIOContext is NOT NULL\n")); 913 } 914 } 915 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 916 smIORequestBody->ioCompleted = agTRUE; 917 smIORequestBody->ioStarted = agFALSE; 918 /* interal structure free */ 919 smsatFreeIntIoResource(smRoot,oneDeviceData, satIntIo); 920 } 921 922 GLOBAL void 923 smsatTranslateATAPIErrorsToSCSIErrors( 924 bit8 bCommand, 925 bit8 bATAStatus, 926 bit8 bATAError, 927 bit8 *pSenseKey, 928 bit16 *pSenseCodeInfo 929 ) 930 { 931 if (pSenseKey == agNULL || pSenseCodeInfo == agNULL) 932 { 933 SM_DBG1(("TranslateATAErrorsToSCSIErros: pSenseKey == agNULL || pSenseCodeInfo == agNULL\n")); 934 return; 935 } 936 if (bATAStatus & ERR_ATA_STATUS_MASK ) 937 { 938 if(bATAError & NM_ATA_ERROR_MASK) 939 { 940 *pSenseKey = SCSI_SNSKEY_NOT_READY; 941 *pSenseCodeInfo = 0x3a00; 942 } 943 else if(bATAError & ABRT_ATA_ERROR_MASK) 944 { 945 *pSenseKey = SCSI_SNSKEY_ABORTED_COMMAND; 946 *pSenseCodeInfo = 0; 947 } 948 else if(bATAError & MCR_ATA_ERROR_MASK) 949 { 950 *pSenseKey = SCSI_SNSKEY_UNIT_ATTENTION; 951 *pSenseCodeInfo = 0x5a01; 952 } 953 else if(bATAError & IDNF_ATA_ERROR_MASK) 954 { 955 *pSenseKey = SCSI_SNSKEY_MEDIUM_ERROR; 956 *pSenseCodeInfo = 0x1401; 957 } 958 else if(bATAError & MC_ATA_ERROR_MASK) 959 { 960 *pSenseKey = SCSI_SNSKEY_UNIT_ATTENTION; 961 *pSenseCodeInfo = 0x2800; 962 } 963 else if(bATAError & UNC_ATA_ERROR_MASK) 964 { 965 /*READ*/ 966 *pSenseKey = SCSI_SNSKEY_MEDIUM_ERROR; 967 *pSenseCodeInfo = 0x1100; 968 969 /*add WRITE here */ 970 } 971 else if(bATAError & ICRC_ATA_ERROR_MASK) 972 { 973 *pSenseKey = SCSI_SNSKEY_ABORTED_COMMAND; 974 *pSenseCodeInfo = 0x4703; 975 } 976 } 977 else if((bATAStatus & DF_ATA_STATUS_MASK)) 978 { 979 *pSenseKey = SCSI_SNSKEY_HARDWARE_ERROR; 980 *pSenseCodeInfo = 0x4400; 981 } 982 else 983 { 984 SM_DBG1(("unhandled ata error: bATAStatus = 0x%x, bATAError = 0x%x\n", bATAStatus, bATAError)); 985 } 986 } 987 988 GLOBAL void 989 smsatTranslateATAErrorsToSCSIErrors( 990 bit8 bATAStatus, 991 bit8 bATAError, 992 bit8 *pSenseKey, 993 bit16 *pSenseCodeInfo 994 ) 995 { 996 997 SM_DBG1(("TranslateATAErrorsToSCSIErros: bATAStatus=%d bATAError= %d \n",bATAStatus,bATAError)); 998 999 if (pSenseKey == agNULL || pSenseCodeInfo == agNULL) 1000 { 1001 SM_DBG1(("TranslateATAErrorsToSCSIErros: pSenseKey == agNULL || pSenseCodeInfo == agNULL\n")); 1002 return; 1003 } 1004 1005 if (bATAStatus & ERR_ATA_STATUS_MASK) 1006 { 1007 if(bATAError & NM_ATA_ERROR_MASK) 1008 { 1009 *pSenseKey = SCSI_SNSKEY_NOT_READY; 1010 *pSenseCodeInfo = SCSI_SNSCODE_MEDIUM_NOT_PRESENT; 1011 } 1012 else if(bATAError & UNC_ATA_ERROR_MASK) 1013 { 1014 *pSenseKey = SCSI_SNSKEY_MEDIUM_ERROR; 1015 *pSenseCodeInfo = SCSI_SNSCODE_UNRECOVERED_READ_ERROR; 1016 } 1017 else if(bATAError & IDNF_ATA_ERROR_MASK) 1018 { 1019 *pSenseKey = SCSI_SNSKEY_ILLEGAL_REQUEST; 1020 *pSenseCodeInfo = SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; 1021 } 1022 else if(bATAError & ABRT_ATA_ERROR_MASK) 1023 { 1024 *pSenseKey = SCSI_SNSKEY_ABORTED_COMMAND; 1025 *pSenseCodeInfo = SCSI_SNSCODE_NO_ADDITIONAL_INFO; 1026 } 1027 else if(bATAError & MC_ATA_ERROR_MASK) 1028 { 1029 *pSenseKey = SCSI_SNSKEY_UNIT_ATTENTION; 1030 *pSenseCodeInfo = SCSI_SNSCODE_NOT_READY_TO_READY_CHANGE; 1031 } 1032 else if(bATAError & MCR_ATA_ERROR_MASK) 1033 { 1034 *pSenseKey = SCSI_SNSKEY_UNIT_ATTENTION; 1035 *pSenseCodeInfo = SCSI_SNSCODE_OPERATOR_MEDIUM_REMOVAL_REQUEST; 1036 } 1037 else if(bATAError & ICRC_ATA_ERROR_MASK) 1038 { 1039 *pSenseKey = SCSI_SNSKEY_ABORTED_COMMAND; 1040 *pSenseCodeInfo = SCSI_SNSCODE_INFORMATION_UNIT_CRC_ERROR; 1041 } 1042 else 1043 { 1044 *pSenseKey = SCSI_SNSKEY_NO_SENSE; 1045 *pSenseCodeInfo = SCSI_SNSCODE_NO_ADDITIONAL_INFO; 1046 1047 } 1048 } 1049 else if (bATAStatus & DF_ATA_STATUS_MASK) /* INTERNAL TARGET FAILURE */ 1050 { 1051 *pSenseKey = SCSI_SNSKEY_HARDWARE_ERROR; 1052 *pSenseCodeInfo = SCSI_SNSCODE_INTERNAL_TARGET_FAILURE; 1053 } 1054 1055 1056 } 1057 1058 1059 FORCEINLINE void 1060 smsatNonChainedDataIOCB( 1061 agsaRoot_t *agRoot, 1062 agsaIORequest_t *agIORequest, 1063 bit32 agIOStatus, 1064 agsaFisHeader_t *agFirstDword, 1065 bit32 agIOInfoLen, 1066 void *agParam, 1067 void *ioContext 1068 ) 1069 { 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; 1078 1079 SM_DBG2(("smsatNonChainedDataIOCB: start\n")); 1080 1081 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1082 1083 smIORequestBody->ioCompleted = agTRUE; 1084 smIORequestBody->ioStarted = agFALSE; 1085 1086 /* interal structure free */ 1087 smsatFreeIntIoResource( smRoot, 1088 oneDeviceData, 1089 SatIntIo); 1090 1091 /* Process completion */ 1092 if( (agIOStatus == OSSA_IO_SUCCESS) && (agIOInfoLen == 0)) 1093 { 1094 SM_DBG5(("smsatNonChainedDataIOCB: success\n")); 1095 SM_DBG5(("smsatNonChainedDataIOCB: success agIORequest %p\n", agIORequest)); 1096 /* 1097 * Command was completed OK, this is the normal path. 1098 * Now call the OS-App Specific layer about this completion. 1099 */ 1100 tdsmIOCompletedCB( smRoot, 1101 smIORequestBody->smIORequest, 1102 smIOSuccess, 1103 SCSI_STAT_GOOD, 1104 agNULL, 1105 interruptContext); 1106 } 1107 else 1108 { 1109 SM_DBG1(("smsatNonChainedDataIOCB: calling smsatProcessAbnormalCompletion!!!\n")); 1110 /* More checking needed */ 1111 smsatProcessAbnormalCompletion( agRoot, 1112 agIORequest, 1113 agIOStatus, 1114 agFirstDword, 1115 agIOInfoLen, 1116 agParam, 1117 satIOContext); 1118 } 1119 1120 return; 1121 } 1122 1123 FORCEINLINE void 1124 smsatChainedDataIOCB( 1125 agsaRoot_t *agRoot, 1126 agsaIORequest_t *agIORequest, 1127 bit32 agIOStatus, 1128 agsaFisHeader_t *agFirstDword, 1129 bit32 agIOInfoLen, 1130 void *agParam, 1131 void *ioContext 1132 ) 1133 { 1134 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; 1154 bit32 dataLength; 1155 1156 SM_DBG6(("smsatChainedDataIOCB: start\n")); 1157 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 1158 satIOContext = (smSatIOContext_t *) ioContext; 1159 if (satIOContext == agNULL) 1160 { 1161 SM_DBG1(("smsatChainedDataIOCB: satIOContext is NULL\n")); 1162 return; 1163 } 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) 1171 { 1172 SM_DBG5(("smsatChainedDataIOCB: External smSatInternalIo_t satIntIoContext\n")); 1173 satOrgIOContext = satIOContext; 1174 smOrgIORequest = smIORequestBody->smIORequest; 1175 pSense = satIOContext->pSense; 1176 scsiCmnd = satIOContext->pScsiCmnd; 1177 } 1178 else 1179 { 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; 1186 } 1187 smIORequestBody->ioCompleted = agTRUE; 1188 smIORequestBody->ioStarted = agFALSE; 1189 1190 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 1191 { 1192 SM_DBG1(("smsatChainedDataIOCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 1193 smsatSetSensePayload( pSense, 1194 SCSI_SNSKEY_NO_SENSE, 1195 0, 1196 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1197 satOrgIOContext); 1198 1199 tdsmIOCompletedCB( smRoot, 1200 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1201 smIOSuccess, 1202 SCSI_STAT_CHECK_CONDITION, 1203 satOrgIOContext->pSmSenseData, 1204 satOrgIOContext->interruptContext ); 1205 1206 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1207 1208 smsatFreeIntIoResource( smRoot, 1209 oneDeviceData, 1210 satIntIo); 1211 return; 1212 } 1213 1214 /* 1215 checking IO status, FIS type and error status 1216 */ 1217 if (agIOStatus != OSSA_IO_SUCCESS) 1218 { 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 1223 */ 1224 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 1225 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 1226 /* for debugging */ 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) 1230 ) 1231 { 1232 SM_DBG1(("smsatChainedDataIOCB: FAILED, Wrong FIS type 0x%x!!!\n", statDevToHostFisHeader->fisType)); 1233 } 1234 1235 /* for debugging */ 1236 if ( (ataStatus & ERR_ATA_STATUS_MASK) || 1237 (ataStatus & DF_ATA_STATUS_MASK) 1238 ) 1239 { 1240 SM_DBG1(("smsatChainedDataIOCB: FAILED, error status and command 0x%x!!!\n", hostToDevFis->h.command)); 1241 } 1242 1243 /* the function below handles abort case */ 1244 smsatDelayedProcessAbnormalCompletion(agRoot, 1245 agIORequest, 1246 agIOStatus, 1247 agFirstDword, 1248 agIOInfoLen, 1249 agParam, 1250 satIOContext); 1251 1252 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1253 smsatFreeIntIoResource( smRoot, 1254 oneDeviceData, 1255 satIntIo); 1256 return; 1257 } /* end of error */ 1258 1259 switch (hostToDevFis->h.command) 1260 { 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: 1272 1273 SM_DBG5(("smsatChainedDataIOCB: READ/WRITE success case\n")); 1274 1275 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1276 1277 /* done with internally genereated SAT_SMART_RETURN_STATUS */ 1278 smsatFreeIntIoResource( smRoot, 1279 oneDeviceData, 1280 satIntIo); 1281 /* let's loop till TL */ 1282 1283 /* lba = lba + tl 1284 loopnum--; 1285 if (loopnum == 0) done 1286 */ 1287 (satOrgIOContext->LoopNum)--; 1288 if (satOrgIOContext->LoopNum == 0) 1289 { 1290 /* done with read */ 1291 tdsmIOCompletedCB( smRoot, 1292 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1293 smIOSuccess, 1294 SCSI_STAT_GOOD, 1295 agNULL, 1296 satOrgIOContext->interruptContext ); 1297 return; 1298 } 1299 1300 /* don't need to allocate payload memory here. Use the one allocated by OS layer */ 1301 dataLength = 0; 1302 1303 satNewIntIo = smsatAllocIntIoResource( smRoot, 1304 smOrgIORequest, 1305 oneDeviceData, 1306 dataLength, 1307 satNewIntIo); 1308 if (satNewIntIo == agNULL) 1309 { 1310 tdsmIOCompletedCB( smRoot, 1311 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1312 smIOFailed, 1313 smDetailOtherError, 1314 agNULL, 1315 satOrgIOContext->interruptContext ); 1316 1317 SM_DBG1(("smsatChainedDataIOCB: momory allocation fails!!!\n")); 1318 return; 1319 } /* end of memory allocation failure */ 1320 1321 /* 1322 * Need to initialize all the fields within satIOContext 1323 */ 1324 1325 satNewIOContext = smsatPrepareNewIO( 1326 satNewIntIo, 1327 smOrgIORequest, 1328 oneDeviceData, 1329 scsiCmnd, 1330 satOrgIOContext 1331 ); 1332 1333 /* sending another ATA command */ 1334 switch (scsiCmnd->cdb[0]) 1335 { 1336 case SCSIOPC_READ_6: 1337 /* no loop should occur with READ6 since it fits in one ATA command */ 1338 break; 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, 1346 satNewIOContext); 1347 break; 1348 case SCSIOPC_WRITE_6: 1349 /* no loop should occur with WRITE6 since it fits in one ATA command */ 1350 break; 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, 1358 satNewIOContext); 1359 break; 1360 default: 1361 SM_DBG1(("smsatChainedDataIOCB: success but default case scsi cmd 0x%x ata cmd 0x%x!!!\n",scsiCmnd->cdb[0], hostToDevFis->h.command)); 1362 status = tiError; 1363 break; 1364 } 1365 1366 1367 1368 if (status != SM_RC_SUCCESS) 1369 { 1370 smsatFreeIntIoResource( smRoot, 1371 oneDeviceData, 1372 satNewIntIo); 1373 tdsmIOCompletedCB( smRoot, 1374 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1375 smIOFailed, 1376 smDetailOtherError, 1377 agNULL, 1378 satOrgIOContext->interruptContext ); 1379 SM_DBG1(("smsatChainedDataIOCB: calling satRead10_1 fails!!!\n")); 1380 return; 1381 } 1382 1383 break; 1384 1385 1386 default: 1387 SM_DBG1(("smsatChainedDataIOCB: success but default case command 0x%x!!!\n",hostToDevFis->h.command)); 1388 tdsmIOCompletedCB( smRoot, 1389 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1390 smIOFailed, 1391 smDetailOtherError, 1392 agNULL, 1393 satOrgIOContext->interruptContext ); 1394 1395 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1396 1397 smsatFreeIntIoResource( smRoot, 1398 oneDeviceData, 1399 satIntIo); 1400 1401 break; 1402 } 1403 1404 1405 return; 1406 } 1407 1408 osGLOBAL void 1409 smsatNonChainedVerifyCB( 1410 agsaRoot_t *agRoot, 1411 agsaIORequest_t *agIORequest, 1412 bit32 agIOStatus, 1413 agsaFisHeader_t *agFirstDword, 1414 bit32 agIOInfoLen, 1415 agsaFrameHandle_t agFrameHandle, 1416 void *ioContext 1417 ) 1418 { 1419 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; 1439 1440 SM_DBG2(("smsatNonChainedVerifyCB: start\n")); 1441 SM_DBG5(("smsatNonChainedVerifyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 1442 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) 1453 { 1454 SM_DBG4(("smsatNonChainedVerifyCB: External smSatInternalIo_t satIntIoContext\n")); 1455 satOrgIOContext = satIOContext; 1456 smOrgIORequest = smIORequestBody->smIORequest; 1457 pSense = satIOContext->pSense; 1458 } 1459 else 1460 { 1461 SM_DBG4(("smsatNonChainedVerifyCB: Internal smSatInternalIo_t satIntIoContext\n")); 1462 satOrgIOContext = satIOContext->satOrgIOContext; 1463 if (satOrgIOContext == agNULL) 1464 { 1465 SM_DBG4(("smsatNonChainedVerifyCB: satOrgIOContext is NULL, wrong\n")); 1466 return; 1467 } 1468 else 1469 { 1470 SM_DBG4(("smsatNonChainedVerifyCB: satOrgIOContext is NOT NULL\n")); 1471 } 1472 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 1473 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 1474 pSense = satOrgIOContext->pSense; 1475 } 1476 1477 smIORequestBody->ioCompleted = agTRUE; 1478 smIORequestBody->ioStarted = agFALSE; 1479 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 1480 { 1481 SM_DBG1(("smsatNonChainedVerifyCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 1482 smsatSetSensePayload( pSense, 1483 SCSI_SNSKEY_NO_SENSE, 1484 0, 1485 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1486 satOrgIOContext); 1487 tdsmIOCompletedCB( smRoot, 1488 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1489 smIOSuccess, 1490 SCSI_STAT_CHECK_CONDITION, 1491 satOrgIOContext->pSmSenseData, 1492 satOrgIOContext->interruptContext ); 1493 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1494 1495 smsatFreeIntIoResource( smRoot, 1496 oneDeviceData, 1497 satIntIo); 1498 return; 1499 } 1500 if (agIOStatus != OSSA_IO_SUCCESS) 1501 { 1502 /* only agsaFisRegDeviceToHost_t is expected */ 1503 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 1504 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 1505 } 1506 1507 if( agIOStatus != OSSA_IO_SUCCESS) 1508 { 1509 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 1510 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 1511 ) 1512 { 1513 /* for debugging */ 1514 if( agIOStatus != OSSA_IO_SUCCESS) 1515 { 1516 SM_DBG1(("smsatNonChainedVerifyCB: FAILED, NOT IO_SUCCESS!!!\n")); 1517 } 1518 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 1519 { 1520 SM_DBG1(("smsatNonChainedVerifyCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 1521 } 1522 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 1523 (ataStatus & DF_ATA_STATUS_MASK) 1524 ) 1525 { 1526 SM_DBG1(("smsatNonChainedVerifyCB: FAILED, FAILED, error status!!!\n")); 1527 } 1528 1529 /* Process abort case */ 1530 if (agIOStatus == OSSA_IO_ABORTED) 1531 { 1532 smsatProcessAbort(smRoot, 1533 smOrgIORequest, 1534 satOrgIOContext 1535 ); 1536 1537 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1538 1539 smsatFreeIntIoResource( smRoot, 1540 oneDeviceData, 1541 satIntIo); 1542 return; 1543 } 1544 1545 /* for debugging */ 1546 switch (hostToDevFis->h.command) 1547 { 1548 case SAT_READ_VERIFY_SECTORS: 1549 SM_DBG1(("smsatNonChainedVerifyCB: SAT_READ_VERIFY_SECTORS!!!\n")); 1550 break; 1551 case SAT_READ_VERIFY_SECTORS_EXT: 1552 SM_DBG1(("smsatNonChainedVerifyCB: SAT_READ_VERIFY_SECTORS_EXT!!!\n")); 1553 break; 1554 default: 1555 SM_DBG1(("smsatNonChainedVerifyCB: error default case command 0x%x!!!\n", hostToDevFis->h.command)); 1556 break; 1557 } 1558 1559 smsatSetSensePayload( pSense, 1560 SCSI_SNSKEY_NO_SENSE, 1561 0, 1562 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1563 satOrgIOContext); 1564 1565 tdsmIOCompletedCB( smRoot, 1566 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1567 smIOSuccess, 1568 SCSI_STAT_CHECK_CONDITION, 1569 satOrgIOContext->pSmSenseData, 1570 satOrgIOContext->interruptContext ); 1571 1572 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1573 1574 smsatFreeIntIoResource( smRoot, 1575 oneDeviceData, 1576 satIntIo); 1577 return; 1578 } /* end error checking */ 1579 } 1580 1581 /* process success from this point on */ 1582 switch (hostToDevFis->h.command) 1583 { 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")); 1587 1588 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1589 1590 smsatFreeIntIoResource( smRoot, 1591 oneDeviceData, 1592 satIntIo); 1593 1594 tdsmIOCompletedCB( smRoot, 1595 smOrgIORequest, 1596 smIOSuccess, 1597 SCSI_STAT_GOOD, 1598 agNULL, 1599 satOrgIOContext->interruptContext); 1600 break; 1601 default: 1602 SM_DBG1(("smsatNonChainedVerifyCB: success but error default case command 0x%x!!!\n", hostToDevFis->h.command)); 1603 1604 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1605 1606 smsatFreeIntIoResource( smRoot, 1607 oneDeviceData, 1608 satIntIo); 1609 1610 smsatSetSensePayload( pSense, 1611 SCSI_SNSKEY_NO_SENSE, 1612 0, 1613 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1614 satOrgIOContext); 1615 1616 tdsmIOCompletedCB( smRoot, 1617 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1618 smIOSuccess, 1619 SCSI_STAT_CHECK_CONDITION, 1620 satOrgIOContext->pSmSenseData, 1621 satOrgIOContext->interruptContext ); 1622 1623 break; 1624 } 1625 1626 return; 1627 } 1628 1629 osGLOBAL void 1630 smsatChainedVerifyCB( 1631 agsaRoot_t *agRoot, 1632 agsaIORequest_t *agIORequest, 1633 bit32 agIOStatus, 1634 agsaFisHeader_t *agFirstDword, 1635 bit32 agIOInfoLen, 1636 agsaFrameHandle_t agFrameHandle, 1637 void *ioContext 1638 ) 1639 { 1640 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; 1659 bit32 dataLength; 1660 1661 SM_DBG2(("smsatChainedVerifyCB: start\n")); 1662 SM_DBG5(("smsatChainedVerifyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 1663 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; 1673 1674 if (satIntIo == agNULL) 1675 { 1676 SM_DBG4(("smsatChainedVerifyCB: External smSatInternalIo_t satIntIoContext\n")); 1677 satOrgIOContext = satIOContext; 1678 smOrgIORequest = smIORequestBody->smIORequest; 1679 pSense = satIOContext->pSense; 1680 scsiCmnd = satIOContext->pScsiCmnd; 1681 } 1682 else 1683 { 1684 SM_DBG4(("smsatChainedVerifyCB: Internal smSatInternalIo_t satIntIoContext\n")); 1685 satOrgIOContext = satIOContext->satOrgIOContext; 1686 if (satOrgIOContext == agNULL) 1687 { 1688 SM_DBG4(("smsatChainedVerifyCB: satOrgIOContext is NULL, wrong\n")); 1689 return; 1690 } 1691 else 1692 { 1693 SM_DBG4(("smsatChainedVerifyCB: satOrgIOContext is NOT NULL\n")); 1694 } 1695 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 1696 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 1697 pSense = satOrgIOContext->pSense; 1698 scsiCmnd = satOrgIOContext->pScsiCmnd; 1699 } 1700 1701 smIORequestBody->ioCompleted = agTRUE; 1702 smIORequestBody->ioStarted = agFALSE; 1703 1704 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 1705 { 1706 SM_DBG1(("smsatChainedVerifyCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 1707 smsatSetSensePayload( pSense, 1708 SCSI_SNSKEY_NO_SENSE, 1709 0, 1710 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1711 satOrgIOContext); 1712 1713 tdsmIOCompletedCB( smRoot, 1714 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1715 smIOSuccess, 1716 SCSI_STAT_CHECK_CONDITION, 1717 satOrgIOContext->pSmSenseData, 1718 satOrgIOContext->interruptContext ); 1719 1720 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1721 1722 smsatFreeIntIoResource( smRoot, 1723 oneDeviceData, 1724 satIntIo); 1725 return; 1726 } 1727 1728 if (agIOStatus != OSSA_IO_SUCCESS) 1729 { 1730 /* only agsaFisRegDeviceToHost_t is expected */ 1731 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 1732 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 1733 } 1734 1735 if( agIOStatus != OSSA_IO_SUCCESS) 1736 { 1737 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 1738 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 1739 ) 1740 { 1741 /* for debugging */ 1742 if( agIOStatus != OSSA_IO_SUCCESS) 1743 { 1744 SM_DBG1(("smsatChainedVerifyCB: FAILED, NOT IO_SUCCESS!!!\n")); 1745 } 1746 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 1747 { 1748 SM_DBG1(("smsatChainedVerifyCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 1749 } 1750 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 1751 (ataStatus & DF_ATA_STATUS_MASK) 1752 ) 1753 { 1754 SM_DBG1(("smsatChainedVerifyCB: FAILED, FAILED, error status!!!\n")); 1755 } 1756 1757 /* Process abort case */ 1758 if (agIOStatus == OSSA_IO_ABORTED) 1759 { 1760 smsatProcessAbort(smRoot, 1761 smOrgIORequest, 1762 satOrgIOContext 1763 ); 1764 1765 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1766 1767 smsatFreeIntIoResource( smRoot, 1768 oneDeviceData, 1769 satIntIo); 1770 return; 1771 } 1772 1773 /* for debugging */ 1774 switch (hostToDevFis->h.command) 1775 { 1776 case SAT_READ_VERIFY_SECTORS: 1777 SM_DBG1(("smsatChainedVerifyCB: SAT_READ_VERIFY_SECTORS!!!\n")); 1778 break; 1779 case SAT_READ_VERIFY_SECTORS_EXT: 1780 SM_DBG1(("smsatChainedVerifyCB: SAT_READ_VERIFY_SECTORS_EXT!!!\n")); 1781 break; 1782 default: 1783 SM_DBG1(("smsatChainedVerifyCB: error default case command 0x%x!!!\n", hostToDevFis->h.command)); 1784 break; 1785 } 1786 1787 smsatSetSensePayload( pSense, 1788 SCSI_SNSKEY_NO_SENSE, 1789 0, 1790 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1791 satOrgIOContext); 1792 1793 tdsmIOCompletedCB( smRoot, 1794 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1795 smIOSuccess, 1796 SCSI_STAT_CHECK_CONDITION, 1797 satOrgIOContext->pSmSenseData, 1798 satOrgIOContext->interruptContext ); 1799 1800 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1801 1802 smsatFreeIntIoResource( smRoot, 1803 oneDeviceData, 1804 satIntIo); 1805 return; 1806 } /* end error checking */ 1807 } 1808 1809 /* process success from this point on */ 1810 switch (hostToDevFis->h.command) 1811 { 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")); 1815 1816 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1817 1818 smsatFreeIntIoResource( smRoot, 1819 oneDeviceData, 1820 satIntIo); 1821 1822 /* let's loop till TL */ 1823 1824 /* lba = lba + tl 1825 loopnum--; 1826 if (loopnum == 0) done 1827 */ 1828 (satOrgIOContext->LoopNum)--; 1829 if (satOrgIOContext->LoopNum == 0) 1830 { 1831 /* 1832 done with write and verify 1833 */ 1834 tdsmIOCompletedCB( smRoot, 1835 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1836 smIOSuccess, 1837 SCSI_STAT_GOOD, 1838 agNULL, 1839 satOrgIOContext->interruptContext ); 1840 return; 1841 } 1842 1843 if (satOrgIOContext->superIOFlag) 1844 { 1845 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength; 1846 } 1847 else 1848 { 1849 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength; 1850 } 1851 1852 satNewIntIo = smsatAllocIntIoResource( smRoot, 1853 smOrgIORequest, 1854 oneDeviceData, 1855 dataLength, 1856 satNewIntIo); 1857 if (satNewIntIo == agNULL) 1858 { 1859 tdsmIOCompletedCB( smRoot, 1860 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1861 smIOFailed, 1862 smDetailOtherError, 1863 agNULL, 1864 satOrgIOContext->interruptContext ); 1865 1866 SM_DBG1(("smsatChainedVerifyCB: momory allocation fails!!!\n")); 1867 return; 1868 } /* end of memory allocation failure */ 1869 1870 /* 1871 * Need to initialize all the fields within satIOContext 1872 */ 1873 1874 satNewIOContext = smsatPrepareNewIO( 1875 satNewIntIo, 1876 smOrgIORequest, 1877 oneDeviceData, 1878 scsiCmnd, 1879 satOrgIOContext 1880 ); 1881 status = smsatChainedVerify(smRoot, 1882 &satNewIntIo->satIntSmIORequest, 1883 satNewIOContext->psmDeviceHandle, 1884 &satNewIntIo->satIntSmScsiXchg, 1885 satNewIOContext); 1886 1887 if (status != SM_RC_SUCCESS) 1888 { 1889 smsatFreeIntIoResource( smRoot, 1890 oneDeviceData, 1891 satNewIntIo); 1892 tdsmIOCompletedCB( smRoot, 1893 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1894 smIOFailed, 1895 smDetailOtherError, 1896 agNULL, 1897 satOrgIOContext->interruptContext ); 1898 SM_DBG1(("smsatChainedVerifyCB: calling satChainedVerify fails!!!\n")); 1899 return; 1900 } 1901 1902 break; 1903 default: 1904 SM_DBG1(("smsatChainedVerifyCB: success but error default case command 0x%x!!!\n", hostToDevFis->h.command)); 1905 1906 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 1907 1908 smsatFreeIntIoResource( smRoot, 1909 oneDeviceData, 1910 satIntIo); 1911 1912 smsatSetSensePayload( pSense, 1913 SCSI_SNSKEY_NO_SENSE, 1914 0, 1915 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1916 satOrgIOContext); 1917 1918 tdsmIOCompletedCB( smRoot, 1919 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 1920 smIOSuccess, 1921 SCSI_STAT_CHECK_CONDITION, 1922 satOrgIOContext->pSmSenseData, 1923 satOrgIOContext->interruptContext ); 1924 1925 break; 1926 } 1927 return; 1928 } 1929 1930 1931 osGLOBAL void 1932 smsatTestUnitReadyCB( 1933 agsaRoot_t *agRoot, 1934 agsaIORequest_t *agIORequest, 1935 bit32 agIOStatus, 1936 agsaFisHeader_t *agFirstDword, 1937 bit32 agIOInfoLen, 1938 agsaFrameHandle_t agFrameHandle, 1939 void *ioContext 1940 ) 1941 { 1942 /* 1943 In the process of TestUnitReady 1944 Process SAT_GET_MEDIA_STATUS 1945 Process SAT_CHECK_POWER_MODE 1946 */ 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; 1963 1964 smScsiRspSense_t *pSense; 1965 smIniScsiCmnd_t *scsiCmnd; 1966 smIORequest_t *smOrgIORequest; 1967 1968 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 1969 bit32 ataStatus = 0; 1970 bit32 ataError; 1971 1972 bit32 status; 1973 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 1974 1975 SM_DBG2(("smsatTestUnitReadyCB: start\n")); 1976 SM_DBG6(("smsatTestUnitReadyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 1977 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; 1987 1988 if (satIntIo == agNULL) 1989 { 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; 1995 } 1996 else 1997 { 1998 SM_DBG5(("smsatTestUnitReadyCB: yes internal smSatInternalIo_t satIntIoContext\n")); 1999 2000 /* orginal smIOContext */ 2001 smOrgIORequest = (smIORequest_t *)satIOContext->satIntIoContext->satOrgSmIORequest; 2002 smOrgIORequestBody = (smIORequestBody_t *)smOrgIORequest->tdData; 2003 satOrgIOContext = &(smOrgIORequestBody->transport.SATA.satIOContext); 2004 2005 pSense = satOrgIOContext->pSense; 2006 scsiCmnd = satOrgIOContext->pScsiCmnd; 2007 } 2008 2009 smIORequestBody->ioCompleted = agTRUE; 2010 smIORequestBody->ioStarted = agFALSE; 2011 2012 if (agIOStatus == OSSA_IO_ABORTED) 2013 { 2014 tdsmIOCompletedCB( smRoot, 2015 smOrgIORequest, 2016 smIOFailed, 2017 smDetailAborted, 2018 agNULL, 2019 satIOContext->interruptContext); 2020 2021 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2022 2023 smsatFreeIntIoResource( smRoot, 2024 oneDeviceData, 2025 satIntIo); 2026 2027 return; 2028 } 2029 2030 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 2031 { 2032 SM_DBG1(("smsatTestUnitReadyCB: agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 2033 smsatSetSensePayload( pSense, 2034 SCSI_SNSKEY_NOT_READY, 2035 0, 2036 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 2037 satOrgIOContext); 2038 2039 tdsmIOCompletedCB( smRoot, 2040 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2041 smIOSuccess, 2042 SCSI_STAT_CHECK_CONDITION, 2043 satOrgIOContext->pSmSenseData, 2044 satOrgIOContext->interruptContext ); 2045 2046 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2047 2048 smsatFreeIntIoResource( smRoot, 2049 oneDeviceData, 2050 satIntIo); 2051 2052 return; 2053 } 2054 /* 2055 HW checks an error for us and the results is agIOStatus 2056 */ 2057 if (agIOStatus != OSSA_IO_SUCCESS) 2058 { 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) 2064 { 2065 SM_DBG1(("smsatTestUnitReadyCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 2066 } 2067 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 2068 (ataStatus & DF_ATA_STATUS_MASK) 2069 ) 2070 { 2071 SM_DBG1(("smsatTestUnitReadyCB: FAILED, FAILED, error status!!!\n")); 2072 } 2073 2074 /* Process abort case */ 2075 if (agIOStatus == OSSA_IO_ABORTED) 2076 { 2077 smsatProcessAbort(smRoot, 2078 smOrgIORequest, 2079 satOrgIOContext 2080 ); 2081 2082 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2083 2084 smsatFreeIntIoResource( smRoot, 2085 oneDeviceData, 2086 satIntIo); 2087 return; 2088 } 2089 2090 switch (hostToDevFis->h.command) 2091 { 2092 case SAT_GET_MEDIA_STATUS: 2093 SM_DBG1(("smsatTestUnitReadyCB: SAT_GET_MEDIA_STATUS failed!!! \n")); 2094 2095 /* checking NM bit */ 2096 if (ataError & SCSI_NM_MASK) 2097 { 2098 smsatSetSensePayload( pSense, 2099 SCSI_SNSKEY_NOT_READY, 2100 0, 2101 SCSI_SNSCODE_MEDIUM_NOT_PRESENT, 2102 satOrgIOContext); 2103 } 2104 else 2105 { 2106 smsatSetSensePayload( pSense, 2107 SCSI_SNSKEY_NOT_READY, 2108 0, 2109 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 2110 satOrgIOContext); 2111 } 2112 2113 tdsmIOCompletedCB( smRoot, 2114 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2115 smIOSuccess, 2116 SCSI_STAT_CHECK_CONDITION, 2117 satOrgIOContext->pSmSenseData, 2118 satOrgIOContext->interruptContext ); 2119 2120 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2121 2122 smsatFreeIntIoResource( smRoot, 2123 oneDeviceData, 2124 satIntIo); 2125 break; 2126 case SAT_CHECK_POWER_MODE: 2127 SM_DBG1(("smsatTestUnitReadyCB: SAT_CHECK_POWER_MODE failed!!! \n")); 2128 smsatSetSensePayload( pSense, 2129 SCSI_SNSKEY_NOT_READY, 2130 0, 2131 SCSI_SNSCODE_LOGICAL_UNIT_DOES_NOT_RESPOND_TO_SELECTION, 2132 satOrgIOContext); 2133 2134 tdsmIOCompletedCB( smRoot, 2135 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2136 smIOSuccess, 2137 SCSI_STAT_CHECK_CONDITION, 2138 satOrgIOContext->pSmSenseData, 2139 satOrgIOContext->interruptContext ); 2140 2141 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2142 2143 smsatFreeIntIoResource( smRoot, 2144 oneDeviceData, 2145 satIntIo); 2146 break; 2147 default: 2148 SM_DBG1(("smsatTestUnitReadyCB: default failed command %d!!!\n", hostToDevFis->h.command)); 2149 2150 smsatSetSensePayload( pSense, 2151 SCSI_SNSKEY_NOT_READY, 2152 0, 2153 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 2154 satOrgIOContext); 2155 2156 tdsmIOCompletedCB( smRoot, 2157 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2158 smIOSuccess, 2159 SCSI_STAT_CHECK_CONDITION, 2160 satOrgIOContext->pSmSenseData, 2161 satOrgIOContext->interruptContext ); 2162 2163 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2164 2165 smsatFreeIntIoResource( smRoot, 2166 oneDeviceData, 2167 satIntIo); 2168 break; 2169 2170 } 2171 return; 2172 }/* end error */ 2173 2174 /* ATA command completes sucessfully */ 2175 switch (hostToDevFis->h.command) 2176 { 2177 case SAT_GET_MEDIA_STATUS: 2178 2179 SM_DBG5(("smsatTestUnitReadyCB: SAT_GET_MEDIA_STATUS success\n")); 2180 2181 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2182 2183 smsatFreeIntIoResource( smRoot, 2184 oneDeviceData, 2185 satIntIo); 2186 2187 satNewIntIo = smsatAllocIntIoResource( smRoot, 2188 smOrgIORequest, 2189 oneDeviceData, 2190 0, 2191 satNewIntIo); 2192 if (satNewIntIo == agNULL) 2193 { 2194 smsatSetSensePayload( pSense, 2195 SCSI_SNSKEY_NOT_READY, 2196 0, 2197 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 2198 satOrgIOContext); 2199 2200 tdsmIOCompletedCB( smRoot, 2201 smOrgIORequest, 2202 smIOSuccess, 2203 SCSI_STAT_CHECK_CONDITION, 2204 satOrgIOContext->pSmSenseData, 2205 satOrgIOContext->interruptContext ); 2206 2207 SM_DBG1(("smsatTestUnitReadyCB: momory allocation fails!!!\n")); 2208 return; 2209 } 2210 2211 /* 2212 * Need to initialize all the fields within satIOContext 2213 */ 2214 2215 satNewIOContext = smsatPrepareNewIO( 2216 satNewIntIo, 2217 smOrgIORequest, 2218 oneDeviceData, 2219 scsiCmnd, 2220 satOrgIOContext 2221 ); 2222 2223 /* sends SAT_CHECK_POWER_MODE */ 2224 status = smsatTestUnitReady_1( smRoot, 2225 &satNewIntIo->satIntSmIORequest, 2226 satNewIOContext->psmDeviceHandle, 2227 &satNewIntIo->satIntSmScsiXchg, 2228 satNewIOContext); 2229 2230 if (status != SM_RC_SUCCESS) 2231 { 2232 /* sending SAT_CHECK_POWER_MODE fails */ 2233 smsatFreeIntIoResource( smRoot, 2234 oneDeviceData, 2235 satNewIntIo); 2236 smsatSetSensePayload( pSense, 2237 SCSI_SNSKEY_NOT_READY, 2238 0, 2239 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 2240 satOrgIOContext); 2241 2242 tdsmIOCompletedCB( smRoot, 2243 smOrgIORequest, 2244 smIOSuccess, 2245 SCSI_STAT_CHECK_CONDITION, 2246 satOrgIOContext->pSmSenseData, 2247 satOrgIOContext->interruptContext ); 2248 2249 SM_DBG1(("smsatTestUnitReadyCB: calling satTestUnitReady_1 fails!!!\n")); 2250 return; 2251 } 2252 2253 break; 2254 case SAT_CHECK_POWER_MODE: 2255 SM_DBG5(("smsatTestUnitReadyCB: SAT_CHECK_POWER_MODE success\n")); 2256 2257 2258 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2259 2260 smsatFreeIntIoResource( smRoot, 2261 oneDeviceData, 2262 satIntIo); 2263 2264 /* returns good status */ 2265 tdsmIOCompletedCB( smRoot, 2266 smOrgIORequest, 2267 smIOSuccess, 2268 SCSI_STAT_GOOD, 2269 agNULL, 2270 satOrgIOContext->interruptContext ); 2271 2272 break; 2273 default: 2274 SM_DBG1(("smsatTestUnitReadyCB: default success command %d!!!\n", hostToDevFis->h.command)); 2275 smsatSetSensePayload( pSense, 2276 SCSI_SNSKEY_NOT_READY, 2277 0, 2278 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 2279 satOrgIOContext); 2280 2281 tdsmIOCompletedCB( smRoot, 2282 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2283 smIOSuccess, 2284 SCSI_STAT_CHECK_CONDITION, 2285 satOrgIOContext->pSmSenseData, 2286 satOrgIOContext->interruptContext ); 2287 2288 2289 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2290 2291 smsatFreeIntIoResource( smRoot, 2292 oneDeviceData, 2293 satIntIo); 2294 break; 2295 } 2296 2297 return; 2298 } 2299 2300 osGLOBAL void 2301 smsatRequestSenseCB( 2302 agsaRoot_t *agRoot, 2303 agsaIORequest_t *agIORequest, 2304 bit32 agIOStatus, 2305 agsaFisHeader_t *agFirstDword, 2306 bit32 agIOInfoLen, 2307 void *agParam, 2308 void *ioContext 2309 ) 2310 { 2311 /* ATA Vol 1, p299 SAT_SMART_RETURN_STATUS */ 2312 /* 2313 if threshold exceeds, return SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE 2314 else call satRequestSense_1 to send CHECK_POWER_MODE 2315 */ 2316 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; 2338 bit32 status; 2339 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 2340 agsaFisRegD2HData_t statDevToHostFisData; 2341 bit32 allocationLen = 0; 2342 bit32 dataLength; 2343 bit8 *pDataBuffer = agNULL; 2344 2345 SM_DBG2(("smsatRequestSenseCB: start\n")); 2346 SM_DBG4(("smsatRequestSenseCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 2347 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; 2357 2358 /*ttttttthe one */ 2359 if (satIntIo == agNULL) 2360 { 2361 SM_DBG4(("smsatRequestSenseCB: External smSatInternalIo_t satIntIoContext\n")); 2362 satOrgIOContext = satIOContext; 2363 smOrgIORequest = smIORequestBody->smIORequest; 2364 if (satOrgIOContext->superIOFlag) 2365 { 2366 pDataBuffer = (bit8 *)(((tiSuperScsiInitiatorRequest_t *)satOrgIOContext->smScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense; 2367 } 2368 else 2369 { 2370 pDataBuffer = (bit8 *)(((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense; 2371 2372 } 2373 scsiCmnd = satOrgIOContext->pScsiCmnd; 2374 pSense = satOrgIOContext->pSense; 2375 } 2376 else 2377 { 2378 SM_DBG4(("smsatRequestSenseCB: Internal smSatInternalIo_t satIntIoContext\n")); 2379 satOrgIOContext = satIOContext->satOrgIOContext; 2380 if (satOrgIOContext == agNULL) 2381 { 2382 SM_DBG4(("smsatRequestSenseCB: satOrgIOContext is NULL, wrong\n")); 2383 return; 2384 } 2385 else 2386 { 2387 SM_DBG4(("smsatRequestSenseCB: satOrgIOContext is NOT NULL\n")); 2388 } 2389 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 2390 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 2391 2392 if (satOrgIOContext->superIOFlag) 2393 { 2394 pDataBuffer = (bit8 *)(((tiSuperScsiInitiatorRequest_t *)satOrgIOContext->smScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense; 2395 } 2396 else 2397 { 2398 pDataBuffer = (bit8 *)(((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense; 2399 2400 } 2401 scsiCmnd = satOrgIOContext->pScsiCmnd; 2402 pSense = satOrgIOContext->pSense; 2403 } 2404 2405 smIORequestBody->ioCompleted = agTRUE; 2406 smIORequestBody->ioStarted = agFALSE; 2407 2408 SM_DBG4(("smsatRequestSenseCB: fis command 0x%x\n", hostToDevFis->h.command)); 2409 2410 allocationLen = scsiCmnd->cdb[4]; 2411 allocationLen = MIN(allocationLen, scsiCmnd->expDataLength); 2412 SM_DBG1(("smsatRequestSenseCB: allocationLen in CDB %d 0x%x!!!\n", allocationLen,allocationLen)); 2413 2414 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 2415 { 2416 SM_DBG1(("smsatRequestSenseCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 2417 tdsmIOCompletedCB( 2418 smRoot, 2419 smOrgIORequest, 2420 smIOFailed, 2421 smDetailOtherError, 2422 agNULL, 2423 satOrgIOContext->interruptContext 2424 ); 2425 2426 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2427 2428 smsatFreeIntIoResource( smRoot, 2429 oneDeviceData, 2430 satIntIo); 2431 2432 return; 2433 } 2434 2435 /* 2436 checking IO status, FIS type and error status 2437 */ 2438 if (agIOStatus != OSSA_IO_SUCCESS) 2439 { 2440 /* only agsaFisRegDeviceToHost_t is expected */ 2441 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 2442 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 2443 2444 /* for debugging */ 2445 if( statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 2446 { 2447 if (hostToDevFis->h.command == SAT_SMART && hostToDevFis->h.features == SAT_SMART_RETURN_STATUS) 2448 { 2449 SM_DBG1(("smsatRequestSenseCB: FAILED, Wrong FIS type 0x%x and SAT_SMART_RETURN_STATU!!!\n", statDevToHostFisHeader->fisType)); 2450 } 2451 else 2452 { 2453 SM_DBG1(("smsatRequestSenseCB: FAILED, Wrong FIS type 0x%x and SAT_CHECK_POWER_MODE!!!\n",statDevToHostFisHeader->fisType)); 2454 } 2455 } 2456 2457 /* for debugging */ 2458 if ( (ataStatus & ERR_ATA_STATUS_MASK) || 2459 (ataStatus & DF_ATA_STATUS_MASK) 2460 ) 2461 { 2462 if (hostToDevFis->h.command == SAT_SMART && hostToDevFis->h.features == SAT_SMART_RETURN_STATUS) 2463 { 2464 SM_DBG1(("smsatRequestSenseCB: FAILED, error status and SAT_SMART_RETURN_STATU!!!\n")); 2465 } 2466 else 2467 { 2468 SM_DBG1(("smsatRequestSenseCB: FAILED, error status and SAT_CHECK_POWER_MODE!!!\n")); 2469 } 2470 } 2471 2472 /* Process abort case */ 2473 if (agIOStatus == OSSA_IO_ABORTED) 2474 { 2475 smsatProcessAbort(smRoot, 2476 smOrgIORequest, 2477 satOrgIOContext 2478 ); 2479 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2480 2481 smsatFreeIntIoResource( smRoot, 2482 oneDeviceData, 2483 satIntIo); 2484 return; 2485 } 2486 if (hostToDevFis->h.command == SAT_SMART && hostToDevFis->h.features == SAT_SMART_RETURN_STATUS) 2487 { 2488 /* report using the original tiIOrequst */ 2489 /* failed during sending SMART RETURN STATUS */ 2490 smsatSetSensePayload( pSense, 2491 SCSI_SNSKEY_NO_SENSE, 2492 0, 2493 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE, 2494 satOrgIOContext); 2495 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen)); 2496 if (SENSE_DATA_LENGTH < allocationLen) 2497 { 2498 /* underrun */ 2499 tdsmIOCompletedCB( smRoot, 2500 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 2501 smIOUnderRun, 2502 allocationLen - SENSE_DATA_LENGTH, 2503 agNULL, 2504 satOrgIOContext->interruptContext ); 2505 } 2506 else 2507 { 2508 tdsmIOCompletedCB( smRoot, 2509 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 2510 smIOSuccess, 2511 SCSI_STAT_GOOD, 2512 agNULL, 2513 satOrgIOContext->interruptContext ); 2514 } 2515 } 2516 else 2517 { 2518 /* report using the original tiIOrequst */ 2519 /* failed during sending SAT_CHECK_POWER_MODE */ 2520 smsatSetSensePayload( pSense, 2521 SCSI_SNSKEY_NO_SENSE, 2522 0, 2523 SCSI_SNSCODE_LOW_POWER_CONDITION_ON, 2524 satOrgIOContext); 2525 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen)); 2526 2527 if (SENSE_DATA_LENGTH < allocationLen) 2528 { 2529 /* underrun */ 2530 tdsmIOCompletedCB( smRoot, 2531 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 2532 smIOUnderRun, 2533 allocationLen - SENSE_DATA_LENGTH, 2534 agNULL, 2535 satOrgIOContext->interruptContext ); 2536 } 2537 else 2538 { 2539 tdsmIOCompletedCB( smRoot, 2540 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 2541 smIOSuccess, 2542 SCSI_STAT_GOOD, 2543 agNULL, 2544 satOrgIOContext->interruptContext ); 2545 } 2546 } 2547 2548 2549 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2550 2551 smsatFreeIntIoResource( smRoot, 2552 oneDeviceData, 2553 satIntIo); 2554 return; 2555 } 2556 2557 saFrameReadBlock(agRoot, agParam, 0, &statDevToHostFisData, sizeof(agsaFisRegD2HData_t)); 2558 2559 switch (hostToDevFis->h.command) 2560 { 2561 case SAT_SMART: 2562 SM_DBG4(("smsatRequestSenseCB: SAT_SMART_RETURN_STATUS case\n")); 2563 if (statDevToHostFisData.lbaMid == 0xF4 || statDevToHostFisData.lbaHigh == 0x2C) 2564 { 2565 /* threshold exceeds */ 2566 SM_DBG1(("smsatRequestSenseCB: threshold exceeds!!!\n")); 2567 2568 2569 /* report using the original tiIOrequst */ 2570 /* failed during sending SMART RETURN STATUS */ 2571 smsatSetSensePayload( pSense, 2572 SCSI_SNSKEY_NO_SENSE, 2573 0, 2574 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE, 2575 satOrgIOContext); 2576 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen)); 2577 2578 if (SENSE_DATA_LENGTH < allocationLen) 2579 { 2580 /* underrun */ 2581 tdsmIOCompletedCB( smRoot, 2582 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2583 smIOUnderRun, 2584 allocationLen - SENSE_DATA_LENGTH, 2585 agNULL, 2586 satOrgIOContext->interruptContext ); 2587 } 2588 else 2589 { 2590 tdsmIOCompletedCB( smRoot, 2591 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2592 smIOSuccess, 2593 SCSI_STAT_GOOD, 2594 agNULL, 2595 satOrgIOContext->interruptContext ); 2596 } 2597 2598 2599 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2600 2601 smsatFreeIntIoResource( smRoot, 2602 oneDeviceData, 2603 satIntIo); 2604 return; 2605 } 2606 2607 2608 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2609 2610 /* done with internally genereated SAT_SMART_RETURN_STATUS */ 2611 smsatFreeIntIoResource( smRoot, 2612 oneDeviceData, 2613 satIntIo); 2614 2615 /* at this point, successful SMART_RETURN_STATUS 2616 xmit SAT_CHECK_POWER_MODE 2617 */ 2618 if (satOrgIOContext->superIOFlag) 2619 { 2620 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength; 2621 } 2622 else 2623 { 2624 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength; 2625 } 2626 2627 satNewIntIo = smsatAllocIntIoResource( smRoot, 2628 smOrgIORequest, 2629 oneDeviceData, 2630 dataLength, 2631 satNewIntIo); 2632 if (satNewIntIo == agNULL) 2633 { 2634 /* failed as a part of sending SMART RETURN STATUS */ 2635 smsatSetSensePayload( pSense, 2636 SCSI_SNSKEY_NO_SENSE, 2637 0, 2638 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE, 2639 satOrgIOContext); 2640 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen)); 2641 2642 if (SENSE_DATA_LENGTH < allocationLen) 2643 { 2644 /* underrun */ 2645 tdsmIOCompletedCB( smRoot, 2646 smOrgIORequest, 2647 smIOUnderRun, 2648 allocationLen - SENSE_DATA_LENGTH, 2649 agNULL, 2650 satOrgIOContext->interruptContext ); 2651 } 2652 else 2653 { 2654 tdsmIOCompletedCB( smRoot, 2655 smOrgIORequest, 2656 smIOSuccess, 2657 SCSI_STAT_GOOD, 2658 agNULL, 2659 satOrgIOContext->interruptContext ); 2660 } 2661 2662 SM_DBG1(("smsatRequestSenseCB: momory allocation fails!!!\n")); 2663 return; 2664 } /* end of memory allocation failure */ 2665 2666 2667 /* 2668 * Need to initialize all the fields within satIOContext 2669 */ 2670 2671 satNewIOContext = smsatPrepareNewIO( 2672 satNewIntIo, 2673 smOrgIORequest, 2674 oneDeviceData, 2675 scsiCmnd, 2676 satOrgIOContext 2677 ); 2678 2679 /* sending SAT_CHECK_POWER_MODE */ 2680 status = smsatRequestSense_1( smRoot, 2681 &satNewIntIo->satIntSmIORequest, 2682 satNewIOContext->psmDeviceHandle, 2683 &satNewIntIo->satIntSmScsiXchg, 2684 satNewIOContext); 2685 2686 if (status != SM_RC_SUCCESS) 2687 { 2688 /* sending SAT_CHECK_POWER_MODE fails */ 2689 smsatFreeIntIoResource( smRoot, 2690 oneDeviceData, 2691 satNewIntIo); 2692 2693 /* failed during sending SAT_CHECK_POWER_MODE */ 2694 smsatSetSensePayload( pSense, 2695 SCSI_SNSKEY_NO_SENSE, 2696 0, 2697 SCSI_SNSCODE_LOW_POWER_CONDITION_ON, 2698 satOrgIOContext); 2699 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen)); 2700 2701 if (SENSE_DATA_LENGTH < allocationLen) 2702 { 2703 /* underrun */ 2704 tdsmIOCompletedCB( smRoot, 2705 smOrgIORequest, 2706 smIOUnderRun, 2707 allocationLen - SENSE_DATA_LENGTH, 2708 agNULL, 2709 satOrgIOContext->interruptContext ); 2710 } 2711 else 2712 { 2713 tdsmIOCompletedCB( smRoot, 2714 smOrgIORequest, 2715 smIOSuccess, 2716 SCSI_STAT_GOOD, 2717 agNULL, 2718 satOrgIOContext->interruptContext ); 2719 } 2720 2721 SM_DBG1(("smsatRequestSenseCB: calling satRequestSense_1 fails!!!\n")); 2722 return; 2723 } 2724 2725 break; 2726 case SAT_CHECK_POWER_MODE: 2727 SM_DBG4(("smsatRequestSenseCB: SAT_CHECK_POWER_MODE case\n")); 2728 2729 /* check ATA STANDBY state */ 2730 if (statDevToHostFisData.sectorCount == 0x00) 2731 { 2732 /* in STANDBY */ 2733 SM_DBG1(("smsatRequestSenseCB: in standby!!!\n")); 2734 2735 2736 /* report using the original tiIOrequst */ 2737 /* failed during sending SAT_CHECK_POWER_MODE */ 2738 smsatSetSensePayload( pSense, 2739 SCSI_SNSKEY_NO_SENSE, 2740 0, 2741 SCSI_SNSCODE_LOW_POWER_CONDITION_ON, 2742 satOrgIOContext); 2743 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen)); 2744 2745 if (SENSE_DATA_LENGTH < allocationLen) 2746 { 2747 /* underrun */ 2748 tdsmIOCompletedCB( smRoot, 2749 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2750 smIOUnderRun, 2751 allocationLen - SENSE_DATA_LENGTH, 2752 agNULL, 2753 satOrgIOContext->interruptContext ); 2754 } 2755 else 2756 { 2757 tdsmIOCompletedCB( smRoot, 2758 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2759 smIOSuccess, 2760 SCSI_STAT_GOOD, 2761 agNULL, 2762 satOrgIOContext->interruptContext ); 2763 } 2764 2765 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2766 2767 smsatFreeIntIoResource( smRoot, 2768 oneDeviceData, 2769 satIntIo); 2770 return; 2771 } 2772 2773 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2774 2775 /* done with internnaly generated SAT_CHECK_POWER_MODE */ 2776 smsatFreeIntIoResource( smRoot, 2777 oneDeviceData, 2778 satIntIo); 2779 2780 if (oneDeviceData->satFormatState == agTRUE) 2781 { 2782 SM_DBG1(("smsatRequestSenseCB: in format!!!\n")); 2783 2784 2785 /* report using the original tiIOrequst */ 2786 smsatSetSensePayload( pSense, 2787 SCSI_SNSKEY_NOT_READY, 2788 0, 2789 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_FORMAT_IN_PROGRESS, 2790 satOrgIOContext); 2791 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen)); 2792 2793 if (SENSE_DATA_LENGTH < allocationLen) 2794 { 2795 /* underrun */ 2796 tdsmIOCompletedCB( smRoot, 2797 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2798 smIOUnderRun, 2799 allocationLen - SENSE_DATA_LENGTH, 2800 agNULL, 2801 satOrgIOContext->interruptContext ); 2802 } 2803 else 2804 { 2805 tdsmIOCompletedCB( smRoot, 2806 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2807 smIOSuccess, 2808 SCSI_STAT_GOOD, 2809 agNULL, 2810 satOrgIOContext->interruptContext ); 2811 } 2812 2813 return; 2814 } 2815 2816 /* normal: returns good status for requestsense */ 2817 /* report using the original tiIOrequst */ 2818 smsatSetSensePayload( pSense, 2819 SCSI_SNSKEY_NO_SENSE, 2820 0, 2821 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 2822 satOrgIOContext); 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) 2826 { 2827 /* underrun */ 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 */ 2832 smIOUnderRun, 2833 allocationLen - SENSE_DATA_LENGTH, 2834 agNULL, 2835 satOrgIOContext->interruptContext ); 2836 2837 } 2838 else 2839 { 2840 tdsmIOCompletedCB( smRoot, 2841 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2842 smIOSuccess, 2843 SCSI_STAT_GOOD, 2844 agNULL, 2845 satOrgIOContext->interruptContext ); 2846 } 2847 2848 break; 2849 default: 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, 2857 0, 2858 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 2859 satOrgIOContext); 2860 sm_memcpy(pDataBuffer, pSense, MIN(SENSE_DATA_LENGTH, allocationLen)); 2861 2862 tdsmIOCompletedCB( smRoot, 2863 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 2864 smIOSuccess, 2865 SCSI_STAT_CHECK_CONDITION, 2866 satOrgIOContext->pSmSenseData, 2867 satOrgIOContext->interruptContext ); 2868 2869 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2870 2871 smsatFreeIntIoResource( smRoot, 2872 oneDeviceData, 2873 satIntIo); 2874 break; 2875 } /* switch */ 2876 2877 return; 2878 2879 } 2880 2881 osGLOBAL void 2882 smsatSendDiagnosticCB( 2883 agsaRoot_t *agRoot, 2884 agsaIORequest_t *agIORequest, 2885 bit32 agIOStatus, 2886 agsaFisHeader_t *agFirstDword, 2887 bit32 agIOInfoLen, 2888 agsaFrameHandle_t agFrameHandle, 2889 void *ioContext 2890 ) 2891 { 2892 /* 2893 In the process of SendDiagnotic 2894 Process READ VERIFY SECTOR(S) EXT two time 2895 Process SMART ECECUTE OFF-LINE IMMEDIATE 2896 */ 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; 2918 2919 bit32 status; 2920 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 2921 2922 SM_DBG2(("smsatSendDiagnosticCB: start\n")); 2923 SM_DBG5(("smsatSendDiagnosticCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 2924 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; 2934 2935 if (satIntIo == agNULL) 2936 { 2937 SM_DBG4(("smsatSendDiagnosticCB: External smSatInternalIo_t satIntIoContext\n")); 2938 satOrgIOContext = satIOContext; 2939 smOrgIORequest = smIORequestBody->smIORequest; 2940 pSense = satOrgIOContext->pSense; 2941 scsiCmnd = satOrgIOContext->pScsiCmnd; 2942 } 2943 else 2944 { 2945 SM_DBG4(("smsatSendDiagnosticCB: Internal smSatInternalIo_t satIntIoContext\n")); 2946 satOrgIOContext = satIOContext->satOrgIOContext; 2947 if (satOrgIOContext == agNULL) 2948 { 2949 SM_DBG4(("smsatSendDiagnosticCB: satOrgIOContext is NULL, wrong\n")); 2950 return; 2951 } 2952 else 2953 { 2954 SM_DBG4(("smsatSendDiagnosticCB: satOrgIOContext is NOT NULL\n")); 2955 } 2956 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 2957 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 2958 pSense = satOrgIOContext->pSense; 2959 scsiCmnd = satOrgIOContext->pScsiCmnd; 2960 } 2961 2962 smIORequestBody->ioCompleted = agTRUE; 2963 smIORequestBody->ioStarted = agFALSE; 2964 2965 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 2966 { 2967 SM_DBG1(("smsatSendDiagnosticCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 2968 oneDeviceData->satVerifyState = 0; 2969 oneDeviceData->satBGPendingDiag = agFALSE; 2970 2971 if (hostToDevFis->d.lbaLow != 0x01 && hostToDevFis->d.lbaLow != 0x02) 2972 { 2973 /* no completion for background send diagnotic. It is done in satSendDiagnostic() */ 2974 tdsmIOCompletedCB( 2975 smRoot, 2976 smOrgIORequest, 2977 smIOFailed, 2978 smDetailOtherError, 2979 agNULL, 2980 satOrgIOContext->interruptContext 2981 ); 2982 } 2983 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 2984 2985 smsatFreeIntIoResource( smRoot, 2986 oneDeviceData, 2987 satIntIo); 2988 return; 2989 2990 } 2991 2992 if (agIOStatus != OSSA_IO_SUCCESS) 2993 { 2994 /* only agsaFisRegDeviceToHost_t is expected */ 2995 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 2996 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 2997 } 2998 2999 SM_DBG5(("smsatSendDiagnosticCB: fis command 0x%x\n", hostToDevFis->h.command)); 3000 3001 if( agIOStatus != OSSA_IO_SUCCESS) 3002 { 3003 /* 3004 checking IO status, FIS type and error status 3005 */ 3006 oneDeviceData->satVerifyState = 0; 3007 oneDeviceData->satBGPendingDiag = agFALSE; 3008 3009 if( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 3010 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 3011 ) 3012 { 3013 3014 /* for debugging */ 3015 if( agIOStatus != OSSA_IO_SUCCESS) 3016 { 3017 if ( hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT ) 3018 { 3019 SM_DBG1(("smsatSendDiagnosticCB: FAILED, NOT IO_SUCCESS and SAT_READ_VERIFY_SECTORS(_EXT)!!!\n")); 3020 } 3021 else 3022 { 3023 SM_DBG1(("smsatSendDiagnosticCB: FAILED, NOT IO_SUCCESS and SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE!!!\n")); 3024 } 3025 } 3026 3027 /* for debugging */ 3028 if( statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 3029 { 3030 if ( hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT ) 3031 { 3032 SM_DBG1(("smsatSendDiagnosticCB: FAILED, Wrong FIS type 0x%x and SAT_READ_VERIFY_SECTORS(_EXT)!!!\n", statDevToHostFisHeader->fisType)); 3033 } 3034 else 3035 { 3036 SM_DBG1(("smsatSendDiagnosticCB: FAILED, Wrong FIS type 0x%x and SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE!!!\n",statDevToHostFisHeader->fisType)); 3037 } 3038 } 3039 3040 /* for debugging */ 3041 if ( (ataStatus & ERR_ATA_STATUS_MASK) || 3042 (ataStatus & DF_ATA_STATUS_MASK) 3043 ) 3044 { 3045 if ( hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT ) 3046 { 3047 SM_DBG1(("smsatSendDiagnosticCB: FAILED, error status and SAT_READ_VERIFY_SECTORS(_EXT)!!!\n")); 3048 } 3049 else 3050 { 3051 SM_DBG1(("smsatSendDiagnosticCB: FAILED, error status and SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE!!!\n")); 3052 } 3053 } 3054 3055 /* Process abort case */ 3056 if (agIOStatus == OSSA_IO_ABORTED) 3057 { 3058 smsatProcessAbort(smRoot, 3059 smOrgIORequest, 3060 satOrgIOContext 3061 ); 3062 3063 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3064 3065 smsatFreeIntIoResource( smRoot, 3066 oneDeviceData, 3067 satIntIo); 3068 return; 3069 } 3070 3071 if ( (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS) || 3072 (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT) ) 3073 { 3074 /* report using the original tiIOrequst */ 3075 /* failed during sending SAT_READ_VERIFY_SECTORS(_EXT) */ 3076 smsatSetSensePayload( pSense, 3077 SCSI_SNSKEY_HARDWARE_ERROR, 3078 0, 3079 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST, 3080 satOrgIOContext); 3081 3082 tdsmIOCompletedCB( smRoot, 3083 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3084 smIOSuccess, 3085 SCSI_STAT_CHECK_CONDITION, 3086 satOrgIOContext->pSmSenseData, 3087 satOrgIOContext->interruptContext ); 3088 3089 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3090 3091 smsatFreeIntIoResource( smRoot, 3092 oneDeviceData, 3093 satIntIo); 3094 return; 3095 } 3096 else 3097 { 3098 /* report using the original tiIOrequst */ 3099 /* failed during sending SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE */ 3100 smsatSetSensePayload( pSense, 3101 SCSI_SNSKEY_HARDWARE_ERROR, 3102 0, 3103 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST, 3104 satOrgIOContext); 3105 3106 if (hostToDevFis->d.lbaLow != 0x01 && hostToDevFis->d.lbaLow != 0x02) 3107 { 3108 /* no completion for background send diagnotic. It is done in satSendDiagnostic() */ 3109 tdsmIOCompletedCB( smRoot, 3110 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3111 smIOSuccess, 3112 SCSI_STAT_CHECK_CONDITION, 3113 satOrgIOContext->pSmSenseData, 3114 satOrgIOContext->interruptContext ); 3115 3116 } 3117 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3118 3119 smsatFreeIntIoResource( smRoot, 3120 oneDeviceData, 3121 satIntIo); 3122 return; 3123 } 3124 } 3125 } 3126 3127 /* processing success case */ 3128 switch (hostToDevFis->h.command) 3129 { 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)); 3137 3138 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3139 3140 /* done with internally genereated AT_READ_VERIFY_SECTORS(_EXT) */ 3141 smsatFreeIntIoResource( smRoot, 3142 oneDeviceData, 3143 satIntIo); 3144 3145 if (oneDeviceData->satVerifyState == 3) 3146 { 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 */ 3153 smIOSuccess, 3154 SCSI_STAT_GOOD, 3155 agNULL, 3156 satOrgIOContext->interruptContext ); 3157 return; 3158 } 3159 else 3160 { 3161 /* prepare SAT_READ_VERIFY_SECTORS(_EXT) */ 3162 satNewIntIo = smsatAllocIntIoResource( smRoot, 3163 smOrgIORequest, 3164 oneDeviceData, 3165 0, 3166 satNewIntIo); 3167 if (satNewIntIo == agNULL) 3168 { 3169 /* reset satVerifyState */ 3170 oneDeviceData->satVerifyState = 0; 3171 3172 /* failed as a part of sending SAT_READ_VERIFY_SECTORS(_EXT) */ 3173 smsatSetSensePayload( pSense, 3174 SCSI_SNSKEY_HARDWARE_ERROR, 3175 0, 3176 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST, 3177 satOrgIOContext); 3178 3179 tdsmIOCompletedCB( smRoot, 3180 smOrgIORequest, 3181 smIOSuccess, 3182 SCSI_STAT_CHECK_CONDITION, 3183 satOrgIOContext->pSmSenseData, 3184 satOrgIOContext->interruptContext ); 3185 3186 SM_DBG1(("smsatSendDiagnosticCB: momory allocation fails!!!\n")); 3187 return; 3188 } /* end of memory allocation failure */ 3189 3190 /* 3191 * Need to initialize all the fields within satIOContext 3192 */ 3193 3194 satNewIOContext = smsatPrepareNewIO( 3195 satNewIntIo, 3196 smOrgIORequest, 3197 oneDeviceData, 3198 scsiCmnd, 3199 satOrgIOContext 3200 ); 3201 3202 if (oneDeviceData->satVerifyState == 1) 3203 { 3204 /* sending SAT_CHECK_POWER_MODE */ 3205 status = smsatSendDiagnostic_1( smRoot, 3206 &satNewIntIo->satIntSmIORequest, 3207 satNewIOContext->psmDeviceHandle, 3208 &satNewIntIo->satIntSmScsiXchg, 3209 satNewIOContext); 3210 } 3211 else 3212 { 3213 /* oneDeviceData->satVerifyState == 2 */ 3214 status = smsatSendDiagnostic_2( smRoot, 3215 &satNewIntIo->satIntSmIORequest, 3216 satNewIOContext->psmDeviceHandle, 3217 &satNewIntIo->satIntSmScsiXchg, 3218 satNewIOContext); 3219 } 3220 3221 if (status != SM_RC_SUCCESS) 3222 { 3223 /* sending SAT_READ_VERIFY_SECTORS(_EXT) fails */ 3224 smsatFreeIntIoResource( smRoot, 3225 oneDeviceData, 3226 satNewIntIo); 3227 3228 /* failed during sending SAT_READ_VERIFY_SECTORS(_EXT) */ 3229 smsatSetSensePayload( pSense, 3230 SCSI_SNSKEY_HARDWARE_ERROR, 3231 0, 3232 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST, 3233 satOrgIOContext); 3234 3235 tdsmIOCompletedCB( smRoot, 3236 smOrgIORequest, 3237 smIOSuccess, 3238 SCSI_STAT_CHECK_CONDITION, 3239 satOrgIOContext->pSmSenseData, 3240 satOrgIOContext->interruptContext ); 3241 3242 /* reset satVerifyState */ 3243 oneDeviceData->satVerifyState = 0; 3244 SM_DBG1(("smsatSendDiagnosticCB: calling satSendDiagnostic_1 or _2 fails!!!\n")); 3245 return; 3246 } 3247 } /* oneDeviceData->satVerifyState == 1 or 2 */ 3248 3249 break; 3250 case SAT_SMART: 3251 if (hostToDevFis->h.features == SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE) 3252 { 3253 SM_DBG5(("smsatSendDiagnosticCB: SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE case\n")); 3254 3255 oneDeviceData->satBGPendingDiag = agFALSE; 3256 3257 if (hostToDevFis->d.lbaLow == 0x01 || hostToDevFis->d.lbaLow == 0x02) 3258 { 3259 /* for background send diagnostic, no completion here. It is done already. */ 3260 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3261 3262 /* done with AT_SMART_EXEUTE_OFF_LINE_IMMEDIATE */ 3263 smsatFreeIntIoResource( smRoot, 3264 oneDeviceData, 3265 satIntIo); 3266 SM_DBG5(("smsatSendDiagnosticCB: returning but no IOCompleted\n")); 3267 } 3268 else 3269 { 3270 SM_DBG5(("smsatSendDiagnosticCB: returning good status for senddiagnostic\n")); 3271 tdsmIOCompletedCB( smRoot, 3272 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 3273 smIOSuccess, 3274 SCSI_STAT_GOOD, 3275 agNULL, 3276 satOrgIOContext->interruptContext ); 3277 3278 3279 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3280 3281 /* done with AT_SMART_EXEUTE_OFF_LINE_IMMEDIATE */ 3282 smsatFreeIntIoResource( smRoot, 3283 oneDeviceData, 3284 satIntIo); 3285 } 3286 } 3287 break; 3288 default: 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, 3293 0, 3294 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 3295 satOrgIOContext); 3296 3297 tdsmIOCompletedCB( smRoot, 3298 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 3299 smIOSuccess, 3300 SCSI_STAT_CHECK_CONDITION, 3301 satOrgIOContext->pSmSenseData, 3302 satOrgIOContext->interruptContext ); 3303 3304 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3305 3306 smsatFreeIntIoResource( smRoot, 3307 oneDeviceData, 3308 satIntIo); 3309 break; 3310 } 3311 return; 3312 3313 } 3314 3315 osGLOBAL void 3316 smsatStartStopUnitCB( 3317 agsaRoot_t *agRoot, 3318 agsaIORequest_t *agIORequest, 3319 bit32 agIOStatus, 3320 agsaFisHeader_t *agFirstDword, 3321 bit32 agIOInfoLen, 3322 agsaFrameHandle_t agFrameHandle, 3323 void *ioContext 3324 ) 3325 { 3326 /* 3327 In the process of StartStopUnit 3328 Process FLUSH CACHE (EXT) 3329 Process STANDBY 3330 Process READ VERIFY SECTOR(S) EXT 3331 Process MEDIA EJECT 3332 */ 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; 3354 bit32 status; 3355 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 3356 3357 SM_DBG2(("smsatStartStopUnitCB: start\n")); 3358 SM_DBG5(("smsatStartStopUnitCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 3359 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) 3370 { 3371 SM_DBG4(("smsatStartStopUnitCB: External smSatInternalIo_t satIntIoContext\n")); 3372 satOrgIOContext = satIOContext; 3373 smOrgIORequest = smIORequestBody->smIORequest; 3374 pSense = satIOContext->pSense; 3375 scsiCmnd = satIOContext->pScsiCmnd; 3376 } 3377 else 3378 { 3379 SM_DBG4(("smsatStartStopUnitCB: Internal smSatInternalIo_t satIntIoContext\n")); 3380 satOrgIOContext = satIOContext->satOrgIOContext; 3381 if (satOrgIOContext == agNULL) 3382 { 3383 SM_DBG4(("smsatStartStopUnitCB: satOrgIOContext is NULL, wrong\n")); 3384 return; 3385 } 3386 else 3387 { 3388 SM_DBG4(("smsatStartStopUnitCB: satOrgIOContext is NOT NULL\n")); 3389 } 3390 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 3391 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 3392 3393 pSense = satOrgIOContext->pSense; 3394 scsiCmnd = satOrgIOContext->pScsiCmnd; 3395 } 3396 3397 smIORequestBody->ioCompleted = agTRUE; 3398 smIORequestBody->ioStarted = agFALSE; 3399 3400 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 3401 { 3402 SM_DBG1(("smsatStartStopUnitCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 3403 3404 /* IMMED == 0 */ 3405 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 3406 { 3407 SM_DBG1(("smsatStartStopUnitCB: immed bit 0!!!\n")); 3408 smsatSetSensePayload( pSense, 3409 SCSI_SNSKEY_ABORTED_COMMAND, 3410 0, 3411 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3412 satOrgIOContext); 3413 3414 tdsmIOCompletedCB( smRoot, 3415 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3416 smIOSuccess, 3417 SCSI_STAT_CHECK_CONDITION, 3418 satOrgIOContext->pSmSenseData, 3419 satOrgIOContext->interruptContext ); 3420 3421 3422 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3423 smsatFreeIntIoResource( smRoot, 3424 oneDeviceData, 3425 satIntIo); 3426 } 3427 /* IMMED == 1 */ 3428 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK) 3429 { 3430 SM_DBG1(("smsatStartStopUnitCB: immed bit 1!!!\n")); 3431 smsatSetDeferredSensePayload( pSense, 3432 SCSI_SNSKEY_ABORTED_COMMAND, 3433 0, 3434 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3435 satOrgIOContext); 3436 3437 tdsmIOCompletedCB( smRoot, 3438 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3439 smIOSuccess, 3440 SCSI_STAT_CHECK_CONDITION, 3441 satOrgIOContext->pSmSenseData, 3442 satOrgIOContext->interruptContext ); 3443 3444 3445 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3446 smsatFreeIntIoResource( smRoot, 3447 oneDeviceData, 3448 satIntIo); 3449 } 3450 3451 3452 3453 return; 3454 } 3455 3456 if (agIOStatus != OSSA_IO_SUCCESS) 3457 { 3458 /* only agsaFisRegDeviceToHost_t is expected */ 3459 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 3460 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 3461 } 3462 /* 3463 checking IO status, FIS type and error status 3464 */ 3465 if( agIOStatus != OSSA_IO_SUCCESS) 3466 { 3467 if( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 3468 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 3469 ) 3470 { 3471 /* for debugging */ 3472 if( agIOStatus != OSSA_IO_SUCCESS) 3473 { 3474 SM_DBG1(("smsatStartStopUnitCB: FAILED, NOT IO_SUCCESS!!!\n")); 3475 } 3476 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 3477 { 3478 SM_DBG1(("smsatStartStopUnitCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 3479 } 3480 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 3481 (ataStatus & DF_ATA_STATUS_MASK) 3482 ) 3483 { 3484 SM_DBG1(("smsatStartStopUnitCB: FAILED, FAILED, error status!!!\n")); 3485 } 3486 3487 3488 /* Process abort case */ 3489 if (agIOStatus == OSSA_IO_ABORTED) 3490 { 3491 smsatProcessAbort(smRoot, 3492 smOrgIORequest, 3493 satOrgIOContext 3494 ); 3495 3496 3497 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3498 3499 smsatFreeIntIoResource( smRoot, 3500 oneDeviceData, 3501 satIntIo); 3502 return; 3503 } 3504 3505 switch (hostToDevFis->h.command) 3506 { 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 */ 3511 /* IMMED == 0 */ 3512 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 3513 { 3514 smsatSetSensePayload( pSense, 3515 SCSI_SNSKEY_ABORTED_COMMAND, 3516 0, 3517 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3518 satOrgIOContext); 3519 3520 tdsmIOCompletedCB( smRoot, 3521 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3522 smIOSuccess, 3523 SCSI_STAT_CHECK_CONDITION, 3524 satOrgIOContext->pSmSenseData, 3525 satOrgIOContext->interruptContext ); 3526 3527 3528 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3529 3530 smsatFreeIntIoResource( smRoot, 3531 oneDeviceData, 3532 satIntIo); 3533 } 3534 /* IMMED == 1 */ 3535 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK) 3536 { 3537 smsatSetDeferredSensePayload( pSense, 3538 SCSI_SNSKEY_ABORTED_COMMAND, 3539 0, 3540 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3541 satOrgIOContext); 3542 3543 tdsmIOCompletedCB( smRoot, 3544 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3545 smIOSuccess, 3546 SCSI_STAT_CHECK_CONDITION, 3547 satOrgIOContext->pSmSenseData, 3548 satOrgIOContext->interruptContext ); 3549 3550 3551 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3552 3553 smsatFreeIntIoResource( smRoot, 3554 oneDeviceData, 3555 satIntIo); 3556 } 3557 break; 3558 case SAT_STANDBY: 3559 SM_DBG5(("smsatStartStopUnitCB: SAT_STANDBY\n")); 3560 /* check immed bit in scsi command */ 3561 /* IMMED == 0 */ 3562 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 3563 { 3564 smsatSetSensePayload( pSense, 3565 SCSI_SNSKEY_ABORTED_COMMAND, 3566 0, 3567 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3568 satOrgIOContext); 3569 3570 tdsmIOCompletedCB( smRoot, 3571 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3572 smIOSuccess, 3573 SCSI_STAT_CHECK_CONDITION, 3574 satOrgIOContext->pSmSenseData, 3575 satOrgIOContext->interruptContext ); 3576 3577 3578 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3579 3580 smsatFreeIntIoResource( smRoot, 3581 oneDeviceData, 3582 satIntIo); 3583 } 3584 /* IMMED == 1 */ 3585 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK) 3586 { 3587 smsatSetDeferredSensePayload( pSense, 3588 SCSI_SNSKEY_ABORTED_COMMAND, 3589 0, 3590 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3591 satOrgIOContext); 3592 3593 tdsmIOCompletedCB( smRoot, 3594 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3595 smIOSuccess, 3596 SCSI_STAT_CHECK_CONDITION, 3597 satOrgIOContext->pSmSenseData, 3598 satOrgIOContext->interruptContext ); 3599 3600 3601 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3602 3603 smsatFreeIntIoResource( smRoot, 3604 oneDeviceData, 3605 satIntIo); 3606 } 3607 break; 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")); 3611 /* IMMED == 0 */ 3612 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 3613 { 3614 smsatSetSensePayload( pSense, 3615 SCSI_SNSKEY_ABORTED_COMMAND, 3616 0, 3617 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3618 satOrgIOContext); 3619 3620 tdsmIOCompletedCB( smRoot, 3621 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3622 smIOSuccess, 3623 SCSI_STAT_CHECK_CONDITION, 3624 satOrgIOContext->pSmSenseData, 3625 satOrgIOContext->interruptContext ); 3626 3627 3628 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3629 3630 smsatFreeIntIoResource( smRoot, 3631 oneDeviceData, 3632 satIntIo); 3633 } 3634 /* IMMED == 1 */ 3635 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK) 3636 { 3637 smsatSetDeferredSensePayload( pSense, 3638 SCSI_SNSKEY_ABORTED_COMMAND, 3639 0, 3640 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3641 satOrgIOContext); 3642 3643 tdsmIOCompletedCB( smRoot, 3644 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3645 smIOSuccess, 3646 SCSI_STAT_CHECK_CONDITION, 3647 satOrgIOContext->pSmSenseData, 3648 satOrgIOContext->interruptContext ); 3649 3650 3651 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3652 3653 smsatFreeIntIoResource( smRoot, 3654 oneDeviceData, 3655 satIntIo); 3656 } 3657 break; 3658 case SAT_MEDIA_EJECT: 3659 SM_DBG5(("smsatStartStopUnitCB: SAT_MEDIA_EJECT\n")); 3660 /* IMMED == 0 */ 3661 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 3662 { 3663 smsatSetSensePayload( pSense, 3664 SCSI_SNSKEY_ABORTED_COMMAND, 3665 0, 3666 SCSI_SNSCODE_MEDIA_LOAD_OR_EJECT_FAILED, 3667 satOrgIOContext); 3668 3669 tdsmIOCompletedCB( smRoot, 3670 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3671 smIOSuccess, 3672 SCSI_STAT_CHECK_CONDITION, 3673 satOrgIOContext->pSmSenseData, 3674 satOrgIOContext->interruptContext ); 3675 3676 3677 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3678 3679 smsatFreeIntIoResource( smRoot, 3680 oneDeviceData, 3681 satIntIo); 3682 } 3683 /* IMMED == 1 */ 3684 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK) 3685 { 3686 smsatSetDeferredSensePayload( pSense, 3687 SCSI_SNSKEY_ABORTED_COMMAND, 3688 0, 3689 SCSI_SNSCODE_MEDIA_LOAD_OR_EJECT_FAILED, 3690 satOrgIOContext); 3691 3692 tdsmIOCompletedCB( smRoot, 3693 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 3694 smIOSuccess, 3695 SCSI_STAT_CHECK_CONDITION, 3696 satOrgIOContext->pSmSenseData, 3697 satOrgIOContext->interruptContext ); 3698 3699 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3700 3701 smsatFreeIntIoResource( smRoot, 3702 oneDeviceData, 3703 satIntIo); 3704 } 3705 break; 3706 default: 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, 3711 0, 3712 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 3713 satOrgIOContext); 3714 3715 tdsmIOCompletedCB( smRoot, 3716 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 3717 smIOSuccess, 3718 SCSI_STAT_CHECK_CONDITION, 3719 satOrgIOContext->pSmSenseData, 3720 satOrgIOContext->interruptContext ); 3721 3722 3723 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3724 3725 smsatFreeIntIoResource( smRoot, 3726 oneDeviceData, 3727 satIntIo); 3728 break; 3729 } /* switch */ 3730 3731 return; 3732 } /* error check */ 3733 } 3734 3735 /* ATA command completes sucessfully */ 3736 switch (hostToDevFis->h.command) 3737 { 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")); 3741 3742 3743 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3744 3745 /* done with SAT_FLUSH_CACHE(_EXT) */ 3746 smsatFreeIntIoResource( smRoot, 3747 oneDeviceData, 3748 satIntIo); 3749 3750 /* at this point, successful SAT_READ_VERIFY_SECTORS(_EXT) 3751 send SAT_SATNDBY 3752 */ 3753 satNewIntIo = smsatAllocIntIoResource( smRoot, 3754 smOrgIORequest, 3755 oneDeviceData, 3756 0, 3757 satNewIntIo); 3758 if (satNewIntIo == agNULL) 3759 { 3760 /* IMMED == 0 */ 3761 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 3762 { 3763 smsatSetSensePayload( pSense, 3764 SCSI_SNSKEY_ABORTED_COMMAND, 3765 0, 3766 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3767 satOrgIOContext); 3768 } 3769 else /* IMMED == 1 */ 3770 { 3771 smsatSetDeferredSensePayload( pSense, 3772 SCSI_SNSKEY_ABORTED_COMMAND, 3773 0, 3774 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3775 satOrgIOContext); 3776 } 3777 tdsmIOCompletedCB( smRoot, 3778 smOrgIORequest, 3779 smIOSuccess, 3780 SCSI_STAT_CHECK_CONDITION, 3781 satOrgIOContext->pSmSenseData, 3782 satOrgIOContext->interruptContext ); 3783 3784 SM_DBG1(("smsatStartStopUnitCB: momory allocation fails!!!\n")); 3785 return; 3786 } /* end of memory allocation failure */ 3787 3788 /* 3789 * Need to initialize all the fields within satIOContext 3790 */ 3791 3792 satNewIOContext = smsatPrepareNewIO( 3793 satNewIntIo, 3794 smOrgIORequest, 3795 oneDeviceData, 3796 scsiCmnd, 3797 satOrgIOContext 3798 ); 3799 3800 /* sending SAT_STANDBY */ 3801 status = smsatStartStopUnit_1( smRoot, 3802 &satNewIntIo->satIntSmIORequest, 3803 satNewIOContext->psmDeviceHandle, 3804 &satNewIntIo->satIntSmScsiXchg, 3805 satNewIOContext); 3806 3807 if (status != SM_RC_SUCCESS) 3808 { 3809 /* sending SAT_CHECK_POWER_MODE fails */ 3810 smsatFreeIntIoResource( smRoot, 3811 oneDeviceData, 3812 satNewIntIo); 3813 3814 /* IMMED == 0 */ 3815 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 3816 { 3817 smsatSetSensePayload( pSense, 3818 SCSI_SNSKEY_ABORTED_COMMAND, 3819 0, 3820 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3821 satOrgIOContext); 3822 } 3823 else /* IMMED == 1 */ 3824 { 3825 smsatSetDeferredSensePayload( pSense, 3826 SCSI_SNSKEY_ABORTED_COMMAND, 3827 0, 3828 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 3829 satOrgIOContext); 3830 } 3831 tdsmIOCompletedCB( smRoot, 3832 smOrgIORequest, 3833 smIOSuccess, 3834 SCSI_STAT_CHECK_CONDITION, 3835 satOrgIOContext->pSmSenseData, 3836 satOrgIOContext->interruptContext ); 3837 3838 SM_DBG1(("smsatStartStopUnitCB: calling satStartStopUnit_1 fails!!!\n")); 3839 return; 3840 } 3841 break; 3842 case SAT_STANDBY: 3843 SM_DBG5(("smsatStartStopUnitCB: SAT_STANDBY success case\n")); 3844 3845 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3846 3847 /* done with SAT_STANDBY */ 3848 smsatFreeIntIoResource( smRoot, 3849 oneDeviceData, 3850 satIntIo); 3851 /* 3852 if immed == 0, return good status 3853 */ 3854 /* IMMED == 0 */ 3855 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 3856 { 3857 tdsmIOCompletedCB( smRoot, 3858 smOrgIORequest, 3859 smIOSuccess, 3860 SCSI_STAT_GOOD, 3861 agNULL, 3862 satOrgIOContext->interruptContext ); 3863 } 3864 oneDeviceData->satStopState = agTRUE; 3865 break; 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")); 3869 3870 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3871 3872 /* done with SAT_READ_VERIFY_SECTORS(_EXT) */ 3873 smsatFreeIntIoResource( smRoot, 3874 oneDeviceData, 3875 satIntIo); 3876 /* 3877 if immed == 0, return good status 3878 */ 3879 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 3880 { 3881 tdsmIOCompletedCB( smRoot, 3882 smOrgIORequest, 3883 smIOSuccess, 3884 SCSI_STAT_GOOD, 3885 agNULL, 3886 satOrgIOContext->interruptContext ); 3887 } 3888 /* 3889 if immed == 0, return good status 3890 */ 3891 /* 3892 don't forget to check and set driver state; Active power state 3893 */ 3894 oneDeviceData->satStopState = agFALSE; 3895 break; 3896 case SAT_MEDIA_EJECT: 3897 SM_DBG5(("smsatStartStopUnitCB: SAT_MEDIA_EJECT success case\n")); 3898 3899 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3900 3901 /* done with SAT_READ_VERIFY_SECTORS(_EXT) */ 3902 smsatFreeIntIoResource( smRoot, 3903 oneDeviceData, 3904 satIntIo); 3905 /* 3906 if immed == 0, return good status 3907 */ 3908 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 3909 { 3910 tdsmIOCompletedCB( smRoot, 3911 smOrgIORequest, 3912 smIOSuccess, 3913 SCSI_STAT_GOOD, 3914 agNULL, 3915 satOrgIOContext->interruptContext ); 3916 } 3917 break; 3918 default: 3919 SM_DBG1(("smsatStartStopUnitCB:success but error default case command 0x%x!!!\n", hostToDevFis->h.command)); 3920 3921 /* unspecified case, return no sense and no addition info */ 3922 smsatSetSensePayload( pSense, 3923 SCSI_SNSKEY_NO_SENSE, 3924 0, 3925 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 3926 satOrgIOContext); 3927 3928 tdsmIOCompletedCB( smRoot, 3929 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 3930 smIOSuccess, 3931 SCSI_STAT_CHECK_CONDITION, 3932 satOrgIOContext->pSmSenseData, 3933 satOrgIOContext->interruptContext ); 3934 3935 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 3936 3937 smsatFreeIntIoResource( smRoot, 3938 oneDeviceData, 3939 satIntIo); 3940 break; 3941 } 3942 return; 3943 3944 } 3945 3946 osGLOBAL void 3947 smsatWriteSame10CB( 3948 agsaRoot_t *agRoot, 3949 agsaIORequest_t *agIORequest, 3950 bit32 agIOStatus, 3951 agsaFisHeader_t *agFirstDword, 3952 bit32 agIOInfoLen, 3953 agsaFrameHandle_t agFrameHandle, 3954 void *ioContext 3955 ) 3956 { 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; 3974 bit32 status; 3975 bit32 sectorcount = 0; 3976 bit32 lba = 0, tl = 0; 3977 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 3978 agsaFisSetDevBitsHeader_t *statSetDevBitFisHeader = agNULL; 3979 3980 SM_DBG2(("smsatWriteSame10CB: start\n")); 3981 SM_DBG5(("smsatWriteSame10CB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 3982 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; 3992 3993 if (satIntIo == agNULL) 3994 { 3995 SM_DBG4(("smsatWriteSame10CB: External smSatInternalIo_t satIntIoContext\n")); 3996 satOrgIOContext = satIOContext; 3997 smOrgIORequest = smIORequestBody->smIORequest; 3998 pSense = satIOContext->pSense; 3999 scsiCmnd = satIOContext->pScsiCmnd; 4000 } 4001 else 4002 { 4003 SM_DBG4(("smsatWriteSame10CB: Internal smSatInternalIo_t satIntIoContext\n")); 4004 satOrgIOContext = satIOContext->satOrgIOContext; 4005 if (satOrgIOContext == agNULL) 4006 { 4007 SM_DBG4(("smsatWriteSame10CB: satOrgIOContext is NULL, wrong\n")); 4008 return; 4009 } 4010 else 4011 { 4012 SM_DBG4(("smsatWriteSame10CB: satOrgIOContext is NOT NULL\n")); 4013 } 4014 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 4015 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 4016 4017 pSense = satOrgIOContext->pSense; 4018 scsiCmnd = satOrgIOContext->pScsiCmnd; 4019 } 4020 4021 4022 smIORequestBody->ioCompleted = agTRUE; 4023 smIORequestBody->ioStarted = agFALSE; 4024 4025 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 4026 { 4027 SM_DBG1(("smsatWriteSame10CB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 4028 smsatSetSensePayload( pSense, 4029 SCSI_SNSKEY_NO_SENSE, 4030 0, 4031 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 4032 satOrgIOContext); 4033 4034 tdsmIOCompletedCB( smRoot, 4035 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 4036 smIOSuccess, 4037 SCSI_STAT_CHECK_CONDITION, 4038 satOrgIOContext->pSmSenseData, 4039 satOrgIOContext->interruptContext ); 4040 4041 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4042 4043 smsatFreeIntIoResource( smRoot, 4044 oneDeviceData, 4045 satIntIo); 4046 return; 4047 } 4048 4049 if (agIOStatus != OSSA_IO_SUCCESS) 4050 { 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 */ 4055 } 4056 4057 if (agIOStatus != OSSA_IO_SUCCESS) 4058 { 4059 if (statDevToHostFisHeader->fisType == SET_DEV_BITS_FIS) 4060 { 4061 statSetDevBitFisHeader = (agsaFisSetDevBitsHeader_t *)&(agFirstDword->D2H); 4062 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 */ 4066 } 4067 } 4068 4069 if( agIOStatus != OSSA_IO_SUCCESS) 4070 { 4071 /* 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 4074 */ 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)) 4078 ) 4079 { 4080 /* for debugging */ 4081 if( agIOStatus != OSSA_IO_SUCCESS) 4082 { 4083 SM_DBG1(("smsatWriteSame10CB: FAILED, NOT IO_SUCCESS!!!\n")); 4084 } 4085 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 4086 { 4087 SM_DBG1(("smsatWriteSame10CB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 4088 } 4089 else if (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS) 4090 { 4091 SM_DBG1(("smsatWriteSame10CB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 4092 } 4093 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 4094 (ataStatus & DF_ATA_STATUS_MASK) 4095 ) 4096 { 4097 SM_DBG1(("smsatWriteSame10CB: FAILED, FAILED, error status!!!\n")); 4098 } 4099 4100 /* Process abort case */ 4101 if (agIOStatus == OSSA_IO_ABORTED) 4102 { 4103 smsatProcessAbort(smRoot, 4104 smOrgIORequest, 4105 satOrgIOContext 4106 ); 4107 4108 4109 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4110 4111 smsatFreeIntIoResource( smRoot, 4112 oneDeviceData, 4113 satIntIo); 4114 return; 4115 } 4116 4117 /* for debugging */ 4118 switch (hostToDevFis->h.command) 4119 { 4120 case SAT_WRITE_DMA_EXT: 4121 SM_DBG1(("smsatWriteSame10CB: SAT_WRITE_DMA_EXT!!!\n")); 4122 break; 4123 case SAT_WRITE_SECTORS_EXT: 4124 SM_DBG1(("smsatWriteSame10CB: SAT_WRITE_SECTORS_EXT!!!\n")); 4125 break; 4126 case SAT_WRITE_FPDMA_QUEUED: 4127 SM_DBG1(("smsatWriteSame10CB: SAT_WRITE_FPDMA_QUEUED!!!\n")); 4128 break; 4129 default: 4130 SM_DBG1(("smsatWriteSame10CB: error default case command 0x%x!!!\n", hostToDevFis->h.command)); 4131 break; 4132 } 4133 4134 smsatSetSensePayload( pSense, 4135 SCSI_SNSKEY_NO_SENSE, 4136 0, 4137 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 4138 satOrgIOContext); 4139 4140 tdsmIOCompletedCB( smRoot, 4141 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 4142 smIOSuccess, 4143 SCSI_STAT_CHECK_CONDITION, 4144 satOrgIOContext->pSmSenseData, 4145 satOrgIOContext->interruptContext ); 4146 4147 4148 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4149 4150 smsatFreeIntIoResource( smRoot, 4151 oneDeviceData, 4152 satIntIo); 4153 return; 4154 } /* end error */ 4155 } 4156 4157 /* process success from this point on */ 4158 /* 4159 note: inefficient implementation until a single block can be manipulated 4160 */ 4161 4162 if (hostToDevFis->h.command == SAT_WRITE_DMA_EXT) 4163 { 4164 SM_DBG5(("smsatWriteSame10CB: SAT_WRITE_DMA_EXT success\n")); 4165 } 4166 else if (hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT) 4167 { 4168 SM_DBG5(("smsatWriteSame10CB: SAT_WRITE_SECTORS_EXT success\n")); 4169 } 4170 else if (hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED) 4171 { 4172 SM_DBG5(("smsatWriteSame10CB: SAT_WRITE_FPDMA_QUEUED success\n")); 4173 } 4174 else 4175 { 4176 SM_DBG1(("smsatWriteSame10CB: error case command 0x%x success!!!\n", hostToDevFis->h.command)); 4177 smsatSetSensePayload( pSense, 4178 SCSI_SNSKEY_NO_SENSE, 4179 0, 4180 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 4181 satOrgIOContext); 4182 4183 tdsmIOCompletedCB( smRoot, 4184 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 4185 smIOSuccess, 4186 SCSI_STAT_CHECK_CONDITION, 4187 satOrgIOContext->pSmSenseData, 4188 satOrgIOContext->interruptContext ); 4189 4190 4191 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4192 4193 smsatFreeIntIoResource( smRoot, 4194 oneDeviceData, 4195 satIntIo); 4196 return; 4197 } 4198 4199 4200 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4201 4202 /* free */ 4203 smsatFreeIntIoResource( smRoot, 4204 oneDeviceData, 4205 satIntIo); 4206 4207 /* 4208 increment LBA by one, keeping the same sector count(1) 4209 sends another ATA command with the changed parameters 4210 */ 4211 4212 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK); 4213 oneDeviceData->satSectorDone++; 4214 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 4215 4216 SM_DBG1(("smsatWriteSame10CB: sectordone %d!!!\n", oneDeviceData->satSectorDone)); 4217 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]; 4221 4222 SM_DBG5(("smsatWriteSame10CB: lba 0x%x tl 0x%x\n", lba, tl)); 4223 4224 if (tl == 0) 4225 { 4226 /* (oneDeviceData->satMaxUserAddrSectors - 1) - lba*/ 4227 sectorcount = (0x0FFFFFFF - 1) - lba; 4228 } 4229 else 4230 { 4231 sectorcount = tl; 4232 } 4233 4234 if (sectorcount <= 0) 4235 { 4236 smsatSetSensePayload( pSense, 4237 SCSI_SNSKEY_NO_SENSE, 4238 0, 4239 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 4240 satOrgIOContext); 4241 4242 tdsmIOCompletedCB( smRoot, 4243 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 4244 smIOSuccess, 4245 SCSI_STAT_CHECK_CONDITION, 4246 satOrgIOContext->pSmSenseData, 4247 satOrgIOContext->interruptContext ); 4248 SM_DBG1(("smsatWriteSame10CB: incorrect sectorcount 0x%x!!!\n", sectorcount)); 4249 return; 4250 } 4251 4252 if (sectorcount == oneDeviceData->satSectorDone) 4253 { 4254 /* 4255 done with writesame 4256 */ 4257 SM_DBG1(("smsatWriteSame10CB: return writesame done!!!\n")); 4258 oneDeviceData->satSectorDone = 0; 4259 4260 tdsmIOCompletedCB( smRoot, 4261 smOrgIORequest, 4262 smIOSuccess, 4263 SCSI_STAT_GOOD, 4264 agNULL, 4265 satOrgIOContext->interruptContext ); 4266 } 4267 else 4268 { 4269 /* sends another ATA command */ 4270 if (hostToDevFis->h.command == SAT_WRITE_DMA_EXT) 4271 { 4272 SM_DBG1(("smsatWriteSame10CB: sends another SAT_WRITE_DMA_EXT!!!\n")); 4273 } 4274 else if (hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT) 4275 { 4276 SM_DBG1(("smsatWriteSame10CB: sends another SAT_WRITE_SECTORS_EXT!!!\n")); 4277 } 4278 else if (hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED) 4279 { 4280 SM_DBG1(("smsatWriteSame10CB: sends another SAT_WRITE_FPDMA_QUEUED!!!\n")); 4281 } 4282 4283 satNewIntIo = smsatAllocIntIoResource( smRoot, 4284 smOrgIORequest, 4285 oneDeviceData, 4286 0, 4287 satNewIntIo); 4288 if (satNewIntIo == agNULL) 4289 { 4290 smsatSetSensePayload( pSense, 4291 SCSI_SNSKEY_NO_SENSE, 4292 0, 4293 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 4294 satOrgIOContext); 4295 4296 tdsmIOCompletedCB( smRoot, 4297 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 4298 smIOSuccess, 4299 SCSI_STAT_CHECK_CONDITION, 4300 satOrgIOContext->pSmSenseData, 4301 satOrgIOContext->interruptContext ); 4302 SM_DBG1(("smsatWriteSame10CB: momory allocation fails!!!\n")); 4303 return; 4304 } /* end memory allocation */ 4305 4306 /* the one to be used */ 4307 smNewIORequestBody = satNewIntIo->satIntRequestBody; 4308 satNewIOContext = &smNewIORequestBody->transport.SATA.satIOContext; 4309 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; 4324 4325 if (hostToDevFis->h.command == SAT_WRITE_DMA_EXT) 4326 { 4327 status = smsatWriteSame10_1( smRoot, 4328 &satNewIntIo->satIntSmIORequest, 4329 satNewIOContext->psmDeviceHandle, 4330 &satNewIntIo->satIntSmScsiXchg, 4331 satNewIOContext, 4332 lba + oneDeviceData->satSectorDone 4333 ); 4334 } 4335 else if (hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT) 4336 { 4337 status = smsatWriteSame10_2( smRoot, 4338 &satNewIntIo->satIntSmIORequest, 4339 satNewIOContext->psmDeviceHandle, 4340 &satNewIntIo->satIntSmScsiXchg, 4341 satNewIOContext, 4342 lba + oneDeviceData->satSectorDone 4343 ); 4344 } 4345 else if (hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED) 4346 { 4347 status = smsatWriteSame10_3( smRoot, 4348 &satNewIntIo->satIntSmIORequest, 4349 satNewIOContext->psmDeviceHandle, 4350 &satNewIntIo->satIntSmScsiXchg, 4351 satNewIOContext, 4352 lba + oneDeviceData->satSectorDone 4353 ); 4354 } 4355 else 4356 { 4357 status = tiError; 4358 SM_DBG1(("smsatWriteSame10CB: sucess but error in command 0x%x!!!\n", hostToDevFis->h.command)); 4359 } 4360 4361 if (status != SM_RC_SUCCESS) 4362 { 4363 /* sending ATA command fails */ 4364 smsatFreeIntIoResource( smRoot, 4365 oneDeviceData, 4366 satNewIntIo); 4367 smsatSetSensePayload( pSense, 4368 SCSI_SNSKEY_NO_SENSE, 4369 0, 4370 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 4371 satOrgIOContext); 4372 4373 tdsmIOCompletedCB( smRoot, 4374 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 4375 smIOSuccess, 4376 SCSI_STAT_CHECK_CONDITION, 4377 satOrgIOContext->pSmSenseData, 4378 satOrgIOContext->interruptContext ); 4379 SM_DBG1(("smsatWriteSame10CB:calling satWriteSame10_1 fails!!!\n")); 4380 return; 4381 } /* end send fails */ 4382 4383 } /* end sends another ATA command */ 4384 4385 return; 4386 4387 } 4388 4389 osGLOBAL void 4390 smsatLogSenseCB( 4391 agsaRoot_t *agRoot, 4392 agsaIORequest_t *agIORequest, 4393 bit32 agIOStatus, 4394 agsaFisHeader_t *agFirstDword, 4395 bit32 agIOInfoLen, 4396 void *agParam, 4397 void *ioContext 4398 ) 4399 { 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; 4410 4411 smScsiRspSense_t *pSense; 4412 smIORequest_t *smOrgIORequest; 4413 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; 4420 bit8 *pLogPage; 4421 bit8 LogPage[SELFTEST_RESULTS_LOG_PAGE_LENGTH]; 4422 bit8 SelfTestExecutionStatus = 0; 4423 bit32 i = 0; 4424 4425 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 4426 agsaFisRegD2HData_t statDevToHostFisData; 4427 smIniScsiCmnd_t *scsiCmnd; 4428 bit32 allocationLen = 0; 4429 4430 SM_DBG2(("smsatLogSenseCB: start\n")); 4431 SM_DBG5(("smsatLogSenseCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 4432 4433 /* internally generate smIOContext */ 4434 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 4435 satIOContext = (smSatIOContext_t *) ioContext; 4436 if (satIOContext == agNULL) 4437 { 4438 SM_DBG1(("smsatLogSenseCB: satIOContext is NULL\n")); 4439 return; 4440 } 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; 4447 4448 if (satIntIo == agNULL) 4449 { 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; 4460 } 4461 else 4462 { 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; 4467 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; 4475 } 4476 4477 smIORequestBody->ioCompleted = agTRUE; 4478 smIORequestBody->ioStarted = agFALSE; 4479 4480 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 4481 { 4482 SM_DBG1(("smsatLogSenseCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 4483 tdsmIOCompletedCB( 4484 smRoot, 4485 smOrgIORequest, 4486 smIOFailed, 4487 smDetailOtherError, 4488 agNULL, 4489 satOrgIOContext->interruptContext 4490 ); 4491 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4492 4493 smsatFreeIntIoResource( smRoot, 4494 oneDeviceData, 4495 satIntIo); 4496 return; 4497 } 4498 4499 if (agIOStatus != OSSA_IO_SUCCESS) 4500 { 4501 /* non-data and pio read -> device to host and pio setup fis are expected */ 4502 /* 4503 first, assumed to be Reg Device to Host FIS 4504 This is OK to just find fis type 4505 */ 4506 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 4507 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 4508 } 4509 4510 if( agIOStatus != OSSA_IO_SUCCESS) 4511 { 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)) 4515 ) 4516 { 4517 /* for debugging */ 4518 if( agIOStatus != OSSA_IO_SUCCESS) 4519 { 4520 SM_DBG1(("smsatLogSenseCB: FAILED, NOT IO_SUCCESS!!!\n")); 4521 } 4522 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 4523 { 4524 SM_DBG1(("smsatLogSenseCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 4525 } 4526 else if (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS) 4527 { 4528 SM_DBG1(("smsatLogSenseCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 4529 } 4530 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 4531 (ataStatus & DF_ATA_STATUS_MASK) 4532 ) 4533 { 4534 SM_DBG1(("smsatLogSenseCB: FAILED, FAILED, error status!!!\n")); 4535 } 4536 4537 /* Process abort case */ 4538 if (agIOStatus == OSSA_IO_ABORTED) 4539 { 4540 smsatProcessAbort(smRoot, 4541 smOrgIORequest, 4542 satOrgIOContext 4543 ); 4544 4545 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4546 4547 smsatFreeIntIoResource( smRoot, 4548 oneDeviceData, 4549 satIntIo); 4550 return; 4551 } 4552 4553 /* for debugging */ 4554 if (hostToDevFis->h.command == SAT_READ_LOG_EXT) 4555 { 4556 SM_DBG1(("smsatLogSenseCB: SAT_READ_LOG_EXT failed!!!\n")); 4557 } 4558 else if (hostToDevFis->h.command == SAT_SMART) 4559 { 4560 if (hostToDevFis->h.features == SAT_SMART_READ_LOG) 4561 { 4562 SM_DBG1(("smsatLogSenseCB: SAT_SMART_READ_LOG failed!!!\n")); 4563 } 4564 else if (hostToDevFis->h.features == SAT_SMART_RETURN_STATUS) 4565 { 4566 SM_DBG1(("smsatLogSenseCB: SAT_SMART_RETURN_STATUS failed!!!\n")); 4567 } 4568 else 4569 { 4570 SM_DBG1(("smsatLogSenseCB: error unknown command 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features)); 4571 } 4572 } 4573 else 4574 { 4575 SM_DBG1(("smsatLogSenseCB: error default case command 0x%x!!!\n", hostToDevFis->h.command)); 4576 } 4577 4578 smsatSetSensePayload( pSense, 4579 SCSI_SNSKEY_NO_SENSE, 4580 0, 4581 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 4582 satOrgIOContext); 4583 4584 tdsmIOCompletedCB( smRoot, 4585 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 4586 smIOSuccess, 4587 SCSI_STAT_CHECK_CONDITION, 4588 satOrgIOContext->pSmSenseData, 4589 satOrgIOContext->interruptContext ); 4590 4591 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4592 4593 smsatFreeIntIoResource( smRoot, 4594 oneDeviceData, 4595 satIntIo); 4596 return; 4597 4598 } /* error checking */ 4599 } 4600 4601 /* prcessing the success case */ 4602 saFrameReadBlock(agRoot, agParam, 0, &statDevToHostFisData, sizeof(agsaFisRegD2HData_t)); 4603 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)); 4607 4608 4609 if (hostToDevFis->h.command == SAT_READ_LOG_EXT) 4610 { 4611 SM_DBG5(("smsatLogSenseCB: SAT_READ_LOG_EXT success\n")); 4612 4613 /* process log data and sends it to upper */ 4614 4615 /* ATA: Extended Self-Test Log */ 4616 virtAddr1 = (satReadLogExtSelfTest_t *)(smScsiRequest->sglVirtualAddr); 4617 /* 4618 ATA/ATAPI VOLII, p197, 287 4619 self-test execution status (4 bits); ((virtAddr1->byte[5] & 0xF0) >> 4) 4620 */ 4621 SelfTestExecutionStatus = (bit8)(((virtAddr1->byte[5] & 0xF0) >> 4)); 4622 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 */ 4626 LogPage[1] = 0; 4627 LogPage[2] = 0x01; /* 0x190, page length */ 4628 LogPage[3] = 0x90; 4629 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 */ 4639 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 */ 4648 4649 /* SAT rev8 Table75, p 76 */ 4650 switch (SelfTestExecutionStatus) 4651 { 4652 case 0: 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; 4656 break; 4657 case 1: 4658 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 4659 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4660 LogPage[22] = 0x81; 4661 break; 4662 case 2: 4663 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 4664 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4665 LogPage[22] = 0x82; 4666 break; 4667 case 3: 4668 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 4669 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4670 LogPage[22] = 0x83; 4671 break; 4672 case 4: 4673 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 4674 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4675 LogPage[22] = 0x84; 4676 break; 4677 case 5: 4678 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 4679 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4680 LogPage[22] = 0x85; 4681 break; 4682 case 6: 4683 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 4684 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4685 LogPage[22] = 0x86; 4686 break; 4687 case 7: 4688 LogPage[20] = 0 | SCSI_SNSKEY_MEDIUM_ERROR; 4689 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4690 LogPage[22] = 0x87; 4691 break; 4692 case 8: 4693 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 4694 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4695 LogPage[22] = 0x88; 4696 break; 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 */ 4702 case 14: 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; 4706 break; 4707 case 15: 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; 4711 break; 4712 default: 4713 SM_DBG1(("smsatLogSenseCB: Error, incorrect SelfTestExecutionStatus 0x%x!!!\n", SelfTestExecutionStatus)); 4714 4715 smsatSetSensePayload( pSense, 4716 SCSI_SNSKEY_NO_SENSE, 4717 0, 4718 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 4719 satOrgIOContext); 4720 4721 tdsmIOCompletedCB( smRoot, 4722 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 4723 smIOSuccess, 4724 SCSI_STAT_CHECK_CONDITION, 4725 satOrgIOContext->pSmSenseData, 4726 satOrgIOContext->interruptContext ); 4727 4728 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4729 4730 smsatFreeIntIoResource( smRoot, 4731 oneDeviceData, 4732 satIntIo); 4733 4734 return; 4735 } 4736 4737 LogPage[23] = 0; /* vendor specific */ 4738 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++) 4742 { 4743 LogPage[i] = 0; /* vendor specific */ 4744 } 4745 4746 sm_memcpy(pLogPage, LogPage, MIN(allocationLen, SELFTEST_RESULTS_LOG_PAGE_LENGTH)); 4747 if (SELFTEST_RESULTS_LOG_PAGE_LENGTH < allocationLen) 4748 { 4749 SM_DBG6(("smsatLogSenseCB: 1st underrun allocationLen %d len %d \n", allocationLen, SELFTEST_RESULTS_LOG_PAGE_LENGTH)); 4750 4751 /* underrun */ 4752 tdsmIOCompletedCB( smRoot, 4753 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 4754 smIOUnderRun, 4755 allocationLen - SELFTEST_RESULTS_LOG_PAGE_LENGTH, 4756 agNULL, 4757 satOrgIOContext->interruptContext ); 4758 4759 } 4760 else 4761 { 4762 tdsmIOCompletedCB( smRoot, 4763 smOrgIORequest, 4764 smIOSuccess, 4765 SCSI_STAT_GOOD, 4766 agNULL, 4767 satOrgIOContext->interruptContext); 4768 } 4769 4770 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4771 4772 smsatFreeIntIoResource( smRoot, 4773 oneDeviceData, 4774 satIntIo); 4775 4776 return; 4777 } 4778 else if (hostToDevFis->h.command == SAT_SMART) 4779 { 4780 if (hostToDevFis->h.features == SAT_SMART_READ_LOG) 4781 { 4782 SM_DBG5(("smsatLogSenseCB: SAT_SMART_READ_LOG success\n")); 4783 /* process log data and sends it to upper */ 4784 4785 /* ATA: Extended Self-Test Log */ 4786 virtAddr2 = (satSmartReadLogSelfTest_t *)(smScsiRequest->sglVirtualAddr); 4787 /* 4788 SPC-4, p197, 287 4789 self-test execution status (4 bits); ((virtAddr2->byte[3] & 0xF0) >> 4) 4790 */ 4791 SelfTestExecutionStatus = (bit8)(((virtAddr2->byte[3] & 0xF0) >> 4)); 4792 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 */ 4796 LogPage[1] = 0; 4797 LogPage[2] = 0x01; /* 0x190, page length */ 4798 LogPage[3] = 0x90; /* 0x190, page length */ 4799 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 */ 4809 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 */ 4818 4819 /* SAT rev8 Table75, p 76 */ 4820 switch (SelfTestExecutionStatus) 4821 { 4822 case 0: 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; 4826 break; 4827 case 1: 4828 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 4829 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4830 LogPage[22] = 0x81; 4831 break; 4832 case 2: 4833 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 4834 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4835 LogPage[22] = 0x82; 4836 break; 4837 case 3: 4838 LogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 4839 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4840 LogPage[22] = 0x83; 4841 break; 4842 case 4: 4843 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 4844 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4845 LogPage[22] = 0x84; 4846 break; 4847 case 5: 4848 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 4849 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4850 LogPage[22] = 0x85; 4851 break; 4852 case 6: 4853 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 4854 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4855 LogPage[22] = 0x86; 4856 break; 4857 case 7: 4858 LogPage[20] = 0 | SCSI_SNSKEY_MEDIUM_ERROR; 4859 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4860 LogPage[22] = 0x87; 4861 break; 4862 case 8: 4863 LogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 4864 LogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 4865 LogPage[22] = 0x88; 4866 break; 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 */ 4872 case 14: 4873 /* unspecified */ 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; 4877 break; 4878 case 15: 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; 4882 break; 4883 default: 4884 SM_DBG1(("smsatLogSenseCB: Error, incorrect SelfTestExecutionStatus 0x%x!!!\n", SelfTestExecutionStatus)); 4885 4886 smsatSetSensePayload( pSense, 4887 SCSI_SNSKEY_NO_SENSE, 4888 0, 4889 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 4890 satOrgIOContext); 4891 4892 tdsmIOCompletedCB( smRoot, 4893 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 4894 smIOSuccess, 4895 SCSI_STAT_CHECK_CONDITION, 4896 satOrgIOContext->pSmSenseData, 4897 satOrgIOContext->interruptContext ); 4898 4899 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4900 4901 smsatFreeIntIoResource( smRoot, 4902 oneDeviceData, 4903 satIntIo); 4904 4905 return; 4906 } 4907 4908 LogPage[23] = 0; /* vendor specific */ 4909 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++) 4913 { 4914 LogPage[i] = 0; /* vendor specific */ 4915 } 4916 4917 sm_memcpy(pLogPage, LogPage, MIN(allocationLen, SELFTEST_RESULTS_LOG_PAGE_LENGTH)); 4918 if (SELFTEST_RESULTS_LOG_PAGE_LENGTH < allocationLen) 4919 { 4920 SM_DBG6(("smsatLogSenseCB: 2nd underrun allocationLen %d len %d \n", allocationLen, SELFTEST_RESULTS_LOG_PAGE_LENGTH)); 4921 4922 /* underrun */ 4923 tdsmIOCompletedCB( smRoot, 4924 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 4925 smIOUnderRun, 4926 allocationLen - SELFTEST_RESULTS_LOG_PAGE_LENGTH, 4927 agNULL, 4928 satOrgIOContext->interruptContext ); 4929 4930 } 4931 else 4932 { 4933 tdsmIOCompletedCB( smRoot, 4934 smOrgIORequest, 4935 smIOSuccess, 4936 SCSI_STAT_GOOD, 4937 agNULL, 4938 satOrgIOContext->interruptContext); 4939 } 4940 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 4941 4942 smsatFreeIntIoResource( smRoot, 4943 oneDeviceData, 4944 satIntIo); 4945 4946 return; 4947 } 4948 else if (hostToDevFis->h.features == SAT_SMART_RETURN_STATUS) 4949 { 4950 SM_DBG5(("smsatLogSenseCB: SAT_SMART_RETURN_STATUS success\n")); 4951 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 */ 4958 4959 /* 4960 SPC-4, 7.2.5, Table 211, p 255 4961 no vendor specific field 4962 */ 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 */ 4967 4968 /* SAT rev8, 10.2.3.1 Table 72, p 73 */ 4969 if (statDevToHostFisData.lbaMid == 0x4F || statDevToHostFisData.lbaHigh == 0xC2) 4970 { 4971 LogPage[8] = 0; /* Sense code */ 4972 LogPage[9] = 0; /* Sense code qualifier */ 4973 } 4974 else if (statDevToHostFisData.lbaMid == 0xF4 || statDevToHostFisData.lbaHigh == 0x2C) 4975 { 4976 LogPage[8] = 0x5D; /* Sense code */ 4977 LogPage[9] = 0x10; /* Sense code qualifier */ 4978 } 4979 4980 /* Assumption: No support for SCT */ 4981 LogPage[10] = 0xFF; /* Most Recent Temperature Reading */ 4982 4983 sm_memcpy(pLogPage, LogPage, MIN(allocationLen, INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH)); 4984 if (INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH < allocationLen) 4985 { 4986 SM_DBG6(("smsatLogSenseCB: 3rd underrun allocationLen %d len %d \n", allocationLen, INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH)); 4987 4988 /* underrun */ 4989 tdsmIOCompletedCB( smRoot, 4990 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 4991 smIOUnderRun, 4992 allocationLen - INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH, 4993 agNULL, 4994 satOrgIOContext->interruptContext ); 4995 4996 } 4997 else 4998 { 4999 tdsmIOCompletedCB( smRoot, 5000 smOrgIORequest, 5001 smIOSuccess, 5002 SCSI_STAT_GOOD, 5003 agNULL, 5004 satOrgIOContext->interruptContext); 5005 } 5006 5007 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5008 5009 smsatFreeIntIoResource( smRoot, 5010 oneDeviceData, 5011 satIntIo); 5012 5013 5014 return; 5015 } 5016 else 5017 { 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, 5021 0, 5022 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5023 satOrgIOContext); 5024 5025 tdsmIOCompletedCB( smRoot, 5026 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5027 smIOSuccess, 5028 SCSI_STAT_CHECK_CONDITION, 5029 satOrgIOContext->pSmSenseData, 5030 satOrgIOContext->interruptContext ); 5031 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5032 5033 smsatFreeIntIoResource( smRoot, 5034 oneDeviceData, 5035 satIntIo); 5036 5037 return; 5038 } 5039 } 5040 else 5041 { 5042 SM_DBG1(("smsatLogSenseCB: error unknown command success 0x%x!!!\n", hostToDevFis->h.command)); 5043 smsatSetSensePayload( pSense, 5044 SCSI_SNSKEY_NO_SENSE, 5045 0, 5046 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5047 satOrgIOContext); 5048 5049 tdsmIOCompletedCB( smRoot, 5050 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5051 smIOSuccess, 5052 SCSI_STAT_CHECK_CONDITION, 5053 satOrgIOContext->pSmSenseData, 5054 satOrgIOContext->interruptContext ); 5055 5056 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5057 5058 smsatFreeIntIoResource( smRoot, 5059 oneDeviceData, 5060 satIntIo); 5061 5062 return; 5063 } 5064 5065 return; 5066 } 5067 5068 osGLOBAL void 5069 smsatSMARTEnableCB( 5070 agsaRoot_t *agRoot, 5071 agsaIORequest_t *agIORequest, 5072 bit32 agIOStatus, 5073 agsaFisHeader_t *agFirstDword, 5074 bit32 agIOInfoLen, 5075 agsaFrameHandle_t agFrameHandle, 5076 void *ioContext 5077 ) 5078 { 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; 5097 bit32 status; 5098 5099 SM_DBG2(("smsatSMARTEnableCB: start\n")); 5100 SM_DBG4(("smsatSMARTEnableCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 5101 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; 5110 /*ttttttthe one */ 5111 if (satIntIo == agNULL) 5112 { 5113 SM_DBG4(("smsatSMARTEnableCB: External smSatInternalIo_t satIntIoContext\n")); 5114 satOrgIOContext = satIOContext; 5115 smOrgIORequest = smIORequestBody->smIORequest; 5116 scsiCmnd = satOrgIOContext->pScsiCmnd; 5117 } 5118 else 5119 { 5120 SM_DBG4(("smsatSMARTEnableCB: Internal smSatInternalIo_t satIntIoContext\n")); 5121 satOrgIOContext = satIOContext->satOrgIOContext; 5122 if (satOrgIOContext == agNULL) 5123 { 5124 SM_DBG4(("smsatSMARTEnableCB: satOrgIOContext is NULL, wrong\n")); 5125 return; 5126 } 5127 else 5128 { 5129 SM_DBG4(("smsatSMARTEnableCB: satOrgIOContext is NOT NULL\n")); 5130 } 5131 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 5132 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 5133 scsiCmnd = satOrgIOContext->pScsiCmnd; 5134 } 5135 smIORequestBody->ioCompleted = agTRUE; 5136 smIORequestBody->ioStarted = agFALSE; 5137 5138 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 5139 { 5140 SM_DBG1(("smsatSMARTEnableCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 5141 tdsmIOCompletedCB( 5142 smRoot, 5143 smOrgIORequest, 5144 smIOFailed, 5145 smDetailOtherError, 5146 agNULL, 5147 satOrgIOContext->interruptContext 5148 ); 5149 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5150 smsatFreeIntIoResource( smRoot, 5151 oneDeviceData, 5152 satIntIo); 5153 return; 5154 } 5155 /* 5156 checking IO status, FIS type and error status 5157 */ 5158 if (agIOStatus != OSSA_IO_SUCCESS) 5159 { 5160 SM_DBG1(("smsatSMARTEnableCB: not success status, status %d!!!\n", agIOStatus)); 5161 tdsmIOCompletedCB( 5162 smRoot, 5163 smOrgIORequest, 5164 smIOFailed, 5165 smDetailOtherError, 5166 agNULL, 5167 satOrgIOContext->interruptContext 5168 ); 5169 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5170 smsatFreeIntIoResource( smRoot, 5171 oneDeviceData, 5172 satIntIo); 5173 return; 5174 } 5175 /* process success case */ 5176 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5177 smsatFreeIntIoResource( smRoot, 5178 oneDeviceData, 5179 satIntIo); 5180 satNewIntIo = smsatAllocIntIoResource( smRoot, 5181 smOrgIORequest, 5182 oneDeviceData, 5183 512, 5184 satNewIntIo); 5185 if (satNewIntIo == agNULL) 5186 { 5187 tdsmIOCompletedCB( 5188 smRoot, 5189 smOrgIORequest, 5190 smIOFailed, 5191 smDetailOtherError, 5192 agNULL, 5193 satOrgIOContext->interruptContext 5194 ); 5195 return; 5196 } 5197 satNewIOContext = smsatPrepareNewIO( 5198 satNewIntIo, 5199 smOrgIORequest, 5200 oneDeviceData, 5201 scsiCmnd, 5202 satOrgIOContext 5203 ); 5204 status = smsatLogSense_1(smRoot, 5205 &satNewIntIo->satIntSmIORequest, 5206 satNewIOContext->psmDeviceHandle, 5207 &satNewIntIo->satIntSmScsiXchg, 5208 satNewIOContext); 5209 if (status != SM_RC_SUCCESS) 5210 { 5211 /* sending SAT_CHECK_POWER_MODE fails */ 5212 smsatFreeIntIoResource( smRoot, 5213 oneDeviceData, 5214 satNewIntIo); 5215 tdsmIOCompletedCB( 5216 smRoot, 5217 smOrgIORequest, 5218 smIOFailed, 5219 smDetailOtherError, 5220 agNULL, 5221 satOrgIOContext->interruptContext 5222 ); 5223 return; 5224 } 5225 return; 5226 } 5227 5228 osGLOBAL void 5229 smsatModeSelect6n10CB( 5230 agsaRoot_t *agRoot, 5231 agsaIORequest_t *agIORequest, 5232 bit32 agIOStatus, 5233 agsaFisHeader_t *agFirstDword, 5234 bit32 agIOInfoLen, 5235 agsaFrameHandle_t agFrameHandle, 5236 void *ioContext 5237 ) 5238 { 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; 5251 5252 smScsiRspSense_t *pSense; 5253 smIniScsiCmnd_t *scsiCmnd; 5254 smIORequest_t *smOrgIORequest; 5255 5256 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 5257 bit32 ataStatus = 0; 5258 bit32 status; 5259 smScsiInitiatorRequest_t *smScsiRequest; /* smScsiXchg */ 5260 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 5261 5262 SM_DBG2(("smsatModeSelect6n10CB: start\n")); 5263 SM_DBG5(("smsatModeSelect6n10CB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 5264 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; 5274 5275 if (satIntIo == agNULL) 5276 { 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; 5283 } 5284 else 5285 { 5286 SM_DBG4(("smsatModeSelect6n10CB: Internal smSatInternalIo_t satIntIoContext\n")); 5287 satOrgIOContext = satIOContext->satOrgIOContext; 5288 if (satOrgIOContext == agNULL) 5289 { 5290 SM_DBG4(("smsatModeSelect6n10CB: satOrgIOContext is NULL, wrong\n")); 5291 return; 5292 } 5293 else 5294 { 5295 SM_DBG4(("smsatModeSelect6n10CB: satOrgIOContext is NOT NULL\n")); 5296 } 5297 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 5298 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 5299 5300 smScsiRequest = satOrgIOContext->smScsiXchg; 5301 pSense = satOrgIOContext->pSense; 5302 scsiCmnd = satOrgIOContext->pScsiCmnd; 5303 } 5304 5305 smIORequestBody->ioCompleted = agTRUE; 5306 smIORequestBody->ioStarted = agFALSE; 5307 5308 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 5309 { 5310 SM_DBG1(("smsatModeSelect6n10CB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 5311 tdsmIOCompletedCB( 5312 smRoot, 5313 smOrgIORequest, 5314 smIOFailed, 5315 smDetailOtherError, 5316 agNULL, 5317 satOrgIOContext->interruptContext 5318 ); 5319 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5320 5321 smsatFreeIntIoResource( smRoot, 5322 oneDeviceData, 5323 satIntIo); 5324 return; 5325 } 5326 5327 if (agIOStatus != OSSA_IO_SUCCESS) 5328 { 5329 /* only agsaFisRegDeviceToHost_t is expected */ 5330 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 5331 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 5332 } 5333 5334 if (agIOStatus != OSSA_IO_SUCCESS) 5335 { 5336 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 5337 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 5338 ) 5339 { 5340 /* for debugging */ 5341 if( agIOStatus != OSSA_IO_SUCCESS) 5342 { 5343 SM_DBG1(("smsatModeSelect6n10CB: FAILED, NOT IO_SUCCESS!!!\n")); 5344 } 5345 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 5346 { 5347 SM_DBG1(("smsatModeSelect6n10CB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 5348 } 5349 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 5350 (ataStatus & DF_ATA_STATUS_MASK) 5351 ) 5352 { 5353 SM_DBG1(("smsatModeSelect6n10CB: FAILED, FAILED, error status!!!\n")); 5354 } 5355 5356 /* Process abort case */ 5357 if (agIOStatus == OSSA_IO_ABORTED) 5358 { 5359 smsatProcessAbort(smRoot, 5360 smOrgIORequest, 5361 satOrgIOContext 5362 ); 5363 5364 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5365 5366 smsatFreeIntIoResource( smRoot, 5367 oneDeviceData, 5368 satIntIo); 5369 return; 5370 } 5371 5372 /* for debugging */ 5373 if (hostToDevFis->h.command == SAT_SET_FEATURES) 5374 { 5375 if ((hostToDevFis->h.features == 0x82) || (hostToDevFis->h.features == 0x02)) 5376 { 5377 SM_DBG1(("smsatModeSelect6n10CB: 1 SAT_SET_FEATURES failed, feature 0x%x!!!\n", hostToDevFis->h.features)); 5378 } 5379 else if ((hostToDevFis->h.features == 0xAA) || (hostToDevFis->h.features == 0x55)) 5380 { 5381 SM_DBG1(("smsatModeSelect6n10CB: 2 SAT_SET_FEATURES failed, feature 0x%x!!!\n", hostToDevFis->h.features)); 5382 } 5383 else 5384 { 5385 SM_DBG1(("smsatModeSelect6n10CB: error unknown command 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features)); 5386 } 5387 } 5388 else if (hostToDevFis->h.command == SAT_SMART) 5389 { 5390 if ((hostToDevFis->h.features == SAT_SMART_ENABLE_OPERATIONS) || (hostToDevFis->h.features == SAT_SMART_DISABLE_OPERATIONS)) 5391 { 5392 SM_DBG1(("smsatModeSelect6n10CB: SAT_SMART_ENABLE/DISABLE_OPERATIONS failed, feature 0x%x!!!\n", hostToDevFis->h.features)); 5393 } 5394 else 5395 { 5396 SM_DBG1(("smsatModeSelect6n10CB: error unknown command 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features)); 5397 } 5398 } 5399 else 5400 { 5401 SM_DBG1(("smsatModeSelect6n10CB: error default case command 0x%x!!!\n", hostToDevFis->h.command)); 5402 } 5403 5404 5405 smsatSetSensePayload( pSense, 5406 SCSI_SNSKEY_NO_SENSE, 5407 0, 5408 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5409 satOrgIOContext); 5410 5411 tdsmIOCompletedCB( smRoot, 5412 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5413 smIOSuccess, 5414 SCSI_STAT_CHECK_CONDITION, 5415 satOrgIOContext->pSmSenseData, 5416 satOrgIOContext->interruptContext ); 5417 5418 5419 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5420 5421 smsatFreeIntIoResource( smRoot, 5422 oneDeviceData, 5423 satIntIo); 5424 return; 5425 } /* error checking */ 5426 } 5427 5428 5429 /* prcessing the success case */ 5430 5431 5432 if (hostToDevFis->h.command == SAT_SET_FEATURES) 5433 { 5434 if ((hostToDevFis->h.features == 0x82) || (hostToDevFis->h.features == 0x02)) 5435 { 5436 SM_DBG5(("smsatModeSelect6n10CB: 1 SAT_SET_FEATURES success, feature 0x%x\n", hostToDevFis->h.features)); 5437 if (hostToDevFis->h.features == 0x02) 5438 { 5439 /* enable write cache */ 5440 oneDeviceData->satWriteCacheEnabled = agTRUE; 5441 } 5442 else 5443 { 5444 /* disable write cache */ 5445 oneDeviceData->satWriteCacheEnabled = agFALSE; 5446 } 5447 5448 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5449 5450 smsatFreeIntIoResource( smRoot, 5451 oneDeviceData, 5452 satIntIo); 5453 5454 satNewIntIo = smsatAllocIntIoResource( smRoot, 5455 smOrgIORequest, 5456 oneDeviceData, 5457 0, 5458 satNewIntIo); 5459 if (satNewIntIo == agNULL) 5460 { 5461 smsatSetSensePayload( pSense, 5462 SCSI_SNSKEY_NO_SENSE, 5463 0, 5464 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5465 satOrgIOContext); 5466 5467 tdsmIOCompletedCB( smRoot, 5468 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5469 smIOSuccess, 5470 SCSI_STAT_CHECK_CONDITION, 5471 satOrgIOContext->pSmSenseData, 5472 satOrgIOContext->interruptContext ); 5473 SM_DBG1(("smsatModeSelect6n10CB: momory allocation fails!!!\n")); 5474 return; 5475 } /* end memory allocation */ 5476 5477 satNewIOContext = smsatPrepareNewIO( 5478 satNewIntIo, 5479 smOrgIORequest, 5480 oneDeviceData, 5481 scsiCmnd, 5482 satOrgIOContext 5483 ); 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 */ 5489 satNewIOContext 5490 ); 5491 5492 if (status != SM_RC_SUCCESS) 5493 { 5494 /* sending ATA command fails */ 5495 smsatFreeIntIoResource( smRoot, 5496 oneDeviceData, 5497 satNewIntIo); 5498 smsatSetSensePayload( pSense, 5499 SCSI_SNSKEY_NO_SENSE, 5500 0, 5501 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5502 satOrgIOContext); 5503 5504 tdsmIOCompletedCB( smRoot, 5505 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5506 smIOSuccess, 5507 SCSI_STAT_CHECK_CONDITION, 5508 satOrgIOContext->pSmSenseData, 5509 satOrgIOContext->interruptContext ); 5510 SM_DBG1(("smsatModeSelect6n10CB: calling satModeSelect6_1 fails!!!\n")); 5511 return; 5512 } /* end send fails */ 5513 return; 5514 } 5515 else if ((hostToDevFis->h.features == 0xAA) || (hostToDevFis->h.features == 0x55)) 5516 { 5517 SM_DBG5(("smsatModeSelect6n10CB: 2 SAT_SET_FEATURES success, feature 0x%x\n", hostToDevFis->h.features)); 5518 5519 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5520 5521 smsatFreeIntIoResource( smRoot, 5522 oneDeviceData, 5523 satIntIo); 5524 5525 /* return stat_good */ 5526 tdsmIOCompletedCB( smRoot, 5527 smOrgIORequest, 5528 smIOSuccess, 5529 SCSI_STAT_GOOD, 5530 agNULL, 5531 satOrgIOContext->interruptContext ); 5532 return; 5533 } 5534 else 5535 { 5536 SM_DBG1(("smsatModeSelect6n10CB: error unknown command success 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features)); 5537 5538 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5539 5540 smsatFreeIntIoResource( smRoot, 5541 oneDeviceData, 5542 satIntIo); 5543 smsatSetSensePayload( pSense, 5544 SCSI_SNSKEY_NO_SENSE, 5545 0, 5546 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5547 satOrgIOContext); 5548 5549 tdsmIOCompletedCB( smRoot, 5550 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5551 smIOSuccess, 5552 SCSI_STAT_CHECK_CONDITION, 5553 satOrgIOContext->pSmSenseData, 5554 satOrgIOContext->interruptContext ); 5555 return; 5556 } 5557 } 5558 else if (hostToDevFis->h.command == SAT_SMART ) 5559 { 5560 if ((hostToDevFis->h.features == SAT_SMART_ENABLE_OPERATIONS) || (hostToDevFis->h.features == SAT_SMART_DISABLE_OPERATIONS)) 5561 { 5562 SM_DBG5(("smsatModeSelect6n10CB: SAT_SMART_ENABLE/DISABLE_OPERATIONS success, feature 0x%x\n", hostToDevFis->h.features)); 5563 5564 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5565 5566 smsatFreeIntIoResource( smRoot, 5567 oneDeviceData, 5568 satIntIo); 5569 /* return stat_good */ 5570 tdsmIOCompletedCB( smRoot, 5571 smOrgIORequest, 5572 smIOSuccess, 5573 SCSI_STAT_GOOD, 5574 agNULL, 5575 satOrgIOContext->interruptContext ); 5576 return; 5577 } 5578 else 5579 { 5580 SM_DBG1(("smsatModeSelect6n10CB: error unknown command failed 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features)); 5581 5582 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5583 5584 smsatFreeIntIoResource( smRoot, 5585 oneDeviceData, 5586 satIntIo); 5587 smsatSetSensePayload( pSense, 5588 SCSI_SNSKEY_NO_SENSE, 5589 0, 5590 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5591 satOrgIOContext); 5592 5593 tdsmIOCompletedCB( smRoot, 5594 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5595 smIOSuccess, 5596 SCSI_STAT_CHECK_CONDITION, 5597 satOrgIOContext->pSmSenseData, 5598 satOrgIOContext->interruptContext ); 5599 return; 5600 } 5601 } 5602 5603 else 5604 { 5605 SM_DBG1(("smsatModeSelect6n10CB: error default case command success 0x%x!!!\n", hostToDevFis->h.command)); 5606 5607 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5608 5609 smsatFreeIntIoResource( smRoot, 5610 oneDeviceData, 5611 satIntIo); 5612 5613 smsatSetSensePayload( pSense, 5614 SCSI_SNSKEY_NO_SENSE, 5615 0, 5616 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5617 satOrgIOContext); 5618 5619 tdsmIOCompletedCB( smRoot, 5620 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5621 smIOSuccess, 5622 SCSI_STAT_CHECK_CONDITION, 5623 satOrgIOContext->pSmSenseData, 5624 satOrgIOContext->interruptContext ); 5625 return; 5626 } 5627 5628 return; 5629 5630 } 5631 5632 osGLOBAL void 5633 smsatSynchronizeCache10n16CB( 5634 agsaRoot_t *agRoot, 5635 agsaIORequest_t *agIORequest, 5636 bit32 agIOStatus, 5637 agsaFisHeader_t *agFirstDword, 5638 bit32 agIOInfoLen, 5639 agsaFrameHandle_t agFrameHandle, 5640 void *ioContext 5641 ) 5642 { 5643 /* 5644 In the process of SynchronizeCache10 and SynchronizeCache16 5645 Process SAT_FLUSH_CACHE_EXT 5646 Process SAT_FLUSH_CACHE 5647 */ 5648 5649 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; 5659 5660 smScsiRspSense_t *pSense; 5661 smIniScsiCmnd_t *scsiCmnd; 5662 smIORequest_t *smOrgIORequest; 5663 5664 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 5665 bit32 ataStatus = 0; 5666 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 5667 5668 SM_DBG2(("smsatSynchronizeCache10n16CB: start\n")); 5669 SM_DBG5(("smsatSynchronizeCache10n16CB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 5670 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; 5680 5681 /* SPC: Self-Test Result Log page */ 5682 if (satIntIo == agNULL) 5683 { 5684 SM_DBG4(("smsatSynchronizeCache10n16CB: External smSatInternalIo_t satIntIoContext\n")); 5685 satOrgIOContext = satIOContext; 5686 smOrgIORequest = smIORequestBody->smIORequest; 5687 pSense = satIOContext->pSense; 5688 scsiCmnd = satIOContext->pScsiCmnd; 5689 } 5690 else 5691 { 5692 SM_DBG4(("smsatSynchronizeCache10n16CB: Internal smSatInternalIo_t satIntIoContext\n")); 5693 satOrgIOContext = satIOContext->satOrgIOContext; 5694 if (satOrgIOContext == agNULL) 5695 { 5696 SM_DBG4(("smsatSynchronizeCache10n16CB: satOrgIOContext is NULL, wrong\n")); 5697 return; 5698 } 5699 else 5700 { 5701 SM_DBG4(("smsatSynchronizeCache10n16CB: satOrgIOContext is NOT NULL\n")); 5702 } 5703 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 5704 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 5705 5706 pSense = satOrgIOContext->pSense; 5707 scsiCmnd = satOrgIOContext->pScsiCmnd; 5708 } 5709 5710 smIORequestBody->ioCompleted = agTRUE; 5711 smIORequestBody->ioStarted = agFALSE; 5712 5713 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 5714 { 5715 SM_DBG1(("smsatSynchronizeCache10n16CB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 5716 5717 tdsmIOCompletedCB( 5718 smRoot, 5719 smOrgIORequest, 5720 smIOFailed, 5721 smDetailOtherError, 5722 agNULL, 5723 satOrgIOContext->interruptContext 5724 ); 5725 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5726 5727 smsatFreeIntIoResource( smRoot, 5728 oneDeviceData, 5729 satIntIo); 5730 return; 5731 } 5732 5733 if( agIOStatus != OSSA_IO_SUCCESS) 5734 { 5735 /* only agsaFisRegDeviceToHost_t is expected */ 5736 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 5737 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 5738 } 5739 5740 if( agIOStatus != OSSA_IO_SUCCESS) 5741 { 5742 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 5743 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 5744 ) 5745 { 5746 /* for debugging */ 5747 if( agIOStatus != OSSA_IO_SUCCESS) 5748 { 5749 SM_DBG1(("smsatSynchronizeCache10n16CB: FAILED, NOT IO_SUCCESS!!!\n")); 5750 } 5751 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 5752 { 5753 SM_DBG1(("smsatSynchronizeCache10n16CB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 5754 } 5755 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 5756 (ataStatus & DF_ATA_STATUS_MASK) 5757 ) 5758 { 5759 SM_DBG1(("smsatSynchronizeCache10n16CB: FAILED, FAILED, error status!!!\n")); 5760 } 5761 5762 5763 /* Process abort case */ 5764 if (agIOStatus == OSSA_IO_ABORTED) 5765 { 5766 smsatProcessAbort(smRoot, 5767 smOrgIORequest, 5768 satOrgIOContext 5769 ); 5770 5771 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5772 5773 smsatFreeIntIoResource( smRoot, 5774 oneDeviceData, 5775 satIntIo); 5776 return; 5777 } 5778 5779 switch (hostToDevFis->h.command) 5780 { 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) 5785 { 5786 smsatSetDeferredSensePayload( pSense, 5787 SCSI_SNSKEY_NO_SENSE, 5788 0, 5789 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5790 satOrgIOContext); 5791 } 5792 else 5793 { 5794 smsatSetDeferredSensePayload( pSense, 5795 SCSI_SNSKEY_NO_SENSE, 5796 0, 5797 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5798 satOrgIOContext); 5799 } 5800 5801 5802 tdsmIOCompletedCB( smRoot, 5803 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5804 smIOSuccess, 5805 SCSI_STAT_CHECK_CONDITION, 5806 satOrgIOContext->pSmSenseData, 5807 satOrgIOContext->interruptContext ); 5808 5809 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5810 5811 smsatFreeIntIoResource( smRoot, 5812 oneDeviceData, 5813 satIntIo); 5814 return; 5815 break; 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) 5820 { 5821 smsatSetDeferredSensePayload( pSense, 5822 SCSI_SNSKEY_NO_SENSE, 5823 0, 5824 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5825 satOrgIOContext); 5826 } 5827 else 5828 { 5829 smsatSetDeferredSensePayload( pSense, 5830 SCSI_SNSKEY_NO_SENSE, 5831 0, 5832 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5833 satOrgIOContext); 5834 } 5835 5836 5837 tdsmIOCompletedCB( smRoot, 5838 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5839 smIOSuccess, 5840 SCSI_STAT_CHECK_CONDITION, 5841 satOrgIOContext->pSmSenseData, 5842 satOrgIOContext->interruptContext ); 5843 5844 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5845 5846 smsatFreeIntIoResource( smRoot, 5847 oneDeviceData, 5848 satIntIo); 5849 return; 5850 break; 5851 default: 5852 SM_DBG1(("smsatSynchronizeCache10n16CB: error unknown command 0x%x!!!\n", hostToDevFis->h.command)); 5853 smsatSetSensePayload( pSense, 5854 SCSI_SNSKEY_NO_SENSE, 5855 0, 5856 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5857 satOrgIOContext); 5858 5859 5860 tdsmIOCompletedCB( smRoot, 5861 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5862 smIOSuccess, 5863 SCSI_STAT_CHECK_CONDITION, 5864 satOrgIOContext->pSmSenseData, 5865 satOrgIOContext->interruptContext ); 5866 5867 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5868 5869 smsatFreeIntIoResource( smRoot, 5870 oneDeviceData, 5871 satIntIo); 5872 return; 5873 break; 5874 } 5875 5876 return; 5877 } /* end of error checking */ 5878 } 5879 5880 /* prcessing the success case */ 5881 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 5882 5883 smsatFreeIntIoResource( smRoot, 5884 oneDeviceData, 5885 satIntIo); 5886 5887 5888 switch (hostToDevFis->h.command) 5889 { 5890 case SAT_FLUSH_CACHE: 5891 SM_DBG5(("smsatSynchronizeCache10n16CB: SAT_FLUSH_CACHE success\n")); 5892 5893 /* checking IMMED bit */ 5894 if ( !(scsiCmnd->cdb[1] & SCSI_FLUSH_CACHE_IMMED_MASK)) 5895 { 5896 tdsmIOCompletedCB( smRoot, 5897 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5898 smIOSuccess, 5899 SCSI_STAT_GOOD, 5900 agNULL, 5901 satOrgIOContext->interruptContext ); 5902 return; 5903 } 5904 5905 5906 break; 5907 case SAT_FLUSH_CACHE_EXT: 5908 SM_DBG5(("smsatSynchronizeCache10n16CB: SAT_FLUSH_CACHE_EXT success\n")); 5909 5910 /* checking IMMED bit */ 5911 if ( !(scsiCmnd->cdb[1] & SCSI_FLUSH_CACHE_IMMED_MASK)) 5912 { 5913 tdsmIOCompletedCB( smRoot, 5914 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5915 smIOSuccess, 5916 SCSI_STAT_GOOD, 5917 agNULL, 5918 satOrgIOContext->interruptContext ); 5919 return; 5920 } 5921 5922 break; 5923 default: 5924 SM_DBG5(("smsatSynchronizeCache10n16CB: error unknown command 0x%x\n", hostToDevFis->h.command)); 5925 smsatSetSensePayload( pSense, 5926 SCSI_SNSKEY_NO_SENSE, 5927 0, 5928 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5929 satOrgIOContext); 5930 5931 5932 tdsmIOCompletedCB( smRoot, 5933 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 5934 smIOSuccess, 5935 SCSI_STAT_CHECK_CONDITION, 5936 satOrgIOContext->pSmSenseData, 5937 satOrgIOContext->interruptContext ); 5938 5939 return; 5940 break; 5941 } 5942 5943 return; 5944 } 5945 5946 //qqqqqqqq 5947 osGLOBAL void 5948 smsatNonChainedWriteNVerifyCB( 5949 agsaRoot_t *agRoot, 5950 agsaIORequest_t *agIORequest, 5951 bit32 agIOStatus, 5952 agsaFisHeader_t *agFirstDword, 5953 bit32 agIOInfoLen, 5954 void *agParam, 5955 void *ioContext 5956 ) 5957 { 5958 /* 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 5966 chained command 5967 */ 5968 5969 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; 5982 5983 smScsiRspSense_t *pSense; 5984 smIniScsiCmnd_t *scsiCmnd; 5985 smIORequest_t *smOrgIORequest; 5986 5987 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 5988 bit32 ataStatus = 0; 5989 bit32 status; 5990 smScsiInitiatorRequest_t *smScsiRequest; /* smScsiXchg */ 5991 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 5992 agsaFisSetDevBitsHeader_t *statSetDevBitFisHeader = agNULL; 5993 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; 6003 6004 /* SPC: Self-Test Result Log page */ 6005 smScsiRequest = satIOContext->smScsiXchg; 6006 6007 SM_DBG2(("smsatNonChainedWriteNVerifyCB: start\n")); 6008 SM_DBG5(("smsatNonChainedWriteNVerifyCB: start agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 6009 6010 6011 if (satIntIo == agNULL) 6012 { 6013 SM_DBG4(("smsatNonChainedWriteNVerifyCB: External smSatInternalIo_t satIntIoContext\n")); 6014 satOrgIOContext = satIOContext; 6015 smOrgIORequest = smIORequestBody->smIORequest; 6016 pSense = satOrgIOContext->pSense; 6017 scsiCmnd = satOrgIOContext->pScsiCmnd; 6018 } 6019 else 6020 { 6021 SM_DBG4(("smsatNonChainedWriteNVerifyCB: Internal smSatInternalIo_t satIntIoContext\n")); 6022 satOrgIOContext = satIOContext->satOrgIOContext; 6023 if (satOrgIOContext == agNULL) 6024 { 6025 SM_DBG4(("smsatNonChainedWriteNVerifyCB: satOrgIOContext is NULL, wrong\n")); 6026 return; 6027 } 6028 else 6029 { 6030 SM_DBG4(("smsatNonChainedWriteNVerifyCB: satOrgIOContext is NOT NULL\n")); 6031 } 6032 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 6033 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 6034 6035 pSense = satOrgIOContext->pSense; 6036 scsiCmnd = satOrgIOContext->pScsiCmnd; 6037 } 6038 6039 smIORequestBody->ioCompleted = agTRUE; 6040 smIORequestBody->ioStarted = agFALSE; 6041 6042 6043 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 6044 { 6045 SM_DBG1(("smsatNonChainedWriteNVerifyCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 6046 tdsmIOCompletedCB( smRoot, 6047 smOrgIORequest, 6048 smIOFailed, 6049 smDetailOtherError, 6050 agNULL, 6051 satOrgIOContext->interruptContext 6052 ); 6053 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6054 6055 smsatFreeIntIoResource( smRoot, 6056 oneDeviceData, 6057 satIntIo); 6058 return; 6059 } 6060 6061 6062 if (agIOStatus != OSSA_IO_SUCCESS) 6063 { 6064 /* 6065 FIS type should be either REG_DEV_TO_HOST_FIS or SET_DEV_BITS_FIS 6066 */ 6067 /* First, assumed to be Reg Device to Host FIS */ 6068 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 6069 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 6070 } 6071 6072 if (agIOStatus != OSSA_IO_SUCCESS) 6073 { 6074 if (statDevToHostFisHeader->fisType == SET_DEV_BITS_FIS) 6075 { 6076 statSetDevBitFisHeader = (agsaFisSetDevBitsHeader_t *)&(agFirstDword->D2H); 6077 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 */ 6081 } 6082 } 6083 6084 6085 if( agIOStatus != OSSA_IO_SUCCESS) 6086 { 6087 /* 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 6091 */ 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)) 6095 ) 6096 { 6097 /* for debugging */ 6098 if( agIOStatus != OSSA_IO_SUCCESS) 6099 { 6100 SM_DBG1(("smsatNonChainedWriteNVerifyCB: FAILED, NOT IO_SUCCESS!!!\n")); 6101 } 6102 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 6103 { 6104 SM_DBG1(("smsatNonChainedWriteNVerifyCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 6105 } 6106 else if (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS) 6107 { 6108 SM_DBG1(("smsatNonChainedWriteNVerifyCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 6109 } 6110 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 6111 (ataStatus & DF_ATA_STATUS_MASK) 6112 ) 6113 { 6114 SM_DBG1(("smsatNonChainedWriteNVerifyCB: FAILED, FAILED, error status!!!\n")); 6115 } 6116 6117 6118 /* Process abort case */ 6119 if (agIOStatus == OSSA_IO_ABORTED) 6120 { 6121 smsatProcessAbort(smRoot, 6122 smOrgIORequest, 6123 satOrgIOContext 6124 ); 6125 6126 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6127 6128 smsatFreeIntIoResource( smRoot, 6129 oneDeviceData, 6130 satIntIo); 6131 return; 6132 } 6133 6134 /* for debugging */ 6135 switch (hostToDevFis->h.command) 6136 { 6137 case SAT_WRITE_DMA_FUA_EXT: 6138 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_DMA_FUA_EXT!!!\n")); 6139 break; 6140 case SAT_WRITE_DMA_EXT: 6141 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_DMA_EXT!!!\n")); 6142 break; 6143 case SAT_WRITE_SECTORS_EXT: 6144 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_SECTORS_EXT!!!\n")); 6145 break; 6146 case SAT_WRITE_FPDMA_QUEUED: 6147 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_FPDMA_QUEUED!!!\n")); 6148 break; 6149 case SAT_READ_VERIFY_SECTORS: 6150 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS!!!\n")); 6151 break; 6152 case SAT_READ_VERIFY_SECTORS_EXT: 6153 SM_DBG1(("smsatNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS_EXT!!!\n")); 6154 break; 6155 default: 6156 SM_DBG1(("smsatNonChainedWriteNVerifyCB: error default case command 0x%x!!!\n", hostToDevFis->h.command)); 6157 break; 6158 } 6159 6160 smsatSetSensePayload( pSense, 6161 SCSI_SNSKEY_NO_SENSE, 6162 0, 6163 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6164 satOrgIOContext); 6165 6166 tdsmIOCompletedCB( smRoot, 6167 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6168 smIOSuccess, 6169 SCSI_STAT_CHECK_CONDITION, 6170 satOrgIOContext->pSmSenseData, 6171 satOrgIOContext->interruptContext ); 6172 6173 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6174 6175 smsatFreeIntIoResource( smRoot, 6176 oneDeviceData, 6177 satIntIo); 6178 return; 6179 } /* end error checking */ 6180 } 6181 6182 /* process success from this point on */ 6183 6184 switch (hostToDevFis->h.command) 6185 { 6186 case SAT_WRITE_DMA_FUA_EXT: 6187 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_DMA_FUA_EXT success\n")); 6188 break; 6189 case SAT_WRITE_DMA_EXT: 6190 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_DMA_EXT success\n")); 6191 break; 6192 case SAT_WRITE_SECTORS_EXT: 6193 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_SECTORS_EXT succes\n")); 6194 6195 break; 6196 case SAT_WRITE_FPDMA_QUEUED: 6197 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_WRITE_FPDMA_QUEUED succes\n")); 6198 break; 6199 case SAT_READ_VERIFY_SECTORS: 6200 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS succes\n")); 6201 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6202 6203 /* free */ 6204 smsatFreeIntIoResource( smRoot, 6205 oneDeviceData, 6206 satIntIo); 6207 6208 /* return stat_good */ 6209 tdsmIOCompletedCB( smRoot, 6210 smOrgIORequest, 6211 smIOSuccess, 6212 SCSI_STAT_GOOD, 6213 agNULL, 6214 satOrgIOContext->interruptContext ); 6215 return; 6216 break; 6217 case SAT_READ_VERIFY_SECTORS_EXT: 6218 SM_DBG5(("smsatNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS_EXT succes\n")); 6219 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6220 6221 /* free */ 6222 smsatFreeIntIoResource( smRoot, 6223 oneDeviceData, 6224 satIntIo); 6225 6226 /* return stat_good */ 6227 tdsmIOCompletedCB( smRoot, 6228 smOrgIORequest, 6229 smIOSuccess, 6230 SCSI_STAT_GOOD, 6231 agNULL, 6232 satOrgIOContext->interruptContext ); 6233 return; 6234 break; 6235 default: 6236 SM_DBG1(("smsatNonChainedWriteNVerifyCB: error default case command 0x%x success!!!\n", hostToDevFis->h.command)); 6237 6238 smsatSetSensePayload( pSense, 6239 SCSI_SNSKEY_NO_SENSE, 6240 0, 6241 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6242 satOrgIOContext); 6243 6244 tdsmIOCompletedCB( smRoot, 6245 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6246 smIOSuccess, 6247 SCSI_STAT_CHECK_CONDITION, 6248 satOrgIOContext->pSmSenseData, 6249 satOrgIOContext->interruptContext ); 6250 6251 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6252 6253 smsatFreeIntIoResource( smRoot, 6254 oneDeviceData, 6255 satIntIo); 6256 return; 6257 break; 6258 } 6259 6260 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6261 6262 /* free */ 6263 smsatFreeIntIoResource( smRoot, 6264 oneDeviceData, 6265 satIntIo); 6266 6267 satNewIntIo = smsatAllocIntIoResource( smRoot, 6268 smOrgIORequest, 6269 oneDeviceData, 6270 0, 6271 satNewIntIo); 6272 if (satNewIntIo == agNULL) 6273 { 6274 smsatSetSensePayload( pSense, 6275 SCSI_SNSKEY_NO_SENSE, 6276 0, 6277 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6278 satOrgIOContext); 6279 6280 tdsmIOCompletedCB( smRoot, 6281 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6282 smIOSuccess, 6283 SCSI_STAT_CHECK_CONDITION, 6284 satOrgIOContext->pSmSenseData, 6285 satOrgIOContext->interruptContext ); 6286 SM_DBG1(("smsatNonChainedWriteNVerifyCB: momory allocation fails!!!\n")); 6287 return; 6288 } /* end memory allocation */ 6289 6290 satNewIOContext = smsatPrepareNewIO(satNewIntIo, 6291 smOrgIORequest, 6292 oneDeviceData, 6293 scsiCmnd, 6294 satOrgIOContext 6295 ); 6296 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 */ 6302 satNewIOContext 6303 ); 6304 6305 6306 if (status != SM_RC_SUCCESS) 6307 { 6308 /* sending ATA command fails */ 6309 smsatFreeIntIoResource( smRoot, 6310 oneDeviceData, 6311 satNewIntIo); 6312 smsatSetSensePayload( pSense, 6313 SCSI_SNSKEY_NO_SENSE, 6314 0, 6315 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6316 satOrgIOContext); 6317 6318 tdsmIOCompletedCB( smRoot, 6319 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6320 smIOSuccess, 6321 SCSI_STAT_CHECK_CONDITION, 6322 satOrgIOContext->pSmSenseData, 6323 satOrgIOContext->interruptContext ); 6324 SM_DBG1(("smsatNonChainedWriteNVerifyCB: calling satWriteAndVerify10_1 fails!!!\n")); 6325 return; 6326 } /* end send fails */ 6327 6328 return; 6329 6330 } 6331 6332 osGLOBAL void 6333 smsatChainedWriteNVerifyCB( 6334 agsaRoot_t *agRoot, 6335 agsaIORequest_t *agIORequest, 6336 bit32 agIOStatus, 6337 agsaFisHeader_t *agFirstDword, 6338 bit32 agIOInfoLen, 6339 void *agParam, 6340 void *ioContext 6341 ) 6342 { 6343 /* 6344 send write in loop 6345 then, send verify in loop 6346 */ 6347 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; 6364 6365 smScsiRspSense_t *pSense; 6366 smIniScsiCmnd_t *scsiCmnd; 6367 smIORequest_t *smOrgIORequest; 6368 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 6369 bit32 ataStatus = 0; 6370 bit32 dataLength; 6371 bit32 status = tiError; 6372 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 6373 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)); 6385 6386 if (satIntIo == agNULL) 6387 { 6388 SM_DBG5(("smsatChainedWriteNVerifyCB: External smSatInternalIo_t satIntIoContext\n")); 6389 satOrgIOContext = satIOContext; 6390 smOrgIORequest = smIORequestBody->smIORequest; 6391 pSense = satIOContext->pSense; 6392 scsiCmnd = satIOContext->pScsiCmnd; 6393 } 6394 else 6395 { 6396 SM_DBG5(("smsatChainedWriteNVerifyCB: Internal smSatInternalIo_t satIntIoContext\n")); 6397 satOrgIOContext = satIOContext->satOrgIOContext; 6398 if (satOrgIOContext == agNULL) 6399 { 6400 SM_DBG5(("smsatChainedWriteNVerifyCB: satOrgIOContext is NULL, wrong\n")); 6401 return; 6402 } 6403 else 6404 { 6405 SM_DBG5(("smsatChainedWriteNVerifyCB: satOrgIOContext is NOT NULL\n")); 6406 } 6407 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 6408 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 6409 6410 pSense = satOrgIOContext->pSense; 6411 scsiCmnd = satOrgIOContext->pScsiCmnd; 6412 } 6413 6414 smIORequestBody->ioCompleted = agTRUE; 6415 smIORequestBody->ioStarted = agFALSE; 6416 6417 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 6418 { 6419 SM_DBG1(("smsatChainedWriteNVerifyCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 6420 smsatSetSensePayload( pSense, 6421 SCSI_SNSKEY_NO_SENSE, 6422 0, 6423 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6424 satOrgIOContext); 6425 6426 tdsmIOCompletedCB( smRoot, 6427 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6428 smIOSuccess, 6429 SCSI_STAT_CHECK_CONDITION, 6430 satOrgIOContext->pSmSenseData, 6431 satOrgIOContext->interruptContext ); 6432 6433 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6434 6435 smsatFreeIntIoResource( smRoot, 6436 oneDeviceData, 6437 satIntIo); 6438 return; 6439 } 6440 6441 /* 6442 checking IO status, FIS type and error status 6443 */ 6444 if (agIOStatus != OSSA_IO_SUCCESS) 6445 { 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 6450 */ 6451 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 6452 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 6453 /* for debugging */ 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) 6457 ) 6458 { 6459 SM_DBG1(("smsatChainedWriteNVerifyCB: FAILED, Wrong FIS type 0x%x!!!\n", statDevToHostFisHeader->fisType)); 6460 } 6461 6462 /* for debugging */ 6463 if ( (ataStatus & ERR_ATA_STATUS_MASK) || 6464 (ataStatus & DF_ATA_STATUS_MASK) 6465 ) 6466 { 6467 SM_DBG1(("smsatChainedWriteNVerifyCB: FAILED, error status and command 0x%x!!!\n", hostToDevFis->h.command)); 6468 } 6469 6470 /* the function below handles abort case */ 6471 smsatDelayedProcessAbnormalCompletion(agRoot, 6472 agIORequest, 6473 agIOStatus, 6474 agFirstDword, 6475 agIOInfoLen, 6476 agParam, 6477 satIOContext); 6478 6479 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6480 smsatFreeIntIoResource( smRoot, 6481 oneDeviceData, 6482 satIntIo); 6483 return; 6484 } /* end of error */ 6485 6486 /* process the success case */ 6487 switch (hostToDevFis->h.command) 6488 { 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: 6495 6496 SM_DBG5(("smsatChainedWriteNVerifyCB: WRITE success case\n")); 6497 6498 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6499 6500 /* done with internally genereated SAT_SMART_RETURN_STATUS */ 6501 smsatFreeIntIoResource( smRoot, 6502 oneDeviceData, 6503 satIntIo); 6504 /* let's loop till TL */ 6505 6506 /* lba = lba + tl 6507 loopnum--; 6508 if (loopnum == 0) done 6509 */ 6510 (satOrgIOContext->LoopNum)--; 6511 6512 if (satOrgIOContext->superIOFlag) 6513 { 6514 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength; 6515 } 6516 else 6517 { 6518 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength; 6519 } 6520 6521 satNewIntIo = smsatAllocIntIoResource( smRoot, 6522 smOrgIORequest, 6523 oneDeviceData, 6524 dataLength, 6525 satNewIntIo); 6526 if (satNewIntIo == agNULL) 6527 { 6528 tdsmIOCompletedCB( smRoot, 6529 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6530 smIOFailed, 6531 smDetailOtherError, 6532 agNULL, 6533 satOrgIOContext->interruptContext ); 6534 6535 SM_DBG1(("smsatChainedWriteNVerifyCB: momory allocation fails!!!\n")); 6536 return; 6537 } /* end of memory allocation failure */ 6538 6539 /* 6540 * Need to initialize all the fields within satIOContext 6541 */ 6542 6543 satNewIOContext = smsatPrepareNewIO( 6544 satNewIntIo, 6545 smOrgIORequest, 6546 oneDeviceData, 6547 scsiCmnd, 6548 satOrgIOContext 6549 ); 6550 6551 if (satOrgIOContext->LoopNum == 0) 6552 { 6553 /* 6554 done with write 6555 start with verify 6556 */ 6557 satOrgIOContext->LoopNum = satOrgIOContext->LoopNum2; 6558 status = smsatChainedWriteNVerify_Start_Verify(smRoot, 6559 &satNewIntIo->satIntSmIORequest, 6560 satNewIOContext->psmDeviceHandle, 6561 &satNewIntIo->satIntSmScsiXchg, 6562 satNewIOContext); 6563 } 6564 else 6565 { 6566 status = smsatChainedWriteNVerify_Write(smRoot, 6567 &satNewIntIo->satIntSmIORequest, 6568 satNewIOContext->psmDeviceHandle, 6569 &satNewIntIo->satIntSmScsiXchg, 6570 satNewIOContext); 6571 } 6572 6573 if (status != SM_RC_SUCCESS) 6574 { 6575 smsatFreeIntIoResource( smRoot, 6576 oneDeviceData, 6577 satNewIntIo); 6578 tdsmIOCompletedCB( smRoot, 6579 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6580 smIOFailed, 6581 smDetailOtherError, 6582 agNULL, 6583 satOrgIOContext->interruptContext ); 6584 SM_DBG1(("smsatChainedWriteNVerifyCB: calling satChainedWriteNVerify_Write fails!!!\n")); 6585 return; 6586 } 6587 6588 break; 6589 6590 case SAT_READ_VERIFY_SECTORS: /* fall through */ 6591 case SAT_READ_VERIFY_SECTORS_EXT: 6592 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6593 6594 /* done with internally genereated SAT_SMART_RETURN_STATUS */ 6595 smsatFreeIntIoResource( smRoot, 6596 oneDeviceData, 6597 satIntIo); 6598 /* let's loop till TL */ 6599 6600 /* lba = lba + tl 6601 loopnum--; 6602 if (loopnum == 0) done 6603 */ 6604 (satOrgIOContext->LoopNum)--; 6605 if (satOrgIOContext->LoopNum == 0) 6606 { 6607 /* 6608 done with write and verify 6609 */ 6610 tdsmIOCompletedCB( smRoot, 6611 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6612 smIOSuccess, 6613 SCSI_STAT_GOOD, 6614 agNULL, 6615 satOrgIOContext->interruptContext ); 6616 return; 6617 } 6618 6619 if (satOrgIOContext->superIOFlag) 6620 { 6621 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength; 6622 } 6623 else 6624 { 6625 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->smScsiXchg)->scsiCmnd.expDataLength; 6626 } 6627 6628 satNewIntIo = smsatAllocIntIoResource( smRoot, 6629 smOrgIORequest, 6630 oneDeviceData, 6631 dataLength, 6632 satNewIntIo); 6633 if (satNewIntIo == agNULL) 6634 { 6635 tdsmIOCompletedCB( smRoot, 6636 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6637 smIOFailed, 6638 smDetailOtherError, 6639 agNULL, 6640 satOrgIOContext->interruptContext ); 6641 6642 SM_DBG1(("smsatChainedWriteNVerifyCB: momory allocation fails!!!\n")); 6643 return; 6644 } /* end of memory allocation failure */ 6645 6646 /* 6647 * Need to initialize all the fields within satIOContext 6648 */ 6649 6650 satNewIOContext = smsatPrepareNewIO( 6651 satNewIntIo, 6652 smOrgIORequest, 6653 oneDeviceData, 6654 scsiCmnd, 6655 satOrgIOContext 6656 ); 6657 status = smsatChainedWriteNVerify_Verify(smRoot, 6658 &satNewIntIo->satIntSmIORequest, 6659 satNewIOContext->psmDeviceHandle, 6660 &satNewIntIo->satIntSmScsiXchg, 6661 satNewIOContext); 6662 6663 if (status != SM_RC_SUCCESS) 6664 { 6665 smsatFreeIntIoResource( smRoot, 6666 oneDeviceData, 6667 satNewIntIo); 6668 tdsmIOCompletedCB( smRoot, 6669 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6670 smIOFailed, 6671 smDetailOtherError, 6672 agNULL, 6673 satOrgIOContext->interruptContext ); 6674 SM_DBG1(("smsatChainedWriteNVerifyCB: calling satChainedWriteNVerify_Verify fails!!!\n")); 6675 return; 6676 } 6677 6678 break; 6679 6680 default: 6681 SM_DBG1(("smsatChainedWriteNVerifyCB: success but default case command 0x%x!!!\n",hostToDevFis->h.command)); 6682 tdsmIOCompletedCB( smRoot, 6683 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6684 smIOFailed, 6685 smDetailOtherError, 6686 agNULL, 6687 satOrgIOContext->interruptContext ); 6688 6689 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6690 6691 smsatFreeIntIoResource( smRoot, 6692 oneDeviceData, 6693 satIntIo); 6694 6695 break; 6696 } 6697 6698 6699 return; 6700 } 6701 6702 osGLOBAL void 6703 smsatReadMediaSerialNumberCB( 6704 agsaRoot_t *agRoot, 6705 agsaIORequest_t *agIORequest, 6706 bit32 agIOStatus, 6707 agsaFisHeader_t *agFirstDword, 6708 bit32 agIOInfoLen, 6709 agsaFrameHandle_t agFrameHandle, 6710 void *ioContext 6711 ) 6712 { 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; 6727 6728 smScsiRspSense_t *pSense; 6729 smIORequest_t *smOrgIORequest; 6730 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; 6737 6738 SM_DBG2(("smsatReadMediaSerialNumberCB: start\n")); 6739 SM_DBG4(("smsatReadMediaSerialNumberCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 6740 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; 6750 6751 if (satIntIo == agNULL) 6752 { 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; 6762 } 6763 else 6764 { 6765 SM_DBG4(("smsatReadMediaSerialNumberCB: Internal smSatInternalIo_t satIntIoContext\n")); 6766 satOrgIOContext = satIOContext->satOrgIOContext; 6767 if (satOrgIOContext == agNULL) 6768 { 6769 SM_DBG4(("smsatReadMediaSerialNumberCB: satOrgIOContext is NULL, wrong\n")); 6770 return; 6771 } 6772 else 6773 { 6774 SM_DBG4(("smsatReadMediaSerialNumberCB: satOrgIOContext is NOT NULL\n")); 6775 } 6776 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 6777 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 6778 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; 6784 } 6785 6786 smIORequestBody->ioCompleted = agTRUE; 6787 smIORequestBody->ioStarted = agFALSE; 6788 6789 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 6790 { 6791 SM_DBG1(("smsatReadMediaSerialNumberCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 6792 tdsmIOCompletedCB( 6793 smRoot, 6794 smOrgIORequest, 6795 smIOFailed, 6796 smDetailOtherError, 6797 agNULL, 6798 satOrgIOContext->interruptContext 6799 ); 6800 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6801 6802 smsatFreeIntIoResource( smRoot, 6803 oneDeviceData, 6804 satIntIo); 6805 return; 6806 } 6807 6808 if( agIOStatus != OSSA_IO_SUCCESS) 6809 { 6810 /* Process abort case */ 6811 if (agIOStatus == OSSA_IO_ABORTED) 6812 { 6813 smsatProcessAbort(smRoot, 6814 smOrgIORequest, 6815 satOrgIOContext 6816 ); 6817 6818 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6819 6820 smsatFreeIntIoResource( smRoot, 6821 oneDeviceData, 6822 satIntIo); 6823 return; 6824 } 6825 smsatSetSensePayload( pSense, 6826 SCSI_SNSKEY_NOT_READY, 6827 0, 6828 SCSI_SNSCODE_MEDIUM_NOT_PRESENT, 6829 satOrgIOContext); 6830 6831 tdsmIOCompletedCB( smRoot, 6832 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6833 smIOSuccess, 6834 SCSI_STAT_CHECK_CONDITION, 6835 satOrgIOContext->pSmSenseData, 6836 satOrgIOContext->interruptContext ); 6837 6838 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6839 6840 smsatFreeIntIoResource( smRoot, 6841 oneDeviceData, 6842 satIntIo); 6843 return; 6844 } 6845 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)); 6851 6852 if (hostToDevFis->h.command == SAT_READ_SECTORS || 6853 hostToDevFis->h.command == SAT_READ_SECTORS_EXT 6854 ) 6855 { 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; 6864 6865 sm_memcpy(pMediaSerialNumber, MediaSerialNumber, MIN(allocationLen, ZERO_MEDIA_SERIAL_NUMBER_LENGTH)); 6866 if (ZERO_MEDIA_SERIAL_NUMBER_LENGTH < allocationLen) 6867 { 6868 SM_DBG1(("smsatReadMediaSerialNumberCB: 1st underrun allocationLen %d len %d !!!\n", allocationLen, ZERO_MEDIA_SERIAL_NUMBER_LENGTH)); 6869 6870 /* underrun */ 6871 tdsmIOCompletedCB( smRoot, 6872 smOrgIORequest, /* == satIntIo->satOrgSmIORequest */ 6873 smIOUnderRun, 6874 allocationLen - ZERO_MEDIA_SERIAL_NUMBER_LENGTH, 6875 agNULL, 6876 satOrgIOContext->interruptContext ); 6877 6878 } 6879 else 6880 { 6881 tdsmIOCompletedCB( smRoot, 6882 smOrgIORequest, 6883 smIOSuccess, 6884 SCSI_STAT_GOOD, 6885 agNULL, 6886 satOrgIOContext->interruptContext); 6887 } 6888 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6889 6890 smsatFreeIntIoResource( smRoot, 6891 oneDeviceData, 6892 satIntIo); 6893 return; 6894 } 6895 else 6896 { 6897 SM_DBG1(("smsatReadMediaSerialNumberCB: error unknown command success 0x%x!!!\n", hostToDevFis->h.command)); 6898 smsatSetSensePayload( pSense, 6899 SCSI_SNSKEY_NO_SENSE, 6900 0, 6901 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6902 satOrgIOContext); 6903 6904 tdsmIOCompletedCB( smRoot, 6905 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 6906 smIOSuccess, 6907 SCSI_STAT_CHECK_CONDITION, 6908 satOrgIOContext->pSmSenseData, 6909 satOrgIOContext->interruptContext ); 6910 6911 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6912 6913 smsatFreeIntIoResource( smRoot, 6914 oneDeviceData, 6915 satIntIo); 6916 6917 return; 6918 } 6919 return; 6920 } 6921 6922 osGLOBAL void 6923 smsatReadBufferCB( 6924 agsaRoot_t *agRoot, 6925 agsaIORequest_t *agIORequest, 6926 bit32 agIOStatus, 6927 agsaFisHeader_t *agFirstDword, 6928 bit32 agIOInfoLen, 6929 agsaFrameHandle_t agFrameHandle, 6930 void *ioContext 6931 ) 6932 { 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; 6945 6946 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) 6959 { 6960 SM_DBG4(("smsatReadBufferCB: External smSatInternalIo_t satIntIoContext\n")); 6961 satOrgIOContext = satIOContext; 6962 smOrgIORequest = smIORequestBody->smIORequest; 6963 pSense = satOrgIOContext->pSense; 6964 } 6965 else 6966 { 6967 SM_DBG4(("smsatReadBufferCB: Internal smSatInternalIo_t satIntIoContext\n")); 6968 satOrgIOContext = satIOContext->satOrgIOContext; 6969 if (satOrgIOContext == agNULL) 6970 { 6971 SM_DBG4(("smsatReadBufferCB: satOrgIOContext is NULL, wrong\n")); 6972 return; 6973 } 6974 else 6975 { 6976 SM_DBG4(("smsatReadBufferCB: satOrgIOContext is NOT NULL\n")); 6977 } 6978 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 6979 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 6980 pSense = satOrgIOContext->pSense; 6981 } 6982 smIORequestBody->ioCompleted = agTRUE; 6983 smIORequestBody->ioStarted = agFALSE; 6984 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 6985 { 6986 SM_DBG1(("smsatReadBufferCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 6987 tdsmIOCompletedCB( 6988 smRoot, 6989 smOrgIORequest, 6990 smIOFailed, 6991 smDetailOtherError, 6992 agNULL, 6993 satOrgIOContext->interruptContext 6994 ); 6995 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 6996 6997 smsatFreeIntIoResource( smRoot, 6998 oneDeviceData, 6999 satIntIo); 7000 return; 7001 } 7002 7003 if( agIOStatus != OSSA_IO_SUCCESS) 7004 { 7005 /* Process abort case */ 7006 if (agIOStatus == OSSA_IO_ABORTED) 7007 { 7008 smsatProcessAbort(smRoot, 7009 smOrgIORequest, 7010 satOrgIOContext 7011 ); 7012 7013 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7014 7015 smsatFreeIntIoResource( smRoot, 7016 oneDeviceData, 7017 satIntIo); 7018 return; 7019 } 7020 smsatSetSensePayload( pSense, 7021 SCSI_SNSKEY_NOT_READY, 7022 0, 7023 SCSI_SNSCODE_MEDIUM_NOT_PRESENT, 7024 satOrgIOContext); 7025 7026 tdsmIOCompletedCB( smRoot, 7027 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 7028 smIOSuccess, 7029 SCSI_STAT_CHECK_CONDITION, 7030 satOrgIOContext->pSmSenseData, 7031 satOrgIOContext->interruptContext ); 7032 7033 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7034 7035 smsatFreeIntIoResource( smRoot, 7036 oneDeviceData, 7037 satIntIo); 7038 return; 7039 } 7040 7041 /* process success case */ 7042 if (hostToDevFis->h.command == SAT_READ_BUFFER ) 7043 { 7044 7045 tdsmIOCompletedCB( smRoot, 7046 smOrgIORequest, 7047 smIOSuccess, 7048 SCSI_STAT_GOOD, 7049 agNULL, 7050 satOrgIOContext->interruptContext); 7051 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7052 7053 smsatFreeIntIoResource( smRoot, 7054 oneDeviceData, 7055 satIntIo); 7056 return; 7057 } 7058 else 7059 { 7060 SM_DBG1(("smsatReadBufferCB: error unknown command success 0x%x!!!\n", hostToDevFis->h.command)); 7061 smsatSetSensePayload( pSense, 7062 SCSI_SNSKEY_NO_SENSE, 7063 0, 7064 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 7065 satOrgIOContext); 7066 7067 tdsmIOCompletedCB( smRoot, 7068 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 7069 smIOSuccess, 7070 SCSI_STAT_CHECK_CONDITION, 7071 satOrgIOContext->pSmSenseData, 7072 satOrgIOContext->interruptContext ); 7073 7074 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7075 7076 smsatFreeIntIoResource( smRoot, 7077 oneDeviceData, 7078 satIntIo); 7079 7080 return; 7081 } 7082 7083 return; 7084 } 7085 7086 osGLOBAL void 7087 smsatWriteBufferCB( 7088 agsaRoot_t *agRoot, 7089 agsaIORequest_t *agIORequest, 7090 bit32 agIOStatus, 7091 agsaFisHeader_t *agFirstDword, 7092 bit32 agIOInfoLen, 7093 agsaFrameHandle_t agFrameHandle, 7094 void *ioContext 7095 ) 7096 { 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; 7109 7110 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) 7123 { 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; 7130 } 7131 else 7132 { 7133 SM_DBG4(("smsatWriteBufferCB: Internal smSatInternalIo_t satIntIoContext\n")); 7134 satOrgIOContext = satIOContext->satOrgIOContext; 7135 if (satOrgIOContext == agNULL) 7136 { 7137 SM_DBG4(("smsatWriteBufferCB: satOrgIOContext is NULL, wrong\n")); 7138 return; 7139 } 7140 else 7141 { 7142 SM_DBG4(("smsatWriteBufferCB: satOrgIOContext is NOT NULL\n")); 7143 } 7144 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 7145 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 7146 pSense = satOrgIOContext->pSense; 7147 } 7148 smIORequestBody->ioCompleted = agTRUE; 7149 smIORequestBody->ioStarted = agFALSE; 7150 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 7151 { 7152 SM_DBG1(("smsatWriteBufferCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 7153 tdsmIOCompletedCB( 7154 smRoot, 7155 smOrgIORequest, 7156 smIOFailed, 7157 smDetailOtherError, 7158 agNULL, 7159 satOrgIOContext->interruptContext 7160 ); 7161 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7162 7163 smsatFreeIntIoResource( smRoot, 7164 oneDeviceData, 7165 satIntIo); 7166 return; 7167 } 7168 if( agIOStatus != OSSA_IO_SUCCESS) 7169 { 7170 /* Process abort case */ 7171 if (agIOStatus == OSSA_IO_ABORTED) 7172 { 7173 smsatProcessAbort(smRoot, 7174 smOrgIORequest, 7175 satOrgIOContext 7176 ); 7177 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7178 7179 smsatFreeIntIoResource( smRoot, 7180 oneDeviceData, 7181 satIntIo); 7182 return; 7183 } 7184 smsatSetSensePayload( pSense, 7185 SCSI_SNSKEY_NOT_READY, 7186 0, 7187 SCSI_SNSCODE_MEDIUM_NOT_PRESENT, 7188 satOrgIOContext); 7189 tdsmIOCompletedCB( smRoot, 7190 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 7191 smIOSuccess, 7192 SCSI_STAT_CHECK_CONDITION, 7193 satOrgIOContext->pSmSenseData, 7194 satOrgIOContext->interruptContext ); 7195 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7196 7197 smsatFreeIntIoResource( smRoot, 7198 oneDeviceData, 7199 satIntIo); 7200 return; 7201 } 7202 /* process success case */ 7203 if (hostToDevFis->h.command == SAT_WRITE_BUFFER ) 7204 { 7205 tdsmIOCompletedCB( smRoot, 7206 smOrgIORequest, 7207 smIOSuccess, 7208 SCSI_STAT_GOOD, 7209 agNULL, 7210 satOrgIOContext->interruptContext); 7211 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7212 7213 smsatFreeIntIoResource( smRoot, 7214 oneDeviceData, 7215 satIntIo); 7216 return; 7217 } 7218 else 7219 { 7220 SM_DBG1(("smsatWriteBufferCB: error unknown command success 0x%x!!!\n", hostToDevFis->h.command)); 7221 smsatSetSensePayload( pSense, 7222 SCSI_SNSKEY_NO_SENSE, 7223 0, 7224 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 7225 satOrgIOContext); 7226 tdsmIOCompletedCB( smRoot, 7227 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 7228 smIOSuccess, 7229 SCSI_STAT_CHECK_CONDITION, 7230 satOrgIOContext->pSmSenseData, 7231 satOrgIOContext->interruptContext ); 7232 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7233 smsatFreeIntIoResource( smRoot, 7234 oneDeviceData, 7235 satIntIo); 7236 return; 7237 } 7238 return; 7239 } 7240 7241 osGLOBAL void 7242 smsatReassignBlocksCB( 7243 agsaRoot_t *agRoot, 7244 agsaIORequest_t *agIORequest, 7245 bit32 agIOStatus, 7246 agsaFisHeader_t *agFirstDword, 7247 bit32 agIOInfoLen, 7248 agsaFrameHandle_t agFrameHandle, 7249 void *ioContext 7250 ) 7251 { 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; 7268 bit32 status; 7269 smScsiInitiatorRequest_t *smScsiRequest; /* smScsiXchg */ 7270 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 7271 7272 SM_DBG2(("smsatReassignBlocksCB: start\n")); 7273 SM_DBG5(("smsatReassignBlocksCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 7274 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) 7285 { 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; 7292 } 7293 else 7294 { 7295 SM_DBG4(("smsatReassignBlocksCB: Internal smSatInternalIo_t satIntIoContext\n")); 7296 satOrgIOContext = satIOContext->satOrgIOContext; 7297 if (satOrgIOContext == agNULL) 7298 { 7299 SM_DBG4(("smsatReassignBlocksCB: satOrgIOContext is NULL, Wrong\n")); 7300 return; 7301 } 7302 else 7303 { 7304 SM_DBG4(("smsatReassignBlocksCB: satOrgIOContext is NOT NULL, Wrong\n")); 7305 } 7306 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 7307 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 7308 smScsiRequest = satOrgIOContext->smScsiXchg; 7309 pSense = satOrgIOContext->pSense; 7310 scsiCmnd = satOrgIOContext->pScsiCmnd; 7311 } 7312 7313 smIORequestBody->ioCompleted = agTRUE; 7314 smIORequestBody->ioStarted = agFALSE; 7315 7316 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 7317 { 7318 SM_DBG1(("smsatReassignBlocksCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 7319 tdsmIOCompletedCB( 7320 smRoot, 7321 smOrgIORequest, 7322 smIOFailed, 7323 smDetailOtherError, 7324 agNULL, 7325 satOrgIOContext->interruptContext 7326 ); 7327 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7328 7329 smsatFreeIntIoResource( smRoot, 7330 oneDeviceData, 7331 satIntIo); 7332 return; 7333 } 7334 if (agIOStatus != OSSA_IO_SUCCESS) 7335 { 7336 /* only agsaFisRegDeviceToHost_t is expected */ 7337 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 7338 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 7339 } 7340 if (agIOStatus != OSSA_IO_SUCCESS) 7341 { 7342 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 7343 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 7344 ) 7345 { 7346 /* for debugging */ 7347 if( agIOStatus != OSSA_IO_SUCCESS) 7348 { 7349 SM_DBG1(("smsatReassignBlocksCB FAILED, NOT IO_SUCCESS!!!\n")); 7350 } 7351 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 7352 { 7353 SM_DBG1(("smsatReassignBlocksCB FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 7354 } 7355 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 7356 (ataStatus & DF_ATA_STATUS_MASK) 7357 ) 7358 { 7359 SM_DBG1(("smsatReassignBlocksCB FAILED, FAILED, error status!!!\n")); 7360 } 7361 7362 /* Process abort case */ 7363 if (agIOStatus == OSSA_IO_ABORTED) 7364 { 7365 smsatProcessAbort(smRoot, 7366 smOrgIORequest, 7367 satOrgIOContext 7368 ); 7369 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7370 7371 smsatFreeIntIoResource( smRoot, 7372 oneDeviceData, 7373 satIntIo); 7374 return; 7375 } 7376 /* for debugging */ 7377 if (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS || 7378 hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT 7379 ) 7380 { 7381 SM_DBG1(("smsatReassignBlocksCB SAT_READ_VERIFY_SECTORS(_EXT) failed!!!\n")); 7382 /* Verify failed; send Write with same LBA */ 7383 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7384 7385 smsatFreeIntIoResource( smRoot, 7386 oneDeviceData, 7387 satIntIo); 7388 7389 satNewIntIo = smsatAllocIntIoResource( smRoot, 7390 smOrgIORequest, 7391 oneDeviceData, 7392 512, /* writing 1 sector */ 7393 satNewIntIo); 7394 if (satNewIntIo == agNULL) 7395 { 7396 smsatSetSensePayload( pSense, 7397 SCSI_SNSKEY_HARDWARE_ERROR, 7398 0, 7399 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 7400 satOrgIOContext); 7401 tdsmIOCompletedCB( smRoot, 7402 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 7403 smIOSuccess, 7404 SCSI_STAT_CHECK_CONDITION, 7405 satOrgIOContext->pSmSenseData, 7406 satOrgIOContext->interruptContext ); 7407 SM_DBG1(("smsatReassignBlocksCB: momory allocation fails!!!\n")); 7408 return; 7409 } /* end memory allocation */ 7410 satNewIOContext = smsatPrepareNewIO( 7411 satNewIntIo, 7412 smOrgIORequest, 7413 oneDeviceData, 7414 scsiCmnd, 7415 satOrgIOContext 7416 ); 7417 /* send Write with same LBA */ 7418 status = smsatReassignBlocks_2( 7419 smRoot, 7420 &satNewIntIo->satIntSmIORequest, 7421 satNewIOContext->psmDeviceHandle, 7422 &satNewIntIo->satIntSmScsiXchg, 7423 satNewIOContext, 7424 satOrgIOContext->LBA 7425 ); 7426 7427 if (status != SM_RC_SUCCESS) 7428 { 7429 /* sending ATA command fails */ 7430 smsatFreeIntIoResource( smRoot, 7431 oneDeviceData, 7432 satNewIntIo); 7433 smsatSetSensePayload( pSense, 7434 SCSI_SNSKEY_HARDWARE_ERROR, 7435 0, 7436 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 7437 satOrgIOContext); 7438 7439 tdsmIOCompletedCB( smRoot, 7440 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 7441 smIOSuccess, 7442 SCSI_STAT_CHECK_CONDITION, 7443 satOrgIOContext->pSmSenseData, 7444 satOrgIOContext->interruptContext ); 7445 SM_DBG1(("smsatReassignBlocksCB calling fail 1!!!\n")); 7446 return; 7447 } /* end send fails */ 7448 7449 return; 7450 } 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 7456 ) 7457 { 7458 SM_DBG1(("smsatReassignBlocksCB SAT_WRITE failed!!!\n")); 7459 /* fall through */ 7460 } 7461 else 7462 { 7463 SM_DBG1(("smsatReassignBlocksCB error default case unexpected command 0x%x!!!\n", hostToDevFis->h.command)); 7464 } 7465 7466 7467 smsatSetSensePayload( pSense, 7468 SCSI_SNSKEY_HARDWARE_ERROR, 7469 0, 7470 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 7471 satOrgIOContext); 7472 7473 tdsmIOCompletedCB( smRoot, 7474 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 7475 smIOSuccess, 7476 SCSI_STAT_CHECK_CONDITION, 7477 satOrgIOContext->pSmSenseData, 7478 satOrgIOContext->interruptContext ); 7479 7480 7481 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7482 7483 smsatFreeIntIoResource( smRoot, 7484 oneDeviceData, 7485 satIntIo); 7486 return; 7487 } /* error checking */ 7488 } 7489 7490 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 7499 ) 7500 { 7501 /* next LBA; verify */ 7502 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7503 7504 smsatFreeIntIoResource( smRoot, 7505 oneDeviceData, 7506 satIntIo); 7507 7508 if (satOrgIOContext->ParmIndex >= satOrgIOContext->ParmLen) 7509 { 7510 SM_DBG5(("smsatReassignBlocksCB: GOOD status\n")); 7511 /* return stat_good */ 7512 tdsmIOCompletedCB( smRoot, 7513 smOrgIORequest, 7514 smIOSuccess, 7515 SCSI_STAT_GOOD, 7516 agNULL, 7517 satOrgIOContext->interruptContext ); 7518 return; 7519 } 7520 else 7521 { 7522 SM_DBG5(("smsatReassignBlocksCB: processing next LBA\n")); 7523 satNewIntIo = smsatAllocIntIoResource( smRoot, 7524 smOrgIORequest, 7525 oneDeviceData, 7526 0, 7527 satNewIntIo); 7528 if (satNewIntIo == agNULL) 7529 { 7530 smsatSetSensePayload( pSense, 7531 SCSI_SNSKEY_HARDWARE_ERROR, 7532 0, 7533 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 7534 satOrgIOContext); 7535 7536 tdsmIOCompletedCB( smRoot, 7537 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 7538 smIOSuccess, 7539 SCSI_STAT_CHECK_CONDITION, 7540 satOrgIOContext->pSmSenseData, 7541 satOrgIOContext->interruptContext ); 7542 SM_DBG1(("smsatReassignBlocksCB: momory allocation fails!!!\n")); 7543 return; 7544 } /* end memory allocation */ 7545 7546 satNewIOContext = smsatPrepareNewIO( 7547 satNewIntIo, 7548 smOrgIORequest, 7549 oneDeviceData, 7550 scsiCmnd, 7551 satOrgIOContext 7552 ); 7553 7554 /* send Verify with the next LBA */ 7555 status = smsatReassignBlocks_1( 7556 smRoot, 7557 &satNewIntIo->satIntSmIORequest, 7558 satNewIOContext->psmDeviceHandle, 7559 smScsiRequest, /* orginal from OS layer */ 7560 satNewIOContext, 7561 satOrgIOContext 7562 ); 7563 7564 if (status != SM_RC_SUCCESS) 7565 { 7566 /* sending ATA command fails */ 7567 smsatFreeIntIoResource( smRoot, 7568 oneDeviceData, 7569 satNewIntIo); 7570 smsatSetSensePayload( pSense, 7571 SCSI_SNSKEY_HARDWARE_ERROR, 7572 0, 7573 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 7574 satOrgIOContext); 7575 7576 tdsmIOCompletedCB( smRoot, 7577 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 7578 smIOSuccess, 7579 SCSI_STAT_CHECK_CONDITION, 7580 satOrgIOContext->pSmSenseData, 7581 satOrgIOContext->interruptContext ); 7582 SM_DBG1(("smsatReassignBlocksCB calling satModeSelect6_1 fails!!!\n")); 7583 return; 7584 } /* end send fails */ 7585 } /* else */ 7586 return; 7587 7588 } 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 7594 ) 7595 { 7596 /* next LBA; verify */ 7597 } 7598 else 7599 { 7600 SM_DBG1(("smsatReassignBlocksCB error unknown command success 0x%x !!!\n", hostToDevFis->h.command)); 7601 7602 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 7603 7604 smsatFreeIntIoResource( smRoot, 7605 oneDeviceData, 7606 satIntIo); 7607 smsatSetSensePayload( pSense, 7608 SCSI_SNSKEY_HARDWARE_ERROR, 7609 0, 7610 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 7611 satOrgIOContext); 7612 7613 tdsmIOCompletedCB( smRoot, 7614 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 7615 smIOSuccess, 7616 SCSI_STAT_CHECK_CONDITION, 7617 satOrgIOContext->pSmSenseData, 7618 satOrgIOContext->interruptContext ); 7619 return; 7620 } 7621 return; 7622 } 7623 7624 7625 osGLOBAL FORCEINLINE void 7626 smsatDecrementPendingIO( 7627 smRoot_t *smRoot, 7628 smIntContext_t *smAllShared, 7629 smSatIOContext_t *satIOContext 7630 ) 7631 { 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; 7643 #endif 7644 7645 SM_DBG3(("smsatDecrementPendingIO: start\n")); 7646 7647 #ifdef CCFLAG_OPTIMIZE_SAT_LOCK 7648 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 7649 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 7650 { 7651 tdsmInterlockedDecrement(smRoot,&oneDeviceData->satPendingNCQIO); 7652 } 7653 else 7654 { 7655 tdsmInterlockedDecrement(smRoot,&oneDeviceData->satPendingNONNCQIO); 7656 } 7657 tdsmInterlockedDecrement(smRoot,&oneDeviceData->satPendingIO); 7658 /* temp */ 7659 tdsmInterlockedExchange(smRoot, &satPendingNCQIO, oneDeviceData->satPendingNCQIO); 7660 tdsmInterlockedExchange(smRoot, &satPendingNONNCQIO, oneDeviceData->satPendingNONNCQIO); 7661 tdsmInterlockedExchange(smRoot, &satPendingIO, oneDeviceData->satPendingIO); 7662 if (satPendingNCQIO == -1) 7663 { 7664 SM_DBG1(("smsatDecrementPendingIO: satPendingNCQIO adjustment!!!\n")); 7665 oneDeviceData->satPendingNCQIO = 0; 7666 } 7667 if (satPendingNONNCQIO == -1) 7668 { 7669 SM_DBG1(("smsatDecrementPendingIO: satPendingNONNCQIO adjustment!!!\n")); 7670 oneDeviceData->satPendingNONNCQIO = 0; 7671 } 7672 if (satPendingIO == -1) 7673 { 7674 SM_DBG1(("smsatDecrementPendingIO: satPendingIO adjustment!!!\n")); 7675 oneDeviceData->satPendingIO = 0; 7676 } 7677 7678 #else 7679 7680 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 7681 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 7682 { 7683 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK); 7684 oneDeviceData->satPendingNCQIO--; 7685 oneDeviceData->satPendingIO--; 7686 SMLIST_DEQUEUE_THIS (&satIOContext->satIoContextLink); 7687 /* temp */ 7688 if (oneDeviceData->satPendingNCQIO == -1) 7689 { 7690 SM_DBG1(("smsatDecrementPendingIO: satPendingNCQIO adjustment!!!\n")); 7691 oneDeviceData->satPendingNCQIO = 0; 7692 } 7693 if (oneDeviceData->satPendingIO == -1) 7694 { 7695 SM_DBG1(("smsatDecrementPendingIO: satPendingIO adjustment!!!\n")); 7696 oneDeviceData->satPendingIO = 0; 7697 } 7698 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 7699 } 7700 else 7701 { 7702 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK); 7703 oneDeviceData->satPendingNONNCQIO--; 7704 oneDeviceData->satPendingIO--; 7705 SMLIST_DEQUEUE_THIS (&satIOContext->satIoContextLink); 7706 /* temp */ 7707 if (oneDeviceData->satPendingNONNCQIO == -1) 7708 { 7709 SM_DBG1(("smsatDecrementPendingIO: satPendingNONNCQIO adjustment!!!\n")); 7710 oneDeviceData->satPendingNONNCQIO = 0; 7711 } 7712 if (oneDeviceData->satPendingIO == -1) 7713 { 7714 SM_DBG1(("smsatDecrementPendingIO: satPendingIO adjustment!!!\n")); 7715 oneDeviceData->satPendingIO = 0; 7716 } 7717 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 7718 } 7719 7720 #endif /* CCFLAG_OPTIMIZE_SAT_LOCK */ 7721 7722 if (satIntIo == agNULL) 7723 { 7724 SM_DBG3(("smsatDecrementPendingIO: external command!!!\n")); 7725 /*smEnqueueIO(smRoot, satIOContext);*/ 7726 } 7727 else 7728 { 7729 SM_DBG3(("smsatDecrementPendingIO: internal command!!!\n")); 7730 if (satOrgIOContext == agNULL) 7731 { 7732 /* No smEnqueueIO since only alloc used */ 7733 SM_DBG3(("smsatDecrementPendingIO: internal only command!!!, ID %d!!!\n", smIORequestBody->id)); 7734 return; 7735 } 7736 else 7737 { 7738 /* smDequeueIO used */ 7739 /*smEnqueueIO(smRoot, satOrgIOContext);*/ 7740 } 7741 } 7742 7743 return; 7744 } 7745 7746 7747 osGLOBAL void 7748 smsatProcessAbnormalCompletion( 7749 agsaRoot_t *agRoot, 7750 agsaIORequest_t *agIORequest, 7751 bit32 agIOStatus, 7752 agsaFisHeader_t *agFirstDword, 7753 bit32 agIOInfoLen, 7754 void *agParam, 7755 smSatIOContext_t *satIOContext 7756 ) 7757 { 7758 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; 7768 7769 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 7770 oneDeviceData = satIOContext->pSatDevData; 7771 if (oneDeviceData == agNULL) 7772 { 7773 SM_DBG1(("smsatProcessAbnormalCompletion: oneDeviceData is NULL\n")); 7774 return; 7775 } 7776 smDeviceHandle = satIOContext->psmDeviceHandle; 7777 smRoot = oneDeviceData->smRoot; 7778 interruptContext = satIOContext->interruptContext; 7779 7780 SM_DBG5(("smsatProcessAbnormalCompletion: start\n")); 7781 7782 /* Get into the detail */ 7783 switch(agIOStatus) 7784 { 7785 case OSSA_IO_SUCCESS: 7786 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_SUCCESS agIOInfoLen 0x%x calling smsatIOCompleted!!!\n", agIOInfoLen)); 7787 /* 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. 7791 */ 7792 smsatIOCompleted( smRoot, 7793 smIORequestBody->smIORequest, 7794 agFirstDword, 7795 agIOInfoLen, 7796 agParam, 7797 satIOContext, 7798 interruptContext); 7799 break; 7800 7801 7802 case OSSA_IO_ABORTED: 7803 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORTED!!!\n")); 7804 7805 tdsmIOCompletedCB( smRoot, 7806 smIORequestBody->smIORequest, 7807 smIOFailed, 7808 smDetailAborted, 7809 agNULL, 7810 interruptContext); 7811 7812 #ifdef REMOVED 7813 if ( oneDeviceData->satTmTaskTag != agNULL ) 7814 { 7815 SM_DBG1(("smsatProcessAbnormalCompletion: TM callback!!!\n")); 7816 if (smDeviceHandle == agNULL) 7817 { 7818 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n")); 7819 } 7820 /* TM completed */ 7821 tdsmEventCB( smRoot, 7822 smDeviceHandle, 7823 smIntrEventTypeTaskManagement, 7824 smTMOK, 7825 oneDeviceData->satTmTaskTag); 7826 /* 7827 * Reset flag 7828 */ 7829 oneDeviceData->satTmTaskTag = agNULL; 7830 } 7831 #endif 7832 7833 /* 7834 * Check if we are in recovery mode and need to update the recovery flag 7835 */ 7836 if ((oneDeviceData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) && 7837 (oneDeviceData->satPendingIO == 0 )) 7838 { 7839 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL; 7840 SM_DBG1(("smsatProcessAbnormalCompletion: STATE NORMAL!!!\n")); 7841 } 7842 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)); 7846 7847 break; 7848 #ifdef REMOVED 7849 case OSSA_IO_OVERFLOW: 7850 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_OVERFLOW!!!\n")); 7851 tdsmIOCompletedCB( smRoot, 7852 smIORequestBody->smIORequest, 7853 smIOOverRun, 7854 agIOInfoLen, 7855 agNULL, 7856 interruptContext); 7857 break; 7858 #endif 7859 case OSSA_IO_UNDERFLOW: 7860 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_UNDERFLOW!!!\n")); 7861 tdsmIOCompletedCB( smRoot, 7862 smIORequestBody->smIORequest, 7863 smIOUnderRun, 7864 agIOInfoLen, 7865 agNULL, 7866 interruptContext); 7867 break; 7868 7869 7870 case OSSA_IO_FAILED: 7871 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_FAILED!!!\n")); 7872 tdsmIOCompletedCB( smRoot, 7873 smIORequestBody->smIORequest, 7874 smIOFailed, 7875 smDetailOtherError, 7876 agNULL, 7877 interruptContext); 7878 break; 7879 7880 case OSSA_IO_ABORT_RESET: 7881 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORT_RESET!!!\n")); 7882 tdsmIOCompletedCB( smRoot, 7883 smIORequestBody->smIORequest, 7884 smIOFailed, 7885 smDetailAbortReset, 7886 agNULL, 7887 interruptContext); 7888 /* 7889 * Check if we are in recovery mode and need to update the recovery flag 7890 */ 7891 if ((oneDeviceData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) && 7892 (oneDeviceData->satPendingIO == 0 )) 7893 { 7894 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL; 7895 SM_DBG1(("smsatProcessAbnormalCompletion: STATE NORMAL!!!\n")); 7896 } 7897 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)); 7901 7902 break; 7903 7904 #ifdef REMOVED 7905 case OSSA_IO_NOT_VALID: 7906 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_NOT_VALID!!!\n")); 7907 tdsmIOCompletedCB( smRoot, 7908 smIORequestBody->smIORequest, 7909 smIOFailed, 7910 smDetailNotValid, 7911 agNULL, 7912 interruptContext); 7913 break; 7914 #endif 7915 7916 case OSSA_IO_NO_DEVICE: 7917 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_NO_DEVICE!!!\n")); 7918 tdsmIOCompletedCB( smRoot, 7919 smIORequestBody->smIORequest, 7920 smIOFailed, 7921 smDetailNoLogin, 7922 agNULL, 7923 interruptContext); 7924 break; 7925 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, 7931 smIOFailed, 7932 smDetailOtherError, 7933 agNULL, 7934 interruptContext); 7935 break; 7936 7937 case OSSA_IO_LINK_FAILURE: 7938 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_LINK_FAILURE!!!\n")); 7939 tdsmIOCompletedCB( smRoot, 7940 smIORequestBody->smIORequest, 7941 smIOFailed, 7942 smDetailOtherError, 7943 agNULL, 7944 interruptContext); 7945 break; 7946 7947 case OSSA_IO_PROG_ERROR: 7948 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_PROG_ERROR!!!\n")); 7949 tdsmIOCompletedCB( smRoot, 7950 smIORequestBody->smIORequest, 7951 smIOFailed, 7952 smDetailOtherError, 7953 agNULL, 7954 interruptContext); 7955 break; 7956 #endif 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 */ 7967 #endif 7968 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_OPEN_CNX_ERROR_* 0x%x!!!\n", agIOStatus)); 7969 if (smDeviceHandle == agNULL) 7970 { 7971 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n")); 7972 tdsmIOCompletedCB( smRoot, 7973 smIORequestBody->smIORequest, 7974 smIOFailed, 7975 smDetailOtherError, 7976 agNULL, 7977 interruptContext); 7978 return; 7979 } 7980 if (oneDeviceData == agNULL) 7981 { 7982 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n")); 7983 } 7984 else 7985 { 7986 SM_DBG1(("smsatProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id)); 7987 } 7988 7989 tdsmIOCompletedCB( smRoot, 7990 smIORequestBody->smIORequest, 7991 smIOFailed, 7992 smDetailOtherError, 7993 agNULL, 7994 interruptContext); 7995 break; 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, 8000 smIOFailed, 8001 smDetailBusy, 8002 agNULL, 8003 interruptContext); 8004 break; 8005 #ifdef REMOVED 8006 case OSSA_IO_XFER_ERROR_BREAK: /* fall throuth */ 8007 #endif 8008 8009 case OSSA_IO_XFER_ERROR_PHY_NOT_READY: /* fall throuth */ 8010 case OSSA_IO_XFER_ERROR_NAK_RECEIVED: /* fall throuth */ 8011 8012 #ifdef REMOVED 8013 case OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT: /* fall throuth */ 8014 case OSSA_IO_XFER_ERROR_PEER_ABORTED: /* fall throuth */ 8015 #endif 8016 case OSSA_IO_XFER_ERROR_DMA: /* fall throuth */ 8017 #ifdef REMOVED 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 */ 8021 #endif 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 */ 8025 #ifdef REMOVED 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 */ 8031 #endif 8032 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_ERROR_* 0x%x!!!\n", agIOStatus)); 8033 tdsmIOCompletedCB( smRoot, 8034 smIORequestBody->smIORequest, 8035 smIOFailed, 8036 smDetailOtherError, 8037 agNULL, 8038 interruptContext); 8039 break; 8040 #ifdef REMOVED 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, 8047 smIOFailed, 8048 smDetailOtherError, 8049 agNULL, 8050 interruptContext); 8051 break; 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, 8056 smIOFailed, 8057 smDetailOtherError, 8058 agNULL, 8059 interruptContext); 8060 break; 8061 #endif 8062 case OSSA_IO_DS_IN_ERROR: 8063 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_IN_ERROR!!!\n")); 8064 if (smDeviceHandle == agNULL) 8065 { 8066 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n")); 8067 tdsmIOCompletedCB( smRoot, 8068 smIORequestBody->smIORequest, 8069 smIOFailed, 8070 smDetailOtherError, 8071 agNULL, 8072 interruptContext); 8073 return; 8074 } 8075 if (oneDeviceData == agNULL) 8076 { 8077 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n")); 8078 } 8079 else 8080 { 8081 SM_DBG1(("smsatProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id)); 8082 } 8083 tdsmIOCompletedCB( smRoot, 8084 smIORequestBody->smIORequest, 8085 smIOFailed, 8086 smDetailOtherError, 8087 agNULL, 8088 interruptContext); 8089 break; 8090 case OSSA_IO_DS_NON_OPERATIONAL: 8091 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_NON_OPERATIONAL!!!\n")); 8092 if (smDeviceHandle == agNULL) 8093 { 8094 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n")); 8095 tdsmIOCompletedCB( smRoot, 8096 smIORequestBody->smIORequest, 8097 smIOFailed, 8098 smDetailOtherError, 8099 agNULL, 8100 interruptContext); 8101 return; 8102 } 8103 if (oneDeviceData == agNULL) 8104 { 8105 SM_DBG1(("smsatProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n")); 8106 } 8107 else 8108 { 8109 SM_DBG1(("smsatProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id)); 8110 agDevHandle = oneDeviceData->agDevHandle; 8111 if (oneDeviceData->valid == agTRUE) 8112 { 8113 saSetDeviceState(agRoot, agNULL, tdsmRotateQnumber(smRoot, smDeviceHandle), agDevHandle, SA_DS_OPERATIONAL); 8114 } 8115 } 8116 8117 tdsmIOCompletedCB( smRoot, 8118 smIORequestBody->smIORequest, 8119 smIOFailed, 8120 smDetailOtherError, 8121 agNULL, 8122 interruptContext); 8123 break; 8124 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, 8130 smIOFailed, 8131 smDetailOtherError, 8132 agNULL, 8133 interruptContext); 8134 break; 8135 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, 8144 smIOFailed, 8145 smDetailOtherError, 8146 agNULL, 8147 interruptContext); 8148 break; 8149 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, 8156 smIOFailed, 8157 smDetailBusy, 8158 agNULL, 8159 interruptContext); 8160 break; 8161 8162 case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS: /* fall through */ 8163 #ifdef REMOVED 8164 case OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH: 8165 #endif 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: 8171 8172 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = ENCRYPTION ERROR 0x%x!!!\n", agIOStatus)); 8173 smsatEncryptionHandler(smRoot, 8174 agIORequest, 8175 agIOStatus, 8176 agIOInfoLen, 8177 agParam, 8178 0, 8179 interruptContext); 8180 break; 8181 8182 #ifdef REMOVED 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, 8188 agIORequest, 8189 agIOStatus, 8190 agIOInfoLen, 8191 agParam, 8192 0, 8193 interruptContext); 8194 break; 8195 #endif 8196 8197 default: 8198 SM_DBG1(("smsatProcessAbnormalCompletion: agIOStatus = unknown 0x%x!!!\n", agIOStatus)); 8199 if (oneDeviceData != agNULL) 8200 { 8201 SM_DBG1(("smsatProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id)); 8202 } 8203 else 8204 { 8205 SM_DBG1(("smsatProcessAbnormalCompletion: oneDeviceData is NULL!!!\n")); 8206 } 8207 8208 tdsmIOCompletedCB( smRoot, 8209 smIORequestBody->smIORequest, 8210 smIOFailed, 8211 smDetailOtherError, 8212 agNULL, 8213 interruptContext); 8214 break; 8215 8216 } /* switch */ 8217 8218 return; 8219 } 8220 8221 osGLOBAL void 8222 smsatDelayedProcessAbnormalCompletion( 8223 agsaRoot_t *agRoot, 8224 agsaIORequest_t *agIORequest, 8225 bit32 agIOStatus, 8226 agsaFisHeader_t *agFirstDword, 8227 bit32 agIOInfoLen, 8228 void *agParam, 8229 smSatIOContext_t *satIOContext 8230 ) 8231 { 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; 8242 8243 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 8244 oneDeviceData = satIOContext->pSatDevData; 8245 if (oneDeviceData == agNULL) 8246 { 8247 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: oneDeviceData is NULL\n")); 8248 return; 8249 } 8250 smDeviceHandle = satIOContext->psmDeviceHandle; 8251 smRoot = oneDeviceData->smRoot; 8252 interruptContext = satIOContext->interruptContext; 8253 8254 SM_DBG5(("smsatDelayedProcessAbnormalCompletion: start\n")); 8255 8256 /* Get into the detail */ 8257 switch(agIOStatus) 8258 { 8259 case OSSA_IO_SUCCESS: 8260 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_SUCCESS calling smsatIOCompleted!!!\n")); 8261 /* do nothing */ 8262 break; 8263 8264 8265 case OSSA_IO_ABORTED: 8266 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORTED!!!\n")); 8267 8268 tdsmIOCompletedCB( smRoot, 8269 smIORequestBody->smIORequest, 8270 smIOFailed, 8271 smDetailAborted, 8272 agNULL, 8273 interruptContext); 8274 8275 if ( oneDeviceData->satTmTaskTag != agNULL ) 8276 { 8277 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: TM callback!!!\n")); 8278 if (smDeviceHandle == agNULL) 8279 { 8280 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n")); 8281 } 8282 else 8283 { 8284 /* TM completed */ 8285 tdsmEventCB( smRoot, 8286 smDeviceHandle, 8287 smIntrEventTypeTaskManagement, 8288 smTMOK, 8289 oneDeviceData->satTmTaskTag); 8290 /* 8291 * Reset flag 8292 */ 8293 oneDeviceData->satTmTaskTag = agNULL; 8294 } 8295 } 8296 8297 /* 8298 * Check if we are in recovery mode and need to update the recovery flag 8299 */ 8300 if ((oneDeviceData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) && 8301 (oneDeviceData->satPendingIO == 0 )) 8302 { 8303 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL; 8304 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: STATE NORMAL.!!!\n")); 8305 } 8306 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)); 8310 8311 break; 8312 #ifdef REMOVED 8313 case OSSA_IO_OVERFLOW: 8314 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_OVERFLOW!!!\n")); 8315 tdsmIOCompletedCB( smRoot, 8316 smIORequestBody->smIORequest, 8317 smIOOverRun, 8318 agIOInfoLen, 8319 agNULL, 8320 interruptContext); 8321 break; 8322 #endif 8323 case OSSA_IO_UNDERFLOW: 8324 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_UNDERFLOW!!!\n")); 8325 tdsmIOCompletedCB( smRoot, 8326 smIORequestBody->smIORequest, 8327 smIOUnderRun, 8328 agIOInfoLen, 8329 agNULL, 8330 interruptContext); 8331 break; 8332 8333 8334 case OSSA_IO_FAILED: 8335 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_FAILED!!!\n")); 8336 tdsmIOCompletedCB( smRoot, 8337 smIORequestBody->smIORequest, 8338 smIOFailed, 8339 smDetailOtherError, 8340 agNULL, 8341 interruptContext); 8342 break; 8343 8344 case OSSA_IO_ABORT_RESET: 8345 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORT_RESET!!!\n")); 8346 tdsmIOCompletedCB( smRoot, 8347 smIORequestBody->smIORequest, 8348 smIOFailed, 8349 smDetailAbortReset, 8350 agNULL, 8351 interruptContext); 8352 /* 8353 * Check if we are in recovery mode and need to update the recovery flag 8354 */ 8355 if ((oneDeviceData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) && 8356 (oneDeviceData->satPendingIO == 0 )) 8357 { 8358 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL; 8359 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: STATE NORMAL.!!!\n")); 8360 } 8361 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)); 8365 8366 break; 8367 8368 #ifdef REMOVED 8369 case OSSA_IO_NOT_VALID: 8370 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_NOT_VALID!!!\n")); 8371 tdsmIOCompletedCB( smRoot, 8372 smIORequestBody->smIORequest, 8373 smIOFailed, 8374 smDetailNotValid, 8375 agNULL, 8376 interruptContext); 8377 break; 8378 #endif 8379 8380 case OSSA_IO_NO_DEVICE: 8381 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_NO_DEVICE!!!\n")); 8382 tdsmIOCompletedCB( smRoot, 8383 smIORequestBody->smIORequest, 8384 smIOFailed, 8385 smDetailNoLogin, 8386 agNULL, 8387 interruptContext); 8388 break; 8389 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, 8395 smIOFailed, 8396 smDetailOtherError, 8397 agNULL, 8398 interruptContext); 8399 break; 8400 8401 case OSSA_IO_LINK_FAILURE: 8402 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_LINK_FAILURE!!!\n")); 8403 tdsmIOCompletedCB( smRoot, 8404 smIORequestBody->smIORequest, 8405 smIOFailed, 8406 smDetailOtherError, 8407 agNULL, 8408 interruptContext); 8409 break; 8410 8411 case OSSA_IO_PROG_ERROR: 8412 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_PROG_ERROR!!!\n")); 8413 tdsmIOCompletedCB( smRoot, 8414 smIORequestBody->smIORequest, 8415 smIOFailed, 8416 smDetailOtherError, 8417 agNULL, 8418 interruptContext); 8419 break; 8420 #endif 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 */ 8431 #endif 8432 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_OPEN_CNX_ERROR_* 0x%x!!!\n", agIOStatus)); 8433 if (smDeviceHandle == agNULL) 8434 { 8435 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n")); 8436 tdsmIOCompletedCB( smRoot, 8437 smIORequestBody->smIORequest, 8438 smIOFailed, 8439 smDetailOtherError, 8440 agNULL, 8441 interruptContext); 8442 return; 8443 } 8444 if (oneDeviceData == agNULL) 8445 { 8446 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n")); 8447 } 8448 else 8449 { 8450 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id)); 8451 } 8452 tdsmIOCompletedCB( smRoot, 8453 smIORequestBody->smIORequest, 8454 smIOFailed, 8455 smDetailOtherError, 8456 agNULL, 8457 interruptContext); 8458 break; 8459 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, 8464 smIOFailed, 8465 smDetailBusy, 8466 agNULL, 8467 interruptContext); 8468 break; 8469 #ifdef REMOVED 8470 case OSSA_IO_XFER_ERROR_BREAK: /* fall throuth */ 8471 #endif 8472 8473 case OSSA_IO_XFER_ERROR_PHY_NOT_READY: /* fall throuth */ 8474 case OSSA_IO_XFER_ERROR_NAK_RECEIVED: /* fall throuth */ 8475 8476 #ifdef REMOVED 8477 case OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT: /* fall throuth */ 8478 case OSSA_IO_XFER_ERROR_PEER_ABORTED: /* fall throuth */ 8479 #endif 8480 8481 case OSSA_IO_XFER_ERROR_DMA: /* fall throuth */ 8482 8483 #ifdef REMOVED 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 */ 8487 #endif 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 */ 8491 #ifdef REMOVED 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 */ 8496 #endif 8497 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_ERROR_* 0x%x!!!\n", agIOStatus)); 8498 8499 tdsmIOCompletedCB( smRoot, 8500 smIORequestBody->smIORequest, 8501 smIOFailed, 8502 smDetailOtherError, 8503 agNULL, 8504 interruptContext); 8505 break; 8506 #ifdef REMOVED 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, 8513 smIOFailed, 8514 smDetailOtherError, 8515 agNULL, 8516 interruptContext); 8517 break; 8518 case OSSA_IO_XFER_PIO_SETUP_ERROR: 8519 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_PIO_SETUP_ERROR!!!\n")); 8520 if (smDeviceHandle == agNULL) 8521 { 8522 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n")); 8523 } 8524 if (oneDeviceData == agNULL) 8525 { 8526 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n")); 8527 } 8528 else 8529 { 8530 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id)); 8531 } 8532 tdsmIOCompletedCB( smRoot, 8533 smIORequestBody->smIORequest, 8534 smIOFailed, 8535 smDetailOtherError, 8536 agNULL, 8537 interruptContext); 8538 break; 8539 #endif 8540 case OSSA_IO_DS_IN_ERROR: 8541 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_IN_ERROR!!!\n")); 8542 if (smDeviceHandle == agNULL) 8543 { 8544 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n")); 8545 tdsmIOCompletedCB( smRoot, 8546 smIORequestBody->smIORequest, 8547 smIOFailed, 8548 smDetailOtherError, 8549 agNULL, 8550 interruptContext); 8551 return; 8552 } 8553 if (oneDeviceData == agNULL) 8554 { 8555 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n")); 8556 } 8557 else 8558 { 8559 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id)); 8560 } 8561 tdsmIOCompletedCB( smRoot, 8562 smIORequestBody->smIORequest, 8563 smIOFailed, 8564 smDetailOtherError, 8565 agNULL, 8566 interruptContext); 8567 break; 8568 case OSSA_IO_DS_NON_OPERATIONAL: 8569 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_NON_OPERATIONAL!!!\n")); 8570 if (smDeviceHandle == agNULL) 8571 { 8572 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, smDeviceHandle is NULL!!!\n")); 8573 tdsmIOCompletedCB( smRoot, 8574 smIORequestBody->smIORequest, 8575 smIOFailed, 8576 smDetailOtherError, 8577 agNULL, 8578 interruptContext); 8579 return; 8580 } 8581 if (oneDeviceData == agNULL) 8582 { 8583 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL!!!\n")); 8584 } 8585 else 8586 { 8587 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: did %d!!!\n", oneDeviceData->id)); 8588 agDevHandle = oneDeviceData->agDevHandle; 8589 if (oneDeviceData->valid == agTRUE) 8590 { 8591 saSetDeviceState(agRoot, agNULL, tdsmRotateQnumber(smRoot, smDeviceHandle), agDevHandle, SA_DS_OPERATIONAL); 8592 } 8593 } 8594 tdsmIOCompletedCB( smRoot, 8595 smIORequestBody->smIORequest, 8596 smIOFailed, 8597 smDetailOtherError, 8598 agNULL, 8599 interruptContext); 8600 break; 8601 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, 8607 smIOFailed, 8608 smDetailOtherError, 8609 agNULL, 8610 interruptContext); 8611 break; 8612 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, 8621 smIOFailed, 8622 smDetailOtherError, 8623 agNULL, 8624 interruptContext); 8625 break; 8626 case OSSA_IO_DS_INVALID: 8627 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: OSSA_IO_DS_INVALID status %x\n", agIOStatus)); 8628 tdsmIOCompletedCB( smRoot, 8629 smIORequestBody->smIORequest, 8630 smIOFailed, 8631 smDetailOtherError, 8632 agNULL, 8633 interruptContext); 8634 break; 8635 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, 8642 smIOFailed, 8643 smDetailBusy, 8644 agNULL, 8645 interruptContext); 8646 break; 8647 8648 case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS: /* fall through */ 8649 #ifdef REMOVED 8650 case OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH: 8651 #endif 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: 8657 8658 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = ENCRYPTION ERROR 0x%x!!!\n", agIOStatus)); 8659 smsatEncryptionHandler(smRoot, 8660 agIORequest, 8661 agIOStatus, 8662 agIOInfoLen, 8663 agParam, 8664 0, 8665 interruptContext); 8666 break; 8667 8668 #ifdef REMOVED 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, 8674 agIORequest, 8675 agIOStatus, 8676 agIOInfoLen, 8677 agParam, 8678 0, 8679 interruptContext); 8680 break; 8681 #endif 8682 8683 default: 8684 SM_DBG1(("smsatDelayedProcessAbnormalCompletion: agIOStatus = unknown!!!\n")); 8685 tdsmIOCompletedCB( smRoot, 8686 smIORequestBody->smIORequest, 8687 smIOFailed, 8688 smDetailOtherError, 8689 agNULL, 8690 interruptContext); 8691 break; 8692 8693 } /* switch */ 8694 return; 8695 } 8696 8697 osGLOBAL void 8698 smsatIDStartCB( 8699 agsaRoot_t *agRoot, 8700 agsaIORequest_t *agIORequest, 8701 bit32 agIOStatus, 8702 agsaFisHeader_t *agFirstDword, 8703 bit32 agIOInfoLen, 8704 void *agParam, 8705 void *ioContext 8706 ) 8707 { 8708 /* 8709 In the process of SAT_IDENTIFY_DEVICE during discovery 8710 */ 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; 8733 bit32 ataError; 8734 #endif 8735 agsaSATAIdentifyData_t *pSATAIdData; 8736 bit16 *tmpptr, tmpptr_tmp; 8737 bit32 x; 8738 void *sglVirtualAddr; 8739 bit32 status = 0; 8740 // tdsaPortContext_t *onePortContext = agNULL; 8741 // tiPortalContext_t *tiPortalContext = agNULL; 8742 // bit32 retry_status; 8743 smIORequest_t *smIORequest; 8744 agsaDevHandle_t *agDevHandle = agNULL; 8745 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) 8760 { 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; 8765 8766 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 8767 8768 smsatFreeIntIoResource( smRoot, 8769 oneDeviceData, 8770 satIntIo); 8771 return; 8772 } 8773 else 8774 { 8775 SM_DBG3(("smsatIDStartCB: Internal, SM generated\n")); 8776 satOrgIOContext = satIOContext->satOrgIOContext; 8777 if (satOrgIOContext == agNULL) 8778 { 8779 SM_DBG5(("smsatIDStartCB: satOrgIOContext is NULL\n")); 8780 } 8781 else 8782 { 8783 SM_DBG5(("smsatIDStartCB: satOrgIOContext is NOT NULL\n")); 8784 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 8785 if (smOrgIORequestBody == agNULL) 8786 { 8787 SM_DBG1(("smsatIDStartCB: smOrgIORequestBody is NULL!!!\n")); 8788 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 8789 8790 smsatFreeIntIoResource(smRoot, oneDeviceData, satIntIo); 8791 return; 8792 } 8793 } 8794 sglVirtualAddr = satIntIo->satIntSmScsiXchg.sglVirtualAddr; 8795 } 8796 smOrgIORequest = smIORequestBody->smIORequest; 8797 smIORequest = smOrgIORequestBody->smIORequest; 8798 smIORequestBody->ioCompleted = agTRUE; 8799 smIORequestBody->ioStarted = agFALSE; 8800 8801 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 ) 8806 { 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); 8810 8811 smsatFreeIntIoResource( smRoot, 8812 oneDeviceData, 8813 satIntIo); 8814 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) 8818 { 8819 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIORetry, &(oneDeviceData->satIdentifyData)); 8820 } 8821 else if ( agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED || 8822 agIOStatus == OSSA_IO_DS_NON_OPERATIONAL ) 8823 { 8824 /* set device to operational */ 8825 agDevHandle = oneDeviceData->agDevHandle; 8826 if (oneDeviceData->valid == agTRUE) 8827 { 8828 saSetDeviceState(agRoot, agNULL, tdsmRotateQnumber(smRoot, smDeviceHandle), agDevHandle, SA_DS_OPERATIONAL); 8829 } 8830 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIORetry, &(oneDeviceData->satIdentifyData)); 8831 } 8832 else 8833 { 8834 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSTPResourceBusy, &(oneDeviceData->satIdentifyData)); 8835 } 8836 return; 8837 } 8838 8839 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 8840 { 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)); 8845 8846 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 8847 8848 SM_DBG1(("smsatIDStartCB: after pending IO %d NCQ pending IO %d NONNCQ pending IO %d\n", 8849 oneDeviceData->satPendingIO, oneDeviceData->satPendingNCQIO, oneDeviceData->satPendingNONNCQIO)); 8850 8851 smsatFreeIntIoResource( smRoot, 8852 oneDeviceData, 8853 satIntIo); 8854 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)); 8858 return; 8859 } 8860 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 8882 ) 8883 { 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); 8887 8888 smsatFreeIntIoResource( smRoot, 8889 oneDeviceData, 8890 satIntIo); 8891 8892 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)); 8896 return; 8897 } 8898 8899 if ( agIOStatus != OSSA_IO_SUCCESS || 8900 (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL && agIOInfoLen != 0) 8901 ) 8902 { 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 */ 8908 #endif 8909 SM_DBG1(("smsatIDStartCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError)); 8910 8911 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 8912 8913 smsatFreeIntIoResource( smRoot, 8914 oneDeviceData, 8915 satIntIo); 8916 8917 SM_DBG2(("smsatIDStartCB: smOrgIORequestBody %p smIORequest %p\n", smOrgIORequestBody, smIORequest)); 8918 SM_DBG2(("smsatIDStartCB: smOrgIORequestBody->id %d\n", smOrgIORequestBody->id)); 8919 8920 { 8921 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData)); 8922 } 8923 return; 8924 } 8925 8926 8927 /* success */ 8928 SM_DBG3(("smsatIDStartCB: Success\n")); 8929 SM_DBG3(("smsatIDStartCB: Success did %d\n", oneDeviceData->id)); 8930 8931 /* Convert to host endian */ 8932 tmpptr = (bit16*)sglVirtualAddr; 8933 for (x=0; x < sizeof(agsaSATAIdentifyData_t)/sizeof(bit16); x++) 8934 { 8935 OSSA_READ_LE_16(AGROOT, &tmpptr_tmp, tmpptr, 0); 8936 *tmpptr = tmpptr_tmp; 8937 tmpptr++; 8938 } 8939 8940 pSATAIdData = (agsaSATAIdentifyData_t *)sglVirtualAddr; 8941 //smhexdump("satAddSATAIDDevCB before", (bit8 *)pSATAIdData, sizeof(agsaSATAIdentifyData_t)); 8942 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)); 8947 8948 8949 /* copy ID Dev data to oneDeviceData */ 8950 oneDeviceData->satIdentifyData = *pSATAIdData; 8951 oneDeviceData->IDDeviceValid = agTRUE; 8952 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)); 8956 #endif 8957 8958 /* set oneDeviceData fields from IndentifyData */ 8959 smsatSetDevInfo(oneDeviceData,pSATAIdData); 8960 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 8961 8962 smsatFreeIntIoResource( smRoot, 8963 oneDeviceData, 8964 satIntIo); 8965 8966 if (smIORequest->tdData == smIORequest->smData) 8967 { 8968 SM_DBG1(("smsatIDStartCB: the same tdData and smData error!\n")); 8969 } 8970 8971 /* send the Set Feature ATA command to SATA device for enbling PIO and DMA transfer mode*/ 8972 satNewIntIo = smsatAllocIntIoResource( smRoot, 8973 smOrgIORequest, 8974 oneDeviceData, 8975 0, 8976 satNewIntIo); 8977 8978 if (satNewIntIo == agNULL) 8979 { 8980 SM_DBG1(("smsatIDStartCB: momory allocation fails\n")); 8981 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData)); 8982 return; 8983 } /* end memory allocation */ 8984 8985 satNewIOContext = smsatPrepareNewIO(satNewIntIo, 8986 smOrgIORequest, 8987 oneDeviceData, 8988 agNULL, 8989 satOrgIOContext 8990 ); 8991 /*enable PIO mode*/ 8992 status = smsatSetFeaturesPIO(smRoot, 8993 &satNewIntIo->satIntSmIORequest, 8994 satNewIOContext->psmDeviceHandle, 8995 &satNewIntIo->satIntSmScsiXchg, /* orginal from OS layer */ 8996 satNewIOContext 8997 ); 8998 8999 if (status != SM_RC_SUCCESS) 9000 { 9001 smsatFreeIntIoResource(smRoot, 9002 oneDeviceData, 9003 satNewIntIo); 9004 /* clean up TD layer's IORequestBody */ 9005 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData)); 9006 } 9007 9008 SM_DBG2(("smsatIDStartCB: End device id %d\n", oneDeviceData->id)); 9009 return; 9010 } 9011 9012 9013 osGLOBAL void 9014 smsatIOCompleted( 9015 smRoot_t *smRoot, 9016 smIORequest_t *smIORequest, 9017 agsaFisHeader_t *agFirstDword, 9018 bit32 respFisLen, 9019 agsaFrameHandle_t agFrameHandle, 9020 smSatIOContext_t *satIOContext, 9021 bit32 interruptContext 9022 ) 9023 { 9024 // satDeviceData_t *pSatDevData; 9025 smDeviceData_t *oneDeviceData; 9026 smScsiRspSense_t *pSense; 9027 #ifdef TD_DEBUG_ENABLE 9028 smIniScsiCmnd_t *pScsiCmnd; 9029 #endif 9030 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 9031 bit32 ataStatus = 0; 9032 bit32 ataError; 9033 smSatInternalIo_t *satIntIo = agNULL; 9034 bit32 status; 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; 9043 9044 pSense = satIOContext->pSense; 9045 oneDeviceData = satIOContext->pSatDevData; 9046 #ifdef TD_DEBUG_ENABLE 9047 pScsiCmnd = satIOContext->pScsiCmnd; 9048 #endif 9049 hostToDevFis = satIOContext->pFis; 9050 9051 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; 9056 /* 9057 * Find out the type of response FIS: 9058 * Set Device Bit FIS or Reg Device To Host FIS. 9059 */ 9060 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 */ 9065 9066 SM_DBG5(("smsatIOCompleted: start\n")); 9067 9068 /* for debugging */ 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)); 9071 9072 9073 if (statDevToHostFisHeader->fisType == SET_DEV_BITS_FIS) 9074 { 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 */ 9080 9081 /* ATA Eror register */ 9082 ataError = statSetDevBitFisHeader->error; 9083 9084 statDevToHostFisHeader = agNULL; 9085 } 9086 9087 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 9088 { 9089 SM_DBG1(("smsatIOCompleted: *** UNEXPECTED RESP FIS TYPE 0x%x *** smIORequest=%p!!!\n", 9090 statDevToHostFisHeader->fisType, smIORequest)); 9091 9092 smsatSetSensePayload( pSense, 9093 SCSI_SNSKEY_HARDWARE_ERROR, 9094 0, 9095 SCSI_SNSCODE_INTERNAL_TARGET_FAILURE, 9096 satIOContext); 9097 9098 tdsmIOCompletedCB( smRoot, 9099 smIORequest, 9100 smIOSuccess, 9101 SCSI_STAT_CHECK_CONDITION, 9102 satIOContext->pSmSenseData, 9103 interruptContext ); 9104 return; 9105 9106 } 9107 9108 if ( ataStatus & DF_ATA_STATUS_MASK ) 9109 { 9110 oneDeviceData->satDeviceFaultState = agTRUE; 9111 } 9112 else 9113 { 9114 oneDeviceData->satDeviceFaultState = agFALSE; 9115 } 9116 9117 SM_DBG5(("smsatIOCompleted: smIORequest=%p CDB=0x%x ATA CMD =0x%x\n", 9118 smIORequest, pScsiCmnd->cdb[0], hostToDevFis->h.command)); 9119 9120 /* 9121 * Decide which ATA command is the translation needed 9122 */ 9123 switch(hostToDevFis->h.command) 9124 { 9125 case SAT_READ_FPDMA_QUEUED: 9126 case SAT_WRITE_FPDMA_QUEUED: 9127 9128 /************************************************************************ 9129 * 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. !!!! 9136 * 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. 9139 * 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: 9143 * 9144 * 1. Set SATA device flag to indicate error condition and returning busy 9145 * for all new request. 9146 * return SM_RC_SUCCESS; 9147 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 9151 * SCSI status. 9152 * 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. 9155 * 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. 9159 * 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(). 9163 * 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. 9168 * 9169 * 7. Issue abort to LL layer to all other pending I/Os for the same SATA 9170 * drive. 9171 * 9172 * 8. Free resource allocated for the internally generated READ LOG EXT. 9173 * 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. 9178 * 9179 ***********************************************************************/ 9180 9181 SM_DBG1(("smsatIOCompleted: NCQ ERROR smIORequest=%p ataStatus=0x%x ataError=0x%x!!!\n", 9182 smIORequest, ataStatus, ataError )); 9183 9184 /* Set flag to indicate we are in recovery */ 9185 oneDeviceData->satDriveState = SAT_DEV_STATE_IN_RECOVERY; 9186 9187 /* Return the failed NCQ I/O to OS-Apps Specifiic layer */ 9188 smsatDefaultTranslation( smRoot, 9189 smIORequest, 9190 satIOContext, 9191 pSense, 9192 (bit8)ataStatus, 9193 (bit8)ataError, 9194 interruptContext ); 9195 9196 /* 9197 * Allocate resource for READ LOG EXT page 10h 9198 */ 9199 satIntIo = smsatAllocIntIoResource( smRoot, 9200 &(smIORequestTMP), /* anything but NULL */ 9201 oneDeviceData, 9202 sizeof (satReadLogExtPage10h_t), 9203 satIntIo); 9204 9205 /* 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. 9208 */ 9209 if (satIntIo == agNULL) 9210 { 9211 SM_DBG1(("smsatIOCompleted: can't send RLE due to resource lack!!!\n")); 9212 9213 /* Abort I/O after completion of device reset */ 9214 oneDeviceData->satAbortAfterReset = agTRUE; 9215 #ifdef NOT_YET 9216 /* needs further investigation */ 9217 /* no report to OS layer */ 9218 satSubTM(smRoot, 9219 smDeviceHandle, 9220 SM_INTERNAL_TM_RESET, 9221 agNULL, 9222 agNULL, 9223 agNULL, 9224 agFALSE); 9225 #endif 9226 9227 9228 SM_DBG1(("smsatIOCompleted: calling saSATADeviceReset 1!!!\n")); 9229 return; 9230 } 9231 9232 9233 /* 9234 * Set flag to indicate that the failed I/O has been returned to the 9235 * OS-App specific Layer. 9236 */ 9237 satIntIo->satIntFlag = AG_SAT_INT_IO_FLAG_ORG_IO_COMPLETED; 9238 9239 /* compare to satPrepareNewIO() */ 9240 /* Send READ LOG EXIT page 10h command */ 9241 9242 /* 9243 * Need to initialize all the fields within satIOContext except 9244 * reqType and satCompleteCB which will be set depending on cmd. 9245 */ 9246 9247 smIORequestBody = (smIORequestBody_t *)satIntIo->satIntRequestBody; 9248 satIOContext2 = &(smIORequestBody->transport.SATA.satIOContext); 9249 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; 9256 9257 satIOContext2->smRequestBody = satIntIo->satIntRequestBody; 9258 satIOContext2->interruptContext = interruptContext; 9259 satIOContext2->satIntIoContext = satIntIo; 9260 9261 satIOContext2->psmDeviceHandle = smDeviceHandle; 9262 satIOContext2->satOrgIOContext = agNULL; 9263 satIOContext2->smScsiXchg = agNULL; 9264 9265 status = smsatSendReadLogExt( smRoot, 9266 &satIntIo->satIntSmIORequest, 9267 smDeviceHandle, 9268 &satIntIo->satIntSmScsiXchg, 9269 satIOContext2); 9270 9271 if (status != SM_RC_SUCCESS) 9272 { 9273 SM_DBG1(("smsatIOCompleted: can't send RLE due to LL api failure!!!\n")); 9274 smsatFreeIntIoResource( smRoot, 9275 oneDeviceData, 9276 satIntIo); 9277 9278 /* Abort I/O after completion of device reset */ 9279 oneDeviceData->satAbortAfterReset = agTRUE; 9280 #ifdef NOT_YET 9281 /* needs further investigation */ 9282 /* no report to OS layer */ 9283 satSubTM(smRoot, 9284 smDeviceHandle, 9285 SM_INTERNAL_TM_RESET, 9286 agNULL, 9287 agNULL, 9288 agNULL, 9289 agFALSE); 9290 #endif 9291 9292 SM_DBG1(("smsatIOCompleted: calling saSATADeviceReset 2!!!\n")); 9293 return; 9294 } 9295 9296 break; 9297 9298 case SAT_READ_DMA_EXT: 9299 /* fall through */ 9300 /* Use default status/error translation */ 9301 9302 case SAT_READ_DMA: 9303 /* fall through */ 9304 /* Use default status/error translation */ 9305 9306 default: 9307 smsatDefaultTranslation( smRoot, 9308 smIORequest, 9309 satIOContext, 9310 pSense, 9311 (bit8)ataStatus, 9312 (bit8)ataError, 9313 interruptContext ); 9314 break; 9315 9316 } /* end switch */ 9317 return; 9318 } 9319 9320 9321 osGLOBAL void 9322 smsatEncryptionHandler( 9323 smRoot_t *smRoot, 9324 agsaIORequest_t *agIORequest, 9325 bit32 agIOStatus, 9326 bit32 agIOInfoLen, 9327 void *agParam, 9328 bit32 agOtherInfo, 9329 bit32 interruptContext 9330 ) 9331 { 9332 smIORequestBody_t *smIORequestBody; 9333 bit32 errorDetail = smDetailOtherError; 9334 9335 SM_DBG1(("smsatEncryptionHandler: start\n")); 9336 SM_DBG1(("smsatEncryptionHandler: agIOStatus 0x%x\n", agIOStatus)); 9337 9338 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 9339 9340 switch (agIOStatus) 9341 { 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; 9345 break; 9346 case OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID: 9347 SM_DBG1(("smsatEncryptionHandler: OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID\n")); 9348 errorDetail = smDetailCipherModeInvalid; 9349 break; 9350 case OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH: 9351 SM_DBG1(("smsatEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH\n")); 9352 errorDetail = smDetailDekIVMismatch; 9353 break; 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; 9357 break; 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; 9361 break; 9362 case OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE: 9363 SM_DBG1(("smsatEncryptionHandler:OSSA_IO_XFR_ERROR_DEK_ILLEGAL_TABLE\n")); 9364 errorDetail = smDetailOtherError; 9365 break; 9366 default: 9367 SM_DBG1(("smsatEncryptionHandler: other error!!! 0x%x\n", agIOStatus)); 9368 errorDetail = smDetailOtherError; 9369 break; 9370 } 9371 9372 tdsmIOCompletedCB( smRoot, 9373 smIORequestBody->smIORequest, 9374 smIOEncryptError, 9375 errorDetail, 9376 agNULL, 9377 interruptContext 9378 ); 9379 return; 9380 } 9381 9382 osGLOBAL void 9383 smsatDifHandler( 9384 smRoot_t *smRoot, 9385 agsaIORequest_t *agIORequest, 9386 bit32 agIOStatus, 9387 bit32 agIOInfoLen, 9388 void *agParam, 9389 bit32 agOtherInfo, 9390 bit32 interruptContext 9391 ) 9392 { 9393 smIORequestBody_t *smIORequestBody; 9394 bit32 errorDetail = smDetailOtherError; 9395 #ifdef TD_DEBUG_ENABLE 9396 agsaDifDetails_t *DifDetail; 9397 #endif 9398 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; 9404 #endif 9405 9406 switch (agIOStatus) 9407 { 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; 9411 break; 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; 9415 break; 9416 case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH: 9417 SM_DBG1(("smsatDifHandler: OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH\n")); 9418 errorDetail = smDetailDifCrcMismatch; 9419 break; 9420 default: 9421 SM_DBG1(("smsatDifHandler: other error!!! 0x%x\n", agIOStatus)); 9422 errorDetail = smDetailOtherError; 9423 break; 9424 } 9425 9426 SM_DBG1(("smsatDifHandler: DIF detail UpperLBA 0x%08x LowerLBA 0x%08x\n", DifDetail->UpperLBA, DifDetail->LowerLBA)); 9427 9428 tdsmIOCompletedCB( smRoot, 9429 smIORequestBody->smIORequest, 9430 smIODifError, 9431 errorDetail, 9432 agNULL, 9433 interruptContext 9434 ); 9435 return; 9436 } 9437 9438 osGLOBAL void 9439 smsatProcessAbort( 9440 smRoot_t *smRoot, 9441 smIORequest_t *smIORequest, 9442 smSatIOContext_t *satIOContext 9443 ) 9444 { 9445 smDeviceData_t *oneDeviceData; 9446 #ifdef REMOVED 9447 smDeviceHandle_t *smDeviceHandle; 9448 #endif 9449 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 9450 9451 SM_DBG5(("smsatProcessAbort: start\n")); 9452 9453 oneDeviceData = satIOContext->pSatDevData; 9454 #ifdef REMOVED 9455 smDeviceHandle = satIOContext->psmDeviceHandle; 9456 #endif 9457 hostToDevFis = satIOContext->pFis; 9458 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) 9461 ) 9462 { 9463 /* no completion for send diagnotic in background. It is done in satSendDiagnostic() */ 9464 tdsmIOCompletedCB( smRoot, 9465 smIORequest, 9466 smIOFailed, 9467 smDetailAborted, 9468 agNULL, 9469 satIOContext->interruptContext); 9470 } 9471 9472 if ( oneDeviceData->satTmTaskTag != agNULL ) 9473 { 9474 SM_DBG1(("smsatProcessAbort: TM callback!!!\n")); 9475 #ifdef REMOVED 9476 /* TM completed */ 9477 tdsmEventCB( smRoot, 9478 smDeviceHandle, 9479 smIntrEventTypeTaskManagement, 9480 smTMOK, 9481 oneDeviceData->satTmTaskTag); 9482 #endif 9483 /* 9484 * Reset flag 9485 */ 9486 oneDeviceData->satTmTaskTag = agNULL; 9487 } 9488 9489 /* 9490 * Check if we are in recovery mode and need to update the recovery flag 9491 */ 9492 if ((oneDeviceData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) && 9493 (oneDeviceData->satPendingIO == 0 )) 9494 { 9495 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL; 9496 SM_DBG1(("smsatProcessAbort: STATE NORMAL.!!!\n")); 9497 } 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)); 9501 9502 return; 9503 } 9504 9505 9506 osGLOBAL void 9507 smsatNonDataIOCB( 9508 agsaRoot_t *agRoot, 9509 agsaIORequest_t *agIORequest, 9510 bit32 agIOStatus, 9511 agsaFisHeader_t *agFirstDword, 9512 bit32 agIOInfoLen, 9513 void *agParam, 9514 void *ioContext 9515 ) 9516 { 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; 9524 9525 SM_DBG2(("smsatNonDataIOCB: start\n")); 9526 SM_DBG5(("satNonDataIOCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", 9527 agIORequest, agIOStatus, agIOInfoLen)); 9528 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; 9536 9537 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 9538 9539 9540 smIORequestBody->ioCompleted = agTRUE; 9541 smIORequestBody->ioStarted = agFALSE; 9542 9543 /* Process completion */ 9544 if( (agIOStatus == OSSA_IO_SUCCESS) && (agIOInfoLen==0)) 9545 { 9546 9547 SM_DBG1(("satNonDataIOCB: *** ERROR*** agIORequest=%p agIOStatus=0x%x agIOInfoLen %d!!!\n", 9548 agIORequest, agIOStatus, agIOInfoLen)); 9549 9550 tdsmIOCompletedCB( smRoot, 9551 smIORequestBody->smIORequest, 9552 smIOFailed, 9553 smDetailOtherError, 9554 agNULL, 9555 interruptContext); 9556 } 9557 else 9558 { 9559 /* More checking needed, for non-data IO this should be the normal case */ 9560 smsatProcessAbnormalCompletion( agRoot, 9561 agIORequest, 9562 agIOStatus, 9563 agFirstDword, 9564 agIOInfoLen, 9565 agParam, 9566 satIOContext); 9567 } 9568 return; 9569 } 9570 9571 osGLOBAL void 9572 smsatInquiryCB( 9573 agsaRoot_t *agRoot, 9574 agsaIORequest_t *agIORequest, 9575 bit32 agIOStatus, 9576 agsaFisHeader_t *agFirstDword, 9577 bit32 agIOInfoLen, 9578 void *agParam, 9579 void *ioContext 9580 ) 9581 { 9582 /* 9583 In the process of Inquiry 9584 Process SAT_IDENTIFY_DEVICE 9585 */ 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; 9606 bit32 ataError; 9607 #endif 9608 smScsiInitiatorRequest_t *smScsiRequest; /* TD's smScsiXchg */ 9609 smScsiInitiatorRequest_t *smOrgScsiRequest; /* OS's smScsiXchg */ 9610 agsaSATAIdentifyData_t *pSATAIdData; 9611 bit8 *pInquiry; 9612 bit8 page = 0xFF; 9613 bit16 *tmpptr,tmpptr_tmp; 9614 bit32 x; 9615 bit32 lenReceived = 0; 9616 bit32 allocationLen = 0; 9617 bit32 lenNeeded = 0; 9618 bit8 dataBuffer[SATA_PAGE89_INQUIRY_SIZE] = {0}; 9619 9620 9621 SM_DBG6(("smsatInquiryCB: start\n")); 9622 SM_DBG6(("smsatInquiryCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 9623 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; 9632 9633 if (satIntIo == agNULL) 9634 { 9635 SM_DBG6(("smsatInquiryCB: External, OS generated\n")); 9636 pSense = satIOContext->pSense; 9637 scsiCmnd = satIOContext->pScsiCmnd; 9638 satOrgIOContext = satIOContext; 9639 smOrgIORequest = smIORequestBody->smIORequest; 9640 } 9641 else 9642 { 9643 SM_DBG6(("smsatInquiryCB: Internal, TD generated\n")); 9644 satOrgIOContext = satIOContext->satOrgIOContext; 9645 if (satOrgIOContext == agNULL) 9646 { 9647 SM_DBG1(("smsatInquiryCB: satOrgIOContext is NULL, wrong!!!\n")); 9648 return; 9649 } 9650 else 9651 { 9652 SM_DBG6(("smsatInquiryCB: satOrgIOContext is NOT NULL\n")); 9653 } 9654 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 9655 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 9656 pSense = satOrgIOContext->pSense; 9657 scsiCmnd = satOrgIOContext->pScsiCmnd; 9658 } 9659 9660 smOrgScsiRequest = satOrgIOContext->smScsiXchg; 9661 pInquiry = dataBuffer; 9662 9663 smIORequestBody->ioCompleted = agTRUE; 9664 smIORequestBody->ioStarted = agFALSE; 9665 9666 SM_DBG3(("smsatInquiryCB: did %d\n", oneDeviceData->id)); 9667 9668 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 9669 { 9670 SM_DBG1(("smsatInquiryCB: agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 9671 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY) 9672 { 9673 SM_DBG1(("smsatInquiryCB: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY!!!\n")); 9674 /* should NOT be retried */ 9675 tdsmIOCompletedCB( smRoot, 9676 smOrgIORequest, 9677 smIOFailed, 9678 smDetailNoLogin, 9679 agNULL, 9680 satOrgIOContext->interruptContext 9681 ); 9682 } 9683 else 9684 { 9685 SM_DBG1(("smsatInquiryCB: NOT OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY!!!\n")); 9686 tdsmIOCompletedCB( smRoot, 9687 smOrgIORequest, 9688 smIOFailed, 9689 smDetailNoLogin, 9690 agNULL, 9691 satOrgIOContext->interruptContext 9692 ); 9693 } 9694 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 9695 9696 smsatFreeIntIoResource( smRoot, 9697 oneDeviceData, 9698 satIntIo); 9699 return; 9700 } 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 9710 ) 9711 { 9712 SM_DBG1(("smsatInquiryCB: OSSA_IO_OPEN_CNX_ERROR!!!\n")); 9713 9714 tdsmIOCompletedCB( smRoot, 9715 smOrgIORequest, 9716 smIOFailed, 9717 smDetailNoLogin, 9718 agNULL, 9719 satOrgIOContext->interruptContext 9720 ); 9721 9722 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 9723 9724 smsatFreeIntIoResource( smRoot, 9725 oneDeviceData, 9726 satIntIo); 9727 return; 9728 } 9729 9730 if ( agIOStatus != OSSA_IO_SUCCESS || 9731 (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL && agIOInfoLen != 0) 9732 ) 9733 { 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 */ 9739 #endif 9740 SM_DBG1(("smsatInquiryCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError)); 9741 9742 /* Process abort case */ 9743 if (agIOStatus == OSSA_IO_ABORTED) 9744 { 9745 smsatProcessAbort(smRoot, 9746 smOrgIORequest, 9747 satOrgIOContext 9748 ); 9749 9750 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 9751 9752 smsatFreeIntIoResource( smRoot, 9753 oneDeviceData, 9754 satIntIo); 9755 return; 9756 } 9757 9758 tdsmIOCompletedCB( smRoot, 9759 smOrgIORequest, 9760 smIOFailed, 9761 smDetailOtherError, 9762 agNULL, 9763 satOrgIOContext->interruptContext 9764 ); 9765 9766 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 9767 9768 smsatFreeIntIoResource( smRoot, 9769 oneDeviceData, 9770 satIntIo); 9771 return; 9772 } 9773 9774 /* success */ 9775 9776 9777 /* Convert to host endian */ 9778 tmpptr = (bit16*)(smScsiRequest->sglVirtualAddr); 9779 for (x=0; x < sizeof(agsaSATAIdentifyData_t)/sizeof(bit16); x++) 9780 { 9781 OSSA_READ_LE_16(AGROOT, &tmpptr_tmp, tmpptr, 0); 9782 *tmpptr = tmpptr_tmp; 9783 tmpptr++; 9784 /*Print tmpptr_tmp here for debugging purpose*/ 9785 } 9786 9787 pSATAIdData = (agsaSATAIdentifyData_t *)(smScsiRequest->sglVirtualAddr); 9788 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)); 9793 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)); 9800 #endif 9801 // smhexdump("smsatInquiryCB Device ID Dev data",(bit8 *)&oneDeviceData->satIdentifyData, sizeof(agsaSATAIdentifyData_t)); 9802 9803 /* set oneDeviceData fields from IndentifyData */ 9804 smsatSetDevInfo(oneDeviceData,pSATAIdData); 9805 9806 allocationLen = ((scsiCmnd->cdb[3]) << 8) + scsiCmnd->cdb[4]; 9807 allocationLen = MIN(allocationLen, scsiCmnd->expDataLength); 9808 9809 /* SPC-4, spec 6.4 p 141 */ 9810 /* EVPD bit == 0 */ 9811 if (!(scsiCmnd->cdb[1] & SCSI_EVPD_MASK)) 9812 { 9813 /* Returns the standard INQUIRY data */ 9814 lenNeeded = STANDARD_INQUIRY_SIZE; 9815 9816 9817 smsatInquiryStandard(pInquiry, pSATAIdData, scsiCmnd); 9818 //smhexdump("smsatInquiryCB ***standard***", (bit8 *)pInquiry, 36); 9819 9820 } 9821 else 9822 { 9823 /* EVPD bit != 0 && PAGE CODE != 0 */ 9824 /* returns the pages of vital product data information */ 9825 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)) 9832 { 9833 smsatSetSensePayload( pSense, 9834 SCSI_SNSKEY_ILLEGAL_REQUEST, 9835 0, 9836 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 9837 satOrgIOContext); 9838 9839 tdsmIOCompletedCB( smRoot, 9840 smOrgIORequest, 9841 smIOSuccess, 9842 SCSI_STAT_CHECK_CONDITION, 9843 satOrgIOContext->pSmSenseData, 9844 satOrgIOContext->interruptContext ); 9845 9846 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 9847 9848 smsatFreeIntIoResource( smRoot, 9849 oneDeviceData, 9850 satIntIo); 9851 SM_DBG1(("smsatInquiryCB: invalid PAGE CODE 0x%x!!!\n", page)); 9852 return; 9853 } 9854 9855 /* checking length */ 9856 switch (page) 9857 { 9858 case INQUIRY_SUPPORTED_VPD_PAGE: 9859 lenNeeded = SATA_PAGE0_INQUIRY_SIZE; /* 9 */ 9860 break; 9861 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE: 9862 if (oneDeviceData->satWWNSupport) 9863 { 9864 lenNeeded = SATA_PAGE83_INQUIRY_WWN_SIZE; /* 16 */ 9865 } 9866 else 9867 { 9868 lenNeeded = SATA_PAGE83_INQUIRY_NO_WWN_SIZE; /* 76 */ 9869 } 9870 break; 9871 case INQUIRY_ATA_INFORMATION_VPD_PAGE: 9872 lenNeeded = SATA_PAGE89_INQUIRY_SIZE; /* 572 */ 9873 break; 9874 case INQUIRY_BLOCK_DEVICE_CHARACTERISTICS_VPD_PAGE: 9875 lenNeeded = SATA_PAGEB1_INQUIRY_SIZE; /* 64 */ 9876 break; 9877 default: 9878 SM_DBG1(("smsatInquiryCB: wrong!!! invalid PAGE CODE 0x%x!!!\n", page)); 9879 break; 9880 } 9881 9882 9883 /* 9884 * Fill in the Inquiry data depending on what Inquiry data we are returning. 9885 */ 9886 switch (page) 9887 { 9888 case INQUIRY_SUPPORTED_VPD_PAGE: 9889 smsatInquiryPage0(pInquiry, pSATAIdData); 9890 break; 9891 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE: 9892 smsatInquiryPage83(pInquiry, pSATAIdData, oneDeviceData); 9893 break; 9894 case INQUIRY_ATA_INFORMATION_VPD_PAGE: 9895 smsatInquiryPage89(pInquiry, pSATAIdData, oneDeviceData, lenReceived); 9896 break; 9897 case INQUIRY_BLOCK_DEVICE_CHARACTERISTICS_VPD_PAGE: 9898 smsatInquiryPageB1(pInquiry, pSATAIdData); 9899 break; 9900 default: 9901 SM_DBG1(("smsatInquiryCB: wrong!!! invalidinvalid PAGE CODE 0x%x!!!\n", page)); 9902 break; 9903 } 9904 } /* else */ 9905 9906 SM_DBG6(("smsatInquiryCB: calling tdsmIOCompletedCB\n")); 9907 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)) 9911 { 9912 if (tdsmSetDeviceQueueDepth(smRoot, 9913 smOrgIORequest, 9914 oneDeviceData->satNCQMaxIO-1 9915 ) == agFALSE) 9916 { 9917 SM_DBG1(("smsatInquiryCB: failed to call tdsmSetDeviceQueueDepth()!!! Q=%d\n", oneDeviceData->satNCQMaxIO)); 9918 } 9919 } 9920 9921 sm_memcpy(smOrgScsiRequest->sglVirtualAddr, dataBuffer, MIN(allocationLen, lenNeeded)); 9922 if (allocationLen > lenNeeded) 9923 { 9924 SM_DBG6(("smsatInquiryCB reporting underrun lenNeeded=0x%x allocationLen=0x%x smIORequest=%p\n", 9925 lenNeeded, allocationLen, smOrgIORequest)); 9926 9927 tdsmIOCompletedCB( smRoot, 9928 smOrgIORequest, 9929 smIOUnderRun, 9930 allocationLen - lenNeeded, 9931 agNULL, 9932 satOrgIOContext->interruptContext ); 9933 } 9934 else 9935 { 9936 tdsmIOCompletedCB( smRoot, 9937 smOrgIORequest, 9938 smIOSuccess, 9939 SCSI_STAT_GOOD, 9940 agNULL, 9941 satOrgIOContext->interruptContext); 9942 } 9943 9944 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 9945 9946 smsatFreeIntIoResource( smRoot, 9947 oneDeviceData, 9948 satIntIo); 9949 SM_DBG5(("smsatInquiryCB: device %p pending IO %d\n", oneDeviceData, oneDeviceData->satPendingIO)); 9950 SM_DBG6(("smsatInquiryCB: end\n")); 9951 return; 9952 } 9953 9954 osGLOBAL void 9955 smsatInquiryIntCB( 9956 smRoot_t *smRoot, 9957 smIORequest_t *smIORequest, 9958 smDeviceHandle_t *smDeviceHandle, 9959 smScsiInitiatorRequest_t *smScsiRequest, 9960 smSatIOContext_t *satIOContext 9961 ) 9962 { 9963 smScsiRspSense_t *pSense; 9964 smIniScsiCmnd_t *scsiCmnd; 9965 // satDeviceData_t *satDevData; 9966 smDeviceData_t *oneDeviceData; 9967 agsaSATAIdentifyData_t *pSATAIdData; 9968 9969 bit8 *pInquiry; 9970 bit8 page = 0xFF; 9971 bit32 lenReceived = 0; 9972 bit32 allocationLen = 0; 9973 bit32 lenNeeded = 0; 9974 bit8 dataBuffer[SATA_PAGE89_INQUIRY_SIZE] = {0}; 9975 9976 SM_DBG6(("smsatInquiryIntCB: start\n")); 9977 9978 pSense = satIOContext->pSense; 9979 scsiCmnd = &smScsiRequest->scsiCmnd; 9980 pInquiry = dataBuffer; 9981 oneDeviceData = satIOContext->pSatDevData; 9982 pSATAIdData = &oneDeviceData->satIdentifyData; 9983 9984 allocationLen = ((scsiCmnd->cdb[3]) << 8) + scsiCmnd->cdb[4]; 9985 allocationLen = MIN(allocationLen, scsiCmnd->expDataLength); 9986 9987 /* SPC-4, spec 6.4 p 141 */ 9988 /* EVPD bit == 0 */ 9989 if (!(scsiCmnd->cdb[1] & SCSI_EVPD_MASK)) 9990 { 9991 /* Returns the standard INQUIRY data */ 9992 lenNeeded = STANDARD_INQUIRY_SIZE; 9993 9994 smsatInquiryStandard(pInquiry, pSATAIdData, scsiCmnd); 9995 //smhexdump("satInquiryIntCB ***standard***", (bit8 *)pInquiry, 36); 9996 9997 } 9998 else 9999 { 10000 /* EVPD bit != 0 && PAGE CODE != 0 */ 10001 /* returns the pages of vital product data information */ 10002 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)) 10010 { 10011 smsatSetSensePayload( pSense, 10012 SCSI_SNSKEY_ILLEGAL_REQUEST, 10013 0, 10014 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10015 satIOContext); 10016 10017 tdsmIOCompletedCB( smRoot, 10018 smIORequest, 10019 smIOSuccess, 10020 SCSI_STAT_CHECK_CONDITION, 10021 satIOContext->pSmSenseData, 10022 satIOContext->interruptContext ); 10023 10024 SM_DBG1(("smsatInquiryIntCB: invalid PAGE CODE 0x%x!!!\n", page)); 10025 return; 10026 } 10027 10028 /* checking length */ 10029 switch (page) 10030 { 10031 case INQUIRY_SUPPORTED_VPD_PAGE: 10032 lenNeeded = SATA_PAGE0_INQUIRY_SIZE; /* 36 */ 10033 break; 10034 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE: 10035 if (oneDeviceData->satWWNSupport) 10036 { 10037 lenNeeded = SATA_PAGE83_INQUIRY_WWN_SIZE; /* 16 */ 10038 } 10039 else 10040 { 10041 lenNeeded = SATA_PAGE83_INQUIRY_NO_WWN_SIZE; /* 76 */ 10042 } 10043 break; 10044 case INQUIRY_ATA_INFORMATION_VPD_PAGE: 10045 lenNeeded = SATA_PAGE89_INQUIRY_SIZE; /* 572 */ 10046 break; 10047 case INQUIRY_UNIT_SERIAL_NUMBER_VPD_PAGE: 10048 lenNeeded = SATA_PAGE80_INQUIRY_SIZE; /* 24 */ 10049 break; 10050 case INQUIRY_BLOCK_DEVICE_CHARACTERISTICS_VPD_PAGE: 10051 lenNeeded = SATA_PAGEB1_INQUIRY_SIZE; /* 64 */ 10052 break; 10053 default: 10054 SM_DBG1(("smsatInquiryIntCB: wrong!!! invalidinvalid PAGE CODE 0x%x!!!\n", page)); 10055 break; 10056 } 10057 10058 10059 /* 10060 * Fill in the Inquiry data depending on what Inquiry data we are returning. 10061 */ 10062 switch (page) 10063 { 10064 case INQUIRY_SUPPORTED_VPD_PAGE: 10065 smsatInquiryPage0(pInquiry, pSATAIdData); 10066 break; 10067 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE: 10068 smsatInquiryPage83(pInquiry, pSATAIdData, oneDeviceData); 10069 break; 10070 case INQUIRY_ATA_INFORMATION_VPD_PAGE: 10071 smsatInquiryPage89(pInquiry, pSATAIdData, oneDeviceData, lenReceived); 10072 break; 10073 case INQUIRY_UNIT_SERIAL_NUMBER_VPD_PAGE: 10074 smsatInquiryPage80(pInquiry, pSATAIdData); 10075 break; 10076 case INQUIRY_BLOCK_DEVICE_CHARACTERISTICS_VPD_PAGE: 10077 smsatInquiryPageB1(pInquiry, pSATAIdData); 10078 break; 10079 default: 10080 SM_DBG1(("smsatInquiryIntCB: wrong!!! invalidinvalid PAGE CODE 0x%x!!!\n", page)); 10081 break; 10082 } 10083 } /* else */ 10084 10085 SM_DBG6(("smsatInquiryIntCB: calling tdsmIOCompletedCB\n")); 10086 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)) 10090 { 10091 if (tdsmSetDeviceQueueDepth(smRoot, 10092 smIORequest, 10093 oneDeviceData->satNCQMaxIO-1 10094 ) == agFALSE) 10095 { 10096 SM_DBG1(("smsatInquiryIntCB: failed to call tdsmSetDeviceQueueDepth()!!! Q=%d\n", oneDeviceData->satNCQMaxIO)); 10097 } 10098 } 10099 10100 sm_memcpy(smScsiRequest->sglVirtualAddr, dataBuffer, MIN(allocationLen, lenNeeded)); 10101 if (allocationLen > lenNeeded) 10102 { 10103 SM_DBG6(("smsatInquiryIntCB reporting underrun lenNeeded=0x%x allocationLen=0x%x smIORequest=%p\n", 10104 lenNeeded, allocationLen, smIORequest)); 10105 10106 tdsmIOCompletedCB( smRoot, 10107 smIORequest, 10108 smIOUnderRun, 10109 allocationLen - lenNeeded, 10110 agNULL, 10111 satIOContext->interruptContext ); 10112 } 10113 else 10114 { 10115 tdsmIOCompletedCB( smRoot, 10116 smIORequest, 10117 smIOSuccess, 10118 SCSI_STAT_GOOD, 10119 agNULL, 10120 satIOContext->interruptContext); 10121 } 10122 10123 SM_DBG5(("smsatInquiryIntCB: device %p pending IO %d\n", oneDeviceData, oneDeviceData->satPendingIO)); 10124 SM_DBG6(("smsatInquiryIntCB: end\n")); 10125 return; 10126 10127 } 10128 10129 osGLOBAL void 10130 smsatVerify10CB( 10131 agsaRoot_t *agRoot, 10132 agsaIORequest_t *agIORequest, 10133 bit32 agIOStatus, 10134 agsaFisHeader_t *agFirstDword, 10135 bit32 agIOInfoLen, 10136 void *agParam, 10137 void *ioContext 10138 ) 10139 { 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; 10149 10150 smScsiRspSense_t *pSense; 10151 smIORequest_t *smOrgIORequest; 10152 10153 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 10154 bit32 ataStatus = 0; 10155 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 10156 10157 SM_DBG5(("smsatVerify10CB: start\n")); 10158 SM_DBG5(("smsatVerify10CB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 10159 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; 10169 10170 if (satIntIo == agNULL) 10171 { 10172 SM_DBG4(("smsatVerify10CB: External smSatInternalIo_t satIntIoContext\n")); 10173 satOrgIOContext = satIOContext; 10174 smOrgIORequest = smIORequestBody->smIORequest; 10175 pSense = satIOContext->pSense; 10176 } 10177 else 10178 { 10179 SM_DBG4(("smsatVerify10CB: Internal smSatInternalIo_t satIntIoContext\n")); 10180 satOrgIOContext = satIOContext->satOrgIOContext; 10181 if (satOrgIOContext == agNULL) 10182 { 10183 SM_DBG4(("smsatVerify10CB: satOrgIOContext is NULL, wrong\n")); 10184 return; 10185 } 10186 else 10187 { 10188 SM_DBG4(("smsatVerify10CB: satOrgIOContext is NOT NULL\n")); 10189 } 10190 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 10191 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 10192 pSense = satOrgIOContext->pSense; 10193 } 10194 10195 smIORequestBody->ioCompleted = agTRUE; 10196 smIORequestBody->ioStarted = agFALSE; 10197 10198 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 10199 { 10200 SM_DBG1(("smsatVerify10CB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 10201 smsatSetSensePayload( pSense, 10202 SCSI_SNSKEY_NO_SENSE, 10203 0, 10204 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 10205 satOrgIOContext); 10206 10207 tdsmIOCompletedCB( smRoot, 10208 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 10209 smIOSuccess, 10210 SCSI_STAT_CHECK_CONDITION, 10211 satOrgIOContext->pSmSenseData, 10212 satOrgIOContext->interruptContext ); 10213 10214 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 10215 10216 smsatFreeIntIoResource( smRoot, 10217 oneDeviceData, 10218 satIntIo); 10219 return; 10220 } 10221 10222 if (agIOStatus != OSSA_IO_SUCCESS) 10223 { 10224 /* only agsaFisRegDeviceToHost_t is expected */ 10225 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 10226 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 10227 } 10228 10229 if( agIOStatus != OSSA_IO_SUCCESS) 10230 { 10231 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 10232 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 10233 ) 10234 { 10235 /* for debugging */ 10236 if( agIOStatus != OSSA_IO_SUCCESS) 10237 { 10238 SM_DBG1(("smsatVerify10CB: FAILED, NOT IO_SUCCESS!!!\n")); 10239 } 10240 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 10241 { 10242 SM_DBG1(("smsatVerify10CB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 10243 } 10244 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 10245 (ataStatus & DF_ATA_STATUS_MASK) 10246 ) 10247 { 10248 SM_DBG1(("smsatVerify10CB: FAILED, FAILED, error status!!!\n")); 10249 } 10250 10251 /* Process abort case */ 10252 if (agIOStatus == OSSA_IO_ABORTED) 10253 { 10254 smsatProcessAbort(smRoot, 10255 smOrgIORequest, 10256 satOrgIOContext 10257 ); 10258 10259 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 10260 10261 smsatFreeIntIoResource( smRoot, 10262 oneDeviceData, 10263 satIntIo); 10264 return; 10265 } 10266 10267 /* for debugging */ 10268 switch (hostToDevFis->h.command) 10269 { 10270 case SAT_READ_VERIFY_SECTORS_EXT: 10271 SM_DBG1(("smsatVerify10CB: SAT_READ_VERIFY_SECTORS_EXT!!!\n")); 10272 break; 10273 default: 10274 SM_DBG1(("smsatVerify10CB: error default case command 0x%x!!!\n", hostToDevFis->h.command)); 10275 break; 10276 } 10277 10278 smsatSetSensePayload( pSense, 10279 SCSI_SNSKEY_NO_SENSE, 10280 0, 10281 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 10282 satOrgIOContext); 10283 10284 tdsmIOCompletedCB( smRoot, 10285 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 10286 smIOSuccess, 10287 SCSI_STAT_CHECK_CONDITION, 10288 satOrgIOContext->pSmSenseData, 10289 satOrgIOContext->interruptContext ); 10290 10291 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 10292 10293 smsatFreeIntIoResource( smRoot, 10294 oneDeviceData, 10295 satIntIo); 10296 return; 10297 } /* end error checking */ 10298 } 10299 10300 /* process success from this point on */ 10301 switch (hostToDevFis->h.command) 10302 { 10303 case SAT_READ_VERIFY_SECTORS_EXT: 10304 SM_DBG5(("smsatVerify10CB: SAT_WRITE_DMA_EXT success \n")); 10305 10306 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 10307 10308 smsatFreeIntIoResource( smRoot, 10309 oneDeviceData, 10310 satIntIo); 10311 10312 tdsmIOCompletedCB( smRoot, 10313 smOrgIORequest, 10314 smIOSuccess, 10315 SCSI_STAT_GOOD, 10316 agNULL, 10317 satOrgIOContext->interruptContext); 10318 break; 10319 default: 10320 SM_DBG1(("smsatVerify10CB: success but error default case command 0x%x!!!\n", hostToDevFis->h.command)); 10321 10322 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 10323 10324 smsatFreeIntIoResource( smRoot, 10325 oneDeviceData, 10326 satIntIo); 10327 10328 smsatSetSensePayload( pSense, 10329 SCSI_SNSKEY_NO_SENSE, 10330 0, 10331 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 10332 satOrgIOContext); 10333 10334 tdsmIOCompletedCB( smRoot, 10335 smOrgIORequest, /* == &satIntIo->satOrgSmIORequest */ 10336 smIOSuccess, 10337 SCSI_STAT_CHECK_CONDITION, 10338 satOrgIOContext->pSmSenseData, 10339 satOrgIOContext->interruptContext ); 10340 10341 break; 10342 } 10343 10344 return; 10345 } 10346 10347 osGLOBAL void 10348 smsatReadLogExtCB( 10349 agsaRoot_t *agRoot, 10350 agsaIORequest_t *agIORequest, 10351 bit32 agIOStatus, 10352 agsaFisHeader_t *agFirstDword, 10353 bit32 agIOInfoLen, 10354 void *agParam, 10355 void *ioContext 10356 ) 10357 { 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; 10368 bit32 PhysUpper32; 10369 bit32 PhysLower32; 10370 bit32 memAllocStatus; 10371 void *osMemHandle; 10372 smDeviceHandle_t *smDeviceHandle; 10373 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); 10389 10390 smIORequestBody->ioCompleted = agTRUE; 10391 smIORequestBody->ioStarted = agFALSE; 10392 10393 /* 10394 * If READ LOG EXT failed, we issue device reset. 10395 */ 10396 if ( agIOStatus != OSSA_IO_SUCCESS || 10397 (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL && agIOInfoLen != 0) 10398 ) 10399 { 10400 SM_DBG1(("smsatReadLogExtCB: FAILED.!!!\n")); 10401 10402 smsatFreeIntIoResource( smRoot, 10403 oneDeviceData, 10404 satIntIo); 10405 /* Abort I/O after completion of device reset */ 10406 oneDeviceData->satAbortAfterReset = agTRUE; 10407 #ifdef NOT_YET 10408 /* needs to investigate this case */ 10409 /* no report to OS layer */ 10410 satSubTM(smRoot, 10411 satReadLogExtIOContext->ptiDeviceHandle, 10412 TD_INTERNAL_TM_RESET, 10413 agNULL, 10414 agNULL, 10415 agNULL, 10416 agFALSE); 10417 #endif 10418 return; 10419 } 10420 10421 10422 /*************************************************************************** 10423 * The following steps take place when READ LOG EXT successfully completed. 10424 ***************************************************************************/ 10425 10426 /************************************************************************ 10427 * 10428 * 1. Issue abort to LL layer to all other pending I/Os for the same SATA 10429 * drive. 10430 * 10431 * 2. Free resource allocated for the internally generated READ LOG EXT. 10432 * 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. 10437 * 10438 ***********************************************************************/ 10439 10440 /* 10441 * Issue abort to LL layer to all other pending I/Os for the same SATA drive 10442 */ 10443 /* 10444 replace the single IO abort with device abort 10445 */ 10446 10447 SM_DBG1(("smsatReadLogExtCB: issuing saSATAAbort. Device Abort!!!\n")); 10448 oneDeviceData->SMAbortAll = agTRUE; 10449 /* 10450 smAbortIORequestBody = smDequeueIO(smRoot); 10451 10452 if (smAbortIORequestBody == agNULL) 10453 { 10454 SM_DBG1(("smsatReadLogExtCB: empty freeIOList!!!\n")); 10455 return; 10456 } 10457 */ 10458 /* allocating agIORequest for abort itself */ 10459 memAllocStatus = tdsmAllocMemory( 10460 smRoot, 10461 &osMemHandle, 10462 (void **)&smAbortIORequestBody, 10463 &PhysUpper32, 10464 &PhysLower32, 10465 8, 10466 sizeof(smIORequestBody_t), 10467 agTRUE 10468 ); 10469 10470 if (memAllocStatus != tiSuccess) 10471 { 10472 /* let os process IO */ 10473 SM_DBG1(("smsatReadLogExtCB: ostiAllocMemory failed...\n")); 10474 return; 10475 } 10476 10477 if (smAbortIORequestBody == agNULL) 10478 { 10479 /* let os process IO */ 10480 SM_DBG1(("smsatReadLogExtCB: ostiAllocMemory returned NULL smAbortIORequestBody\n")); 10481 return; 10482 } 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; 10491 10492 /* initialize agIORequest */ 10493 agAbortIORequest = &(smAbortIORequestBody->agIORequest); 10494 agAbortIORequest->osData = (void *) smAbortIORequestBody; 10495 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */ 10496 10497 /* 10498 * Issue abort (device abort all) 10499 */ 10500 saSATAAbort( agRoot, agAbortIORequest, tdsmRotateQnumber(smRoot, smDeviceHandle), oneDeviceData->agDevHandle, 1, agNULL, smaSATAAbortCB); 10501 10502 /* 10503 * Free resource allocated for the internally generated READ LOG EXT. 10504 */ 10505 smsatFreeIntIoResource( smRoot, 10506 oneDeviceData, 10507 satIntIo); 10508 10509 /* 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. 10515 */ 10516 10517 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL; 10518 10519 SM_DBG1(("smsatReadLogExtCB: end return!!!\n")); 10520 return; 10521 } 10522 10523 osGLOBAL void 10524 ossaSATAEvent( 10525 agsaRoot_t *agRoot, 10526 agsaIORequest_t *agIORequest, 10527 agsaPortContext_t *agPortContext, 10528 agsaDevHandle_t *agDevHandle, 10529 bit32 event, 10530 bit32 agIOInfoLen, 10531 void *agParam 10532 ) 10533 { 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; 10545 bit32 status; 10546 #ifdef REMOVED 10547 agsaDifDetails_t agDifDetails; 10548 bit8 framePayload[256]; 10549 bit16 frameOffset = 0; 10550 bit16 frameLen = 0; 10551 #endif 10552 10553 SM_DBG1(("ossaSATAEvent: start\n")); 10554 if (event == OSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE) 10555 { 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)) 10560 { 10561 oneDeviceData = SMLIST_OBJECT_BASE(smDeviceData_t, MainLink, DeviceListList); 10562 if (oneDeviceData == agNULL) 10563 { 10564 SM_DBG1(("ossaSATAEvent: oneDeviceData is NULL!!!\n")); 10565 return; 10566 } 10567 if (oneDeviceData->agDevHandle == agDevHandle) 10568 { 10569 SM_DBG2(("ossaSATAEvent: did %d\n", oneDeviceData->id)); 10570 found = agTRUE; 10571 break; 10572 } 10573 DeviceListList = DeviceListList->flink; 10574 } 10575 if (found == agFALSE) 10576 { 10577 SM_DBG2(("ossaSATAEvent: not found!!!\n")); 10578 return; 10579 } 10580 if (oneDeviceData->valid == agFALSE) 10581 { 10582 SM_DBG2(("ossaSATAEvent: oneDeviceData is not valid did %d!!!\n", oneDeviceData->id)); 10583 return; 10584 } 10585 /************************************************************************** 10586 * 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. !!!! 10593 * 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. 10596 * 10597 * Here is the basic flow or sequence of error recovery, this sequence is 10598 * similar to the one described in SATA 2.5: 10599 * 10600 * 1. Set SATA device flag to indicate error condition and returning busy 10601 * for all new request. 10602 * 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. 10605 * 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. 10609 * 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(). 10613 * 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. 10618 * 10619 * 6. Issue abort to LL layer to all other pending I/Os for the same SATA 10620 * drive. 10621 * 10622 * 7. Free resource allocated for the internally generated READ LOG EXT. 10623 * 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. 10628 * 10629 *************************************************************************/ 10630 10631 smDeviceHandle = oneDeviceData->smDevHandle; 10632 SM_DBG1(("ossaSATAEvent: did %d!!!\n", oneDeviceData->id)); 10633 10634 if (oneDeviceData->satDriveState == SAT_DEV_STATE_NORMAL) 10635 { 10636 SM_DBG1(("ossaSATAEvent: NCQ ERROR did %d!!!\n", oneDeviceData->id )); 10637 10638 /* Set flag to indicate we are in recovery */ 10639 oneDeviceData->satDriveState = SAT_DEV_STATE_IN_RECOVERY; 10640 10641 /* 10642 * Allocate resource for READ LOG EXIT page 10h 10643 */ 10644 satIntIo = smsatAllocIntIoResource( smRoot, 10645 &(smIORequestTMP), /* anything but NULL */ 10646 oneDeviceData, 10647 sizeof (satReadLogExtPage10h_t), 10648 satIntIo); 10649 10650 /* 10651 * If we cannot allocate resource to do the normal NCQ recovery, we 10652 * will do SATA device reset. 10653 */ 10654 if (satIntIo == agNULL) 10655 { 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")); 10659 10660 #ifdef NOT_YET 10661 /* needs to investigate this case */ 10662 /* no report to OS layer */ 10663 smsatSubTM(smRoot, 10664 smDeviceHandle, 10665 TD_INTERNAL_TM_RESET, 10666 agNULL, 10667 agNULL, 10668 agNULL, 10669 agFALSE); 10670 #endif 10671 10672 return; 10673 } 10674 10675 10676 /* 10677 * Clear flag to indicate that the failed I/O has NOT been returned to the 10678 * OS-App specific Layer. 10679 */ 10680 satIntIo->satIntFlag = 0; 10681 10682 /* compare to satPrepareNewIO() */ 10683 /* Send READ LOG EXIT page 10h command */ 10684 10685 /* 10686 * Need to initialize all the fields within satIOContext except 10687 * reqType and satCompleteCB which will be set depending on cmd. 10688 */ 10689 10690 smIORequestBody = (smIORequestBody_t *)satIntIo->satIntRequestBody; 10691 satIOContext2 = &(smIORequestBody->transport.SATA.satIOContext); 10692 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; 10699 10700 satIOContext2->smRequestBody = satIntIo->satIntRequestBody; 10701 //not used 10702 // satIOContext2->interruptContext = interruptContext; 10703 satIOContext2->satIntIoContext = satIntIo; 10704 10705 satIOContext2->psmDeviceHandle = smDeviceHandle; 10706 satIOContext2->satOrgIOContext = agNULL; 10707 satIOContext2->smScsiXchg = agNULL; 10708 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, 10713 smDeviceHandle, 10714 &satIntIo->satIntSmScsiXchg, 10715 satIOContext2); 10716 10717 if (status != SM_RC_SUCCESS) 10718 { 10719 SM_DBG1(("ossaSATAEvent: can't send RLE due to LL api failure!!!\n")); 10720 smsatFreeIntIoResource( smRoot, 10721 oneDeviceData, 10722 satIntIo); 10723 /* Abort I/O after completion of device reset */ 10724 oneDeviceData->satAbortAfterReset = agTRUE; 10725 #ifdef NOT_YET 10726 /* needs to investigate this case */ 10727 /* no report to OS layer */ 10728 smsatSubTM(smRoot, 10729 smDeviceHandle, 10730 TD_INTERNAL_TM_RESET, 10731 agNULL, 10732 agNULL, 10733 agNULL, 10734 agFALSE); 10735 #endif 10736 10737 return; 10738 } 10739 } 10740 else 10741 { 10742 SM_DBG1(("ossaSATAEvent: NCQ ERROR but recovery in progress!!!\n")); 10743 } 10744 } 10745 else if (event == OSSA_IO_XFER_CMD_FRAME_ISSUED) 10746 { 10747 SM_DBG1(("ossaSATAEvent: OSSA_IO_XFER_CMD_FRAME_ISSUED\n")); 10748 } 10749 else if (event == OSSA_IO_XFER_PIO_SETUP_ERROR) 10750 { 10751 SM_DBG1(("ossaSATAEvent: OSSA_IO_XFER_PIO_SETUP_ERROR\n")); 10752 } 10753 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED) 10754 { 10755 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED\n")); 10756 } 10757 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO) 10758 { 10759 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO\n")); 10760 } 10761 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST) 10762 { 10763 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST\n")); 10764 } 10765 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE) 10766 { 10767 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE\n")); 10768 } 10769 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED) 10770 { 10771 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED\n")); 10772 } 10773 else if (event == OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH) 10774 { 10775 SM_DBG1(("ossaSATAEvent: OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH\n")); 10776 } 10777 #ifdef REMOVED 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 ) 10780 { 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) 10785 { 10786 SM_DBG2(("ossaSATAEvent: agParam is NULL!!!\n")); 10787 return; 10788 } 10789 if (agIOInfoLen < sizeof(agsaDifDetails_t)) 10790 { 10791 SM_DBG2(("ossaSATAEvent: wrong agIOInfoLen!!! agIOInfoLen %d sizeof(agsaDifDetails_t) %d\n", agIOInfoLen, (int)sizeof(agsaDifDetails_t))); 10792 return; 10793 } 10794 /* reads agsaDifDetails_t */ 10795 saFrameReadBlock(agRoot, agParam, 0, &agDifDetails, sizeof(agsaDifDetails_t)); 10796 frameOffset = (agDifDetails.ErrBoffsetEDataLen & 0xFFFF); 10797 frameLen = (agDifDetails.ErrBoffsetEDataLen & 0xFFFF0000) >> 16; 10798 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) 10805 { 10806 saFrameReadBlock(agRoot, agParam, sizeof(agsaDifDetails_t), framePayload, frameLen); 10807 smhexdump("ossaSATAEvent frame", framePayload, frameLen); 10808 } 10809 } 10810 #endif 10811 else if (event == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY) 10812 { 10813 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 10814 if (smIORequestBody == agNULL) 10815 { 10816 SM_DBG1(("ossaSATAEvent: smIORequestBody is NULL!!!\n")); 10817 return; 10818 } 10819 smDeviceHandle = smIORequestBody->smDevHandle; 10820 if (smDeviceHandle == agNULL) 10821 { 10822 SM_DBG1(("ossaSATAEvent: smDeviceHandle is NULL!!!\n")); 10823 return; 10824 } 10825 oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData; 10826 if (oneDeviceData == agNULL) 10827 { 10828 SM_DBG1(("ossaSATAEvent: oneDeviceData is NULL!!!\n")); 10829 return; 10830 } 10831 SM_DBG1(("ossaSATAEvent: ERROR event %d did=%d\n", event, oneDeviceData->id)); 10832 10833 10834 if (smAllShared->FCA) 10835 { 10836 if (oneDeviceData->SMNumOfFCA <= 0) /* does SMP HARD RESET only upto one time */ 10837 { 10838 SM_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; sending HARD_RESET\n")); 10839 oneDeviceData->SMNumOfFCA++; 10840 smPhyControlSend(smRoot, 10841 oneDeviceData, 10842 SMP_PHY_CONTROL_HARD_RESET, 10843 agNULL, 10844 tdsmRotateQnumber(smRoot, smDeviceHandle) 10845 ); 10846 } 10847 else 10848 { 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")); 10851 } 10852 } 10853 } 10854 else if (event == OSSA_IO_XFER_ERROR_NAK_RECEIVED) 10855 { 10856 SM_DBG1(("ossaSATAEvent: OSSA_IO_XFER_ERROR_NAK_RECEIVED\n")); 10857 } 10858 else if (event == OSSA_IO_XFER_ERROR_DMA_ACTIVATE_TIMEOUT) 10859 { 10860 SM_DBG1(("ossaSATAEvent: OSSA_IO_XFER_ERROR_DMA_ACTIVATE_TIMEOUT\n")); 10861 } 10862 else 10863 { 10864 SM_DBG1(("ossaSATAEvent: other event 0x%x\n", event)); 10865 } 10866 10867 return; 10868 } 10869 10870 osGLOBAL void 10871 smSMPCompletedCB( 10872 agsaRoot_t *agRoot, 10873 agsaIORequest_t *agIORequest, 10874 bit32 agIOStatus, 10875 bit32 agIOInfoLen, 10876 agsaFrameHandle_t agFrameHandle 10877 ) 10878 { 10879 smSMPRequestBody_t *smSMPRequestBody = (smSMPRequestBody_t *) agIORequest->osData; 10880 10881 SM_DBG2(("smSMPCompletedCB: start\n")); 10882 10883 if (smSMPRequestBody == agNULL) 10884 { 10885 SM_DBG1(("smSMPCompletedCB: smSMPRequestBody is NULL!!!\n")); 10886 return; 10887 } 10888 10889 if (smSMPRequestBody->SMPCompletionFunc == agNULL) 10890 { 10891 SM_DBG1(("smSMPCompletedCB: smSMPRequestBody->SMPCompletionFunc is NULL!!!\n")); 10892 return; 10893 } 10894 10895 /* calling smSMPCompleted */ 10896 smSMPRequestBody->SMPCompletionFunc( 10897 agRoot, 10898 agIORequest, 10899 agIOStatus, 10900 agIOInfoLen, 10901 agFrameHandle 10902 ); 10903 return; 10904 } 10905 10906 osGLOBAL void 10907 smSMPCompleted( 10908 agsaRoot_t *agRoot, 10909 agsaIORequest_t *agIORequest, 10910 bit32 agIOStatus, 10911 bit32 agIOInfoLen, 10912 agsaFrameHandle_t agFrameHandle 10913 ) 10914 { 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; 10920 bit8 smpHeader[4]; 10921 smSMPFrameHeader_t *smSMPFrameHeader; 10922 agsaDevHandle_t *agDevHandle = agNULL; 10923 10924 SM_DBG2(("smSMPCompleted: start\n")); 10925 10926 if (smSMPRequestBody == agNULL) 10927 { 10928 SM_DBG1(("smSMPCompleted: smSMPRequestBody is NULL, wrong!!!\n")); 10929 return; 10930 } 10931 10932 CurrentTaskTag = smSMPRequestBody->CurrentTaskTag; 10933 oneDeviceData = smSMPRequestBody->smDeviceData; 10934 smDeviceHandle = smSMPRequestBody->smDevHandle; 10935 if (smDeviceHandle == agNULL) 10936 { 10937 SM_DBG2(("smSMPCompleted: smDeviceHandle is NULL, wrong!!!\n")); 10938 return; 10939 } 10940 10941 if (oneDeviceData == agNULL) 10942 { 10943 SM_DBG2(("smSMPCompleted: oneDeviceData is NULL, wrong!!!\n")); 10944 return; 10945 } 10946 agDevHandle = oneDeviceData->agExpDevHandle; 10947 if (agIOStatus == OSSA_IO_SUCCESS) 10948 { 10949 saFrameReadBlock(agRoot, agFrameHandle, 0, smpHeader, 4); 10950 smSMPFrameHeader = (smSMPFrameHeader_t *)smpHeader; 10951 if (smSMPFrameHeader->smpFunction == SMP_PHY_CONTROL) 10952 { 10953 SM_DBG3(("smSMPCompleted: phy control\n")); 10954 if (agIOInfoLen != 4 && 10955 smSMPFrameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED) /*zero length is expected */ 10956 { 10957 SM_DBG1(("smSMPCompleted: mismatch len agIOInfoLen 0x%x 0x%x!!!\n", agIOInfoLen, 4)); 10958 tdsmFreeMemory( 10959 smRoot, 10960 smSMPRequestBody->osMemHandle, 10961 sizeof(smSMPRequestBody_t) 10962 ); 10963 if (CurrentTaskTag != agNULL) 10964 { 10965 tdsmEventCB(smRoot, 10966 smDeviceHandle, 10967 smIntrEventTypeTaskManagement, 10968 smTMFailed, 10969 CurrentTaskTag); 10970 } 10971 10972 return; 10973 } 10974 smPhyControlRespRcvd(smRoot, 10975 agRoot, 10976 agIORequest, 10977 oneDeviceData, 10978 smSMPFrameHeader, 10979 agFrameHandle, 10980 CurrentTaskTag 10981 ); 10982 } 10983 else 10984 { 10985 /* unknown SMP function */ 10986 SM_DBG2(("smSMPCompleted: unknown smSMPFrameHeader %d!!!\n", smSMPFrameHeader->smpFunction)); 10987 tdsmFreeMemory( 10988 smRoot, 10989 smSMPRequestBody->osMemHandle, 10990 sizeof(smSMPRequestBody_t) 10991 ); 10992 if (CurrentTaskTag != agNULL) 10993 { 10994 tdsmEventCB(smRoot, 10995 smDeviceHandle, 10996 smIntrEventTypeTaskManagement, 10997 smTMFailed, 10998 CurrentTaskTag); 10999 } 11000 return; 11001 } 11002 } 11003 else 11004 { 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 11013 ) 11014 { 11015 SM_DBG1(("smSMPCompleted: setting back to operational\n")); 11016 if (agDevHandle != agNULL) 11017 { 11018 saSetDeviceState(agRoot, agNULL, tdsmRotateQnumber(smRoot, smDeviceHandle), agDevHandle, SA_DS_OPERATIONAL); 11019 } 11020 else 11021 { 11022 SM_DBG1(("smSMPCompleted: agDevHandle is NULL\n")); 11023 } 11024 } 11025 tdsmFreeMemory( 11026 smRoot, 11027 smSMPRequestBody->osMemHandle, 11028 sizeof(smSMPRequestBody_t) 11029 ); 11030 if (CurrentTaskTag != agNULL) 11031 { 11032 tdsmEventCB(smRoot, 11033 smDeviceHandle, 11034 smIntrEventTypeTaskManagement, 11035 smTMFailed, 11036 CurrentTaskTag); 11037 } 11038 return; 11039 } 11040 11041 tdsmFreeMemory( 11042 smRoot, 11043 smSMPRequestBody->osMemHandle, 11044 sizeof(smSMPRequestBody_t) 11045 ); 11046 return; 11047 } 11048 11049 osGLOBAL void 11050 smPhyControlRespRcvd( 11051 smRoot_t *smRoot, 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 11058 ) 11059 { 11060 smDeviceData_t *TargetDeviceData = agNULL; 11061 agsaDevHandle_t *agDevHandle = agNULL; 11062 smSMPRequestBody_t *smSMPRequestBody; 11063 smDeviceHandle_t *smDeviceHandle; 11064 11065 SM_DBG2(("smPhyControlRespRcvd: start\n")); 11066 11067 if (CurrentTaskTag == agNULL ) 11068 { 11069 SM_DBG1(("smPhyControlRespRcvd: CurrentTaskTag is NULL; allowed\n")); 11070 return; 11071 } 11072 11073 smSMPRequestBody = (smSMPRequestBody_t *)CurrentTaskTag->smData; 11074 if (smSMPRequestBody == agNULL) 11075 { 11076 SM_DBG1(("smPhyControlRespRcvd: smSMPRequestBody is NULL!!!\n")); 11077 return; 11078 } 11079 11080 smDeviceHandle = smSMPRequestBody->smDevHandle; 11081 if (smDeviceHandle == agNULL) 11082 { 11083 SM_DBG2(("smPhyControlRespRcvd: smDeviceHandle is NULL!!!\n")); 11084 return; 11085 } 11086 11087 TargetDeviceData = smSMPRequestBody->smDeviceData; 11088 if (oneDeviceData != TargetDeviceData) 11089 { 11090 SM_DBG1(("smPhyControlRespRcvd: oneDeviceData != TargetDeviceData!!!\n")); 11091 return; 11092 } 11093 11094 agDevHandle = TargetDeviceData->agDevHandle; 11095 11096 11097 if (frameHeader->smpFunctionResult == SMP_FUNCTION_ACCEPTED) 11098 { 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); 11103 11104 tdsmEventCB(smRoot, 11105 smDeviceHandle, 11106 smIntrEventTypeTaskManagement, 11107 smTMOK, 11108 CurrentTaskTag); 11109 } 11110 else 11111 { 11112 SM_DBG1(("smPhyControlRespRcvd: SMP failure; result %d!!!\n", frameHeader->smpFunctionResult)); 11113 tdsmEventCB(smRoot, 11114 smDeviceHandle, 11115 smIntrEventTypeTaskManagement, 11116 smTMFailed, 11117 CurrentTaskTag); 11118 } 11119 return; 11120 } 11121 11122 osGLOBAL void 11123 smsatCheckPowerModeCB( 11124 agsaRoot_t *agRoot, 11125 agsaIORequest_t *agIORequest, 11126 bit32 agIOStatus, 11127 agsaFisHeader_t *agFirstDword, 11128 bit32 agIOInfoLen, 11129 agsaFrameHandle_t agFrameHandle, 11130 void *ioContext 11131 ) 11132 { 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; 11149 bit32 ataError; 11150 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 11151 #endif 11152 bit32 AbortTM = agFALSE; 11153 smDeviceHandle_t *smDeviceHandle; 11154 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) 11165 { 11166 SM_DBG6(("smsatCheckPowerModeCB: External, OS generated\n")); 11167 satOrgIOContext = satIOContext; 11168 } 11169 else 11170 { 11171 SM_DBG6(("smsatCheckPowerModeCB: Internal, TD generated\n")); 11172 satOrgIOContext = satIOContext->satOrgIOContext; 11173 if (satOrgIOContext == agNULL) 11174 { 11175 SM_DBG6(("smsatCheckPowerModeCB: satOrgIOContext is NULL, wrong\n")); 11176 return; 11177 } 11178 else 11179 { 11180 SM_DBG6(("smsatCheckPowerModeCB: satOrgIOContext is NOT NULL\n")); 11181 } 11182 } 11183 smIORequestBody->ioCompleted = agTRUE; 11184 smIORequestBody->ioStarted = agFALSE; 11185 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 11186 { 11187 SM_DBG1(("smsatCheckPowerModeCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 11188 /* TM completed */ 11189 tdsmEventCB( smRoot, 11190 smDeviceHandle, 11191 smIntrEventTypeTaskManagement, 11192 smTMFailed, 11193 oneDeviceData->satTmTaskTag); 11194 11195 oneDeviceData->satTmTaskTag = agNULL; 11196 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11197 11198 smsatFreeIntIoResource( smRoot, 11199 oneDeviceData, 11200 satIntIo); 11201 return; 11202 } 11203 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 11213 ) 11214 { 11215 SM_DBG1(("smsatCheckPowerModeCB: OSSA_IO_OPEN_CNX_ERROR!!!\n")); 11216 /* TM completed */ 11217 tdsmEventCB( smRoot, 11218 smDeviceHandle, 11219 smIntrEventTypeTaskManagement, 11220 smTMFailed, 11221 oneDeviceData->satTmTaskTag); 11222 oneDeviceData->satTmTaskTag = agNULL; 11223 11224 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11225 smsatFreeIntIoResource( smRoot, 11226 oneDeviceData, 11227 satIntIo); 11228 return; 11229 } 11230 if (agIOStatus != OSSA_IO_SUCCESS) 11231 { 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 */ 11237 #endif 11238 SM_DBG1(("smsatCheckPowerModeCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError)); 11239 /* TM completed */ 11240 tdsmEventCB( smRoot, 11241 smDeviceHandle, 11242 smIntrEventTypeTaskManagement, 11243 smTMFailed, 11244 oneDeviceData->satTmTaskTag); 11245 oneDeviceData->satTmTaskTag = agNULL; 11246 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11247 smsatFreeIntIoResource( smRoot, 11248 oneDeviceData, 11249 satIntIo); 11250 return; 11251 } 11252 /* success */ 11253 SM_DBG1(("smsatCheckPowerModeCB: success!!!\n")); 11254 SM_DBG1(("smsatCheckPowerModeCB: TMF %d!!!\n", satOrgIOContext->TMF)); 11255 11256 if (satOrgIOContext->TMF == AG_ABORT_TASK) 11257 { 11258 AbortTM = agTRUE; 11259 } 11260 if (AbortTM == agTRUE) 11261 { 11262 SM_DBG1(("smsatCheckPowerModeCB: calling local satAbort!!!\n")); 11263 smsatAbort(smRoot, agRoot, satOrgIOContext->satToBeAbortedIOContext); 11264 } 11265 oneDeviceData->satTmTaskTag = agNULL; 11266 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL; 11267 11268 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11269 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, 11273 oneDeviceData, 11274 satIntIo); 11275 11276 /* TM completed */ 11277 tdsmEventCB( smRoot, 11278 smDeviceHandle, 11279 smIntrEventTypeTaskManagement, 11280 smTMOK, 11281 oneDeviceData->satTmTaskTag); 11282 SM_DBG5(("smsatCheckPowerModeCB: device %p pending IO %d\n", oneDeviceData, oneDeviceData->satPendingIO)); 11283 SM_DBG2(("smsatCheckPowerModeCB: end\n")); 11284 return; 11285 } 11286 11287 osGLOBAL void 11288 smsatCheckPowerModePassCB( 11289 agsaRoot_t *agRoot, 11290 agsaIORequest_t *agIORequest, 11291 bit32 agIOStatus, 11292 agsaFisHeader_t *agFirstDword, 11293 bit32 agIOInfoLen, 11294 agsaFrameHandle_t agFrameHandle, 11295 void *ioContext 11296 ) 11297 11298 { 11299 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; 11313 bit32 ataError; 11314 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 11315 #endif 11316 11317 smScsiRspSense_t *pSense; 11318 bit8 bSenseKey = 0; 11319 bit16 bSenseCodeInfo = 0; 11320 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; 11329 11330 if (satIntIo == agNULL) 11331 { 11332 SM_DBG6(("smsatCheckPowerModePassCB: External, OS generated\n")); 11333 satOrgIOContext = satIOContext; 11334 smOrgIORequest = smIORequestBody->smIORequest; 11335 pSense = satOrgIOContext->pSense; 11336 } 11337 else 11338 { 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) 11345 { 11346 SM_DBG6(("smsatCheckPowerModePassCB: satOrgIOContext is NULL, wrong\n")); 11347 return; 11348 } 11349 else 11350 { 11351 SM_DBG6(("smsatCheckPowerModePassCB: satOrgIOContext is NOT NULL\n")); 11352 } 11353 } 11354 smIORequestBody->ioCompleted = agTRUE; 11355 smIORequestBody->ioStarted = agFALSE; 11356 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 11357 { 11358 SM_DBG1(("smsatCheckPowerModePassCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 11359 11360 tdsmIOCompletedCB( 11361 smRoot, 11362 smOrgIORequest, 11363 smIOFailed, 11364 smDetailOtherError, 11365 agNULL, 11366 satOrgIOContext->interruptContext 11367 ); 11368 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11369 11370 smsatFreeIntIoResource( smRoot, 11371 oneDeviceData, 11372 satIntIo); 11373 return; 11374 11375 } 11376 11377 if (agIOStatus != OSSA_IO_SUCCESS) 11378 { 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 */ 11384 #endif 11385 SM_DBG1(("smsatCheckPowerModePassCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError)); 11386 11387 11388 if (agIOStatus == OSSA_IO_ABORTED) 11389 { 11390 smsatProcessAbort(smRoot, 11391 smOrgIORequest, 11392 satOrgIOContext 11393 ); 11394 11395 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11396 11397 smsatFreeIntIoResource( smRoot, 11398 oneDeviceData, 11399 satIntIo); 11400 return; 11401 } 11402 smsatTranslateATAErrorsToSCSIErrors( 11403 agFirstDword->D2H.status, 11404 agFirstDword->D2H.error, 11405 &bSenseKey, 11406 &bSenseCodeInfo 11407 ); 11408 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 11409 tdsmIOCompletedCB(smRoot, 11410 smOrgIORequest, 11411 smIOSuccess, 11412 SCSI_STAT_CHECK_CONDITION, 11413 satOrgIOContext->pSmSenseData, 11414 satOrgIOContext->interruptContext ); 11415 11416 11417 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11418 11419 smsatFreeIntIoResource( smRoot, 11420 oneDeviceData, 11421 satIntIo); 11422 return; 11423 11424 } 11425 /* success */ 11426 SM_DBG1(("smsatCheckPowerModePassCB: success!!!\n")); 11427 11428 tdsmIOCompletedCB( smRoot, 11429 smOrgIORequest, 11430 smIOSuccess, 11431 SCSI_STAT_GOOD, 11432 agNULL, 11433 satOrgIOContext->interruptContext); 11434 11435 11436 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11437 11438 smsatFreeIntIoResource( smRoot, 11439 oneDeviceData, 11440 satIntIo); 11441 11442 11443 return; 11444 } 11445 11446 osGLOBAL void 11447 smsatIDDataPassCB( 11448 agsaRoot_t *agRoot, 11449 agsaIORequest_t *agIORequest, 11450 bit32 agIOStatus, 11451 agsaFisHeader_t *agFirstDword, 11452 bit32 agIOInfoLen, 11453 agsaFrameHandle_t agFrameHandle, 11454 void *ioContext 11455 ) 11456 { 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; 11470 bit32 ataError; 11471 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 11472 #endif 11473 11474 smScsiRspSense_t *pSense; 11475 bit8 bSenseKey = 0; 11476 bit16 bSenseCodeInfo = 0; 11477 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; 11486 11487 if (satIntIo == agNULL) 11488 { 11489 SM_DBG6(("smsatIDDataPassCB: External, OS generated\n")); 11490 satOrgIOContext = satIOContext; 11491 smOrgIORequest = smIORequestBody->smIORequest; 11492 pSense = satOrgIOContext->pSense; 11493 } 11494 else 11495 { 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) 11502 { 11503 SM_DBG6(("smsatIDDataPassCB: satOrgIOContext is NULL, wrong\n")); 11504 return; 11505 } 11506 else 11507 { 11508 SM_DBG6(("smsatIDDataPassCB: satOrgIOContext is NOT NULL\n")); 11509 } 11510 } 11511 smIORequestBody->ioCompleted = agTRUE; 11512 smIORequestBody->ioStarted = agFALSE; 11513 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 11514 { 11515 SM_DBG1(("smsatIDDataPassCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 11516 11517 tdsmIOCompletedCB( 11518 smRoot, 11519 smOrgIORequest, 11520 smIOFailed, 11521 smDetailOtherError, 11522 agNULL, 11523 satOrgIOContext->interruptContext 11524 ); 11525 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11526 11527 smsatFreeIntIoResource( smRoot, 11528 oneDeviceData, 11529 satIntIo); 11530 return; 11531 11532 } 11533 11534 if (agIOStatus != OSSA_IO_SUCCESS) 11535 { 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 */ 11541 #endif 11542 SM_DBG1(("smsatIDDataPassCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError)); 11543 11544 11545 if (agIOStatus == OSSA_IO_ABORTED) 11546 { 11547 smsatProcessAbort(smRoot, 11548 smOrgIORequest, 11549 satOrgIOContext 11550 ); 11551 11552 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11553 11554 smsatFreeIntIoResource( smRoot, 11555 oneDeviceData, 11556 satIntIo); 11557 return; 11558 } 11559 smsatTranslateATAErrorsToSCSIErrors( 11560 agFirstDword->D2H.status, 11561 agFirstDword->D2H.error, 11562 &bSenseKey, 11563 &bSenseCodeInfo 11564 ); 11565 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 11566 tdsmIOCompletedCB(smRoot, 11567 smOrgIORequest, 11568 smIOSuccess, 11569 SCSI_STAT_CHECK_CONDITION, 11570 satOrgIOContext->pSmSenseData, 11571 satOrgIOContext->interruptContext ); 11572 11573 11574 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11575 11576 smsatFreeIntIoResource( smRoot, 11577 oneDeviceData, 11578 satIntIo); 11579 return; 11580 11581 } 11582 /* success */ 11583 SM_DBG3(("smsatIDDataPassCB: success!!!\n")); 11584 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)); 11589 11590 if (satIOContext->ck_cond) 11591 { 11592 smsatSetSensePayload( pSense, 11593 SCSI_SNSKEY_RECOVERED_ERROR, 11594 satOrgIOContext->sectorCnt07, 11595 SCSI_SNSCODE_ATA_PASS_THROUGH_INFORMATION_AVAILABLE, 11596 satIOContext); 11597 11598 tdsmIOCompletedCB( smRoot, 11599 smOrgIORequest, 11600 smIOSuccess, 11601 SCSI_STAT_CHECK_CONDITION, 11602 satIOContext->pSmSenseData, 11603 satOrgIOContext->interruptContext ); 11604 } 11605 else 11606 { 11607 tdsmIOCompletedCB( smRoot, 11608 smOrgIORequest, 11609 smIOSuccess, 11610 SCSI_STAT_GOOD, 11611 agNULL, 11612 satOrgIOContext->interruptContext); 11613 } 11614 11615 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11616 11617 smsatFreeIntIoResource( smRoot, 11618 oneDeviceData, 11619 satIntIo); 11620 11621 11622 return; 11623 } 11624 11625 osGLOBAL void 11626 smsatResetDeviceCB( 11627 agsaRoot_t *agRoot, 11628 agsaIORequest_t *agIORequest, 11629 bit32 agIOStatus, 11630 agsaFisHeader_t *agFirstDword, 11631 bit32 agIOInfoLen, 11632 agsaFrameHandle_t agFrameHandle, 11633 void *ioContext 11634 ) 11635 { 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; 11656 bit32 ataError; 11657 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 11658 #endif 11659 bit32 status; 11660 smDeviceHandle_t *smDeviceHandle; 11661 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; 11671 11672 if (satIntIo == agNULL) 11673 { 11674 SM_DBG6(("smsatResetDeviceCB: External, OS generated\n")); 11675 satOrgIOContext = satIOContext; 11676 smOrgIORequest = smIORequestBody->smIORequest; 11677 } 11678 else 11679 { 11680 SM_DBG6(("smsatResetDeviceCB: Internal, TD generated\n")); 11681 satOrgIOContext = satIOContext->satOrgIOContext; 11682 if (satOrgIOContext == agNULL) 11683 { 11684 SM_DBG6(("smsatResetDeviceCB: satOrgIOContext is NULL, wrong\n")); 11685 return; 11686 } 11687 else 11688 { 11689 SM_DBG6(("smsatResetDeviceCB: satOrgIOContext is NOT NULL\n")); 11690 } 11691 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 11692 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 11693 } 11694 smIORequestBody->ioCompleted = agTRUE; 11695 smIORequestBody->ioStarted = agFALSE; 11696 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 11697 { 11698 SM_DBG1(("smsatResetDeviceCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 11699 /* TM completed */ 11700 tdsmEventCB( smRoot, 11701 smDeviceHandle, 11702 smIntrEventTypeTaskManagement, 11703 smTMFailed, 11704 oneDeviceData->satTmTaskTag); 11705 oneDeviceData->satTmTaskTag = agNULL; 11706 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11707 smsatFreeIntIoResource( smRoot, 11708 oneDeviceData, 11709 satIntIo); 11710 return; 11711 } 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 11721 ) 11722 { 11723 SM_DBG1(("smsatResetDeviceCB: OSSA_IO_OPEN_CNX_ERROR!!!\n")); 11724 /* TM completed */ 11725 tdsmEventCB( smRoot, 11726 smDeviceHandle, 11727 smIntrEventTypeTaskManagement, 11728 smTMFailed, 11729 oneDeviceData->satTmTaskTag); 11730 11731 oneDeviceData->satTmTaskTag = agNULL; 11732 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11733 smsatFreeIntIoResource( smRoot, 11734 oneDeviceData, 11735 satIntIo); 11736 return; 11737 } 11738 if (agIOStatus != OSSA_IO_SUCCESS) 11739 { 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 */ 11745 #endif 11746 SM_DBG1(("smsatResetDeviceCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError)); 11747 /* TM completed */ 11748 tdsmEventCB( smRoot, 11749 smDeviceHandle, 11750 smIntrEventTypeTaskManagement, 11751 smTMFailed, 11752 oneDeviceData->satTmTaskTag); 11753 11754 oneDeviceData->satTmTaskTag = agNULL; 11755 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11756 smsatFreeIntIoResource( smRoot, 11757 oneDeviceData, 11758 satIntIo); 11759 return; 11760 } 11761 11762 /* success */ 11763 satNewIntIo = smsatAllocIntIoResource( smRoot, 11764 smOrgIORequest, 11765 oneDeviceData, 11766 0, 11767 satNewIntIo); 11768 if (satNewIntIo == agNULL) 11769 { 11770 oneDeviceData->satTmTaskTag = agNULL; 11771 11772 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11773 /* memory allocation failure */ 11774 smsatFreeIntIoResource( smRoot, 11775 oneDeviceData, 11776 satIntIo); 11777 /* TM completed */ 11778 tdsmEventCB( smRoot, 11779 smDeviceHandle, 11780 smIntrEventTypeTaskManagement, 11781 smTMFailed, 11782 oneDeviceData->satTmTaskTag); 11783 SM_DBG1(("smsatResetDeviceCB: momory allocation fails!!!\n")); 11784 return; 11785 } /* end of memory allocation failure */ 11786 /* 11787 * Need to initialize all the fields within satIOContext 11788 */ 11789 satNewIOContext = smsatPrepareNewIO( 11790 satNewIntIo, 11791 smOrgIORequest, 11792 oneDeviceData, 11793 agNULL, 11794 satOrgIOContext 11795 ); 11796 /* send AGSA_SATA_PROTOCOL_SRST_DEASSERT */ 11797 status = smsatDeResetDevice(smRoot, 11798 smOrgIORequest, 11799 satOrgIOContext->psmDeviceHandle, 11800 agNULL, 11801 satNewIOContext 11802 ); 11803 if (status != SM_RC_SUCCESS) 11804 { 11805 /* TM completed */ 11806 tdsmEventCB( smRoot, 11807 smDeviceHandle, 11808 smIntrEventTypeTaskManagement, 11809 smTMFailed, 11810 oneDeviceData->satTmTaskTag); 11811 /* sending AGSA_SATA_PROTOCOL_SRST_DEASSERT fails */ 11812 oneDeviceData->satTmTaskTag = agNULL; 11813 11814 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11815 smsatFreeIntIoResource( smRoot, 11816 oneDeviceData, 11817 satIntIo); 11818 11819 smsatFreeIntIoResource( smRoot, 11820 oneDeviceData, 11821 satNewIntIo); 11822 return; 11823 } 11824 // oneDeviceData->satTmTaskTag = agNULL; 11825 11826 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11827 11828 smsatFreeIntIoResource( smRoot, 11829 oneDeviceData, 11830 satIntIo); 11831 SM_DBG5(("smsatResetDeviceCB: device %p pending IO %d\n", oneDeviceData, oneDeviceData->satPendingIO)); 11832 SM_DBG6(("smsatResetDeviceCB: end\n")); 11833 return; 11834 } 11835 11836 osGLOBAL void 11837 smsatDeResetDeviceCB( 11838 agsaRoot_t *agRoot, 11839 agsaIORequest_t *agIORequest, 11840 bit32 agIOStatus, 11841 agsaFisHeader_t *agFirstDword, 11842 bit32 agIOInfoLen, 11843 agsaFrameHandle_t agFrameHandle, 11844 void *ioContext 11845 ) 11846 { 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; 11863 bit32 ataError; 11864 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 11865 #endif 11866 bit32 AbortTM = agFALSE; 11867 smDeviceHandle_t *smDeviceHandle; 11868 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) 11879 { 11880 SM_DBG6(("smsatDeResetDeviceCB: External, OS generated\n")); 11881 satOrgIOContext = satIOContext; 11882 } 11883 else 11884 { 11885 SM_DBG6(("smsatDeResetDeviceCB: Internal, TD generated\n")); 11886 satOrgIOContext = satIOContext->satOrgIOContext; 11887 if (satOrgIOContext == agNULL) 11888 { 11889 SM_DBG6(("smsatDeResetDeviceCB: satOrgIOContext is NULL, wrong\n")); 11890 return; 11891 } 11892 else 11893 { 11894 SM_DBG6(("smsatDeResetDeviceCB: satOrgIOContext is NOT NULL\n")); 11895 } 11896 } 11897 smIORequestBody->ioCompleted = agTRUE; 11898 smIORequestBody->ioStarted = agFALSE; 11899 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 11900 { 11901 SM_DBG1(("smsatDeResetDeviceCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 11902 /* TM completed */ 11903 tdsmEventCB( smRoot, 11904 smDeviceHandle, 11905 smIntrEventTypeTaskManagement, 11906 smTMFailed, 11907 oneDeviceData->satTmTaskTag); 11908 oneDeviceData->satTmTaskTag = agNULL; 11909 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11910 smsatFreeIntIoResource( smRoot, 11911 oneDeviceData, 11912 satIntIo); 11913 return; 11914 } 11915 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 11925 ) 11926 { 11927 SM_DBG1(("smsatDeResetDeviceCB: OSSA_IO_OPEN_CNX_ERROR!!!\n")); 11928 11929 /* TM completed */ 11930 tdsmEventCB( smRoot, 11931 smDeviceHandle, 11932 smIntrEventTypeTaskManagement, 11933 smTMFailed, 11934 oneDeviceData->satTmTaskTag); 11935 oneDeviceData->satTmTaskTag = agNULL; 11936 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11937 smsatFreeIntIoResource( smRoot, 11938 oneDeviceData, 11939 satIntIo); 11940 return; 11941 } 11942 if (agIOStatus != OSSA_IO_SUCCESS) 11943 { 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 */ 11949 #endif 11950 SM_DBG1(("smsatDeResetDeviceCB: ataStatus 0x%x ataError 0x%x!!!\n", ataStatus, ataError)); 11951 /* TM completed */ 11952 tdsmEventCB( smRoot, 11953 smDeviceHandle, 11954 smIntrEventTypeTaskManagement, 11955 smTMFailed, 11956 oneDeviceData->satTmTaskTag); 11957 oneDeviceData->satTmTaskTag = agNULL; 11958 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11959 smsatFreeIntIoResource( smRoot, 11960 oneDeviceData, 11961 satIntIo); 11962 return; 11963 } 11964 11965 /* success */ 11966 SM_DBG1(("smsatDeResetDeviceCB: success !!!\n")); 11967 SM_DBG1(("smsatDeResetDeviceCB: TMF %d!!!\n", satOrgIOContext->TMF)); 11968 11969 if (satOrgIOContext->TMF == AG_ABORT_TASK) 11970 { 11971 AbortTM = agTRUE; 11972 } 11973 if (AbortTM == agTRUE) 11974 { 11975 SM_DBG1(("smsatDeResetDeviceCB: calling satAbort!!!\n")); 11976 smsatAbort(smRoot, agRoot, satOrgIOContext->satToBeAbortedIOContext); 11977 } 11978 oneDeviceData->satTmTaskTag = agNULL; 11979 oneDeviceData->satDriveState = SAT_DEV_STATE_NORMAL; 11980 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 11981 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 ); 11985 11986 /* TM completed */ 11987 tdsmEventCB( smRoot, 11988 smDeviceHandle, 11989 smIntrEventTypeTaskManagement, 11990 smTMOK, 11991 oneDeviceData->satTmTaskTag); 11992 SM_DBG5(("smsatDeResetDeviceCB: device %p pending IO %d\n", oneDeviceData, oneDeviceData->satPendingIO)); 11993 SM_DBG6(("smsatDeResetDeviceCB: end\n")); 11994 return; 11995 } 11996 11997 osGLOBAL void 11998 smaSATAAbortCB( 11999 agsaRoot_t *agRoot, 12000 agsaIORequest_t *agIORequest, 12001 bit32 flag, 12002 bit32 status 12003 ) 12004 { 12005 smRoot_t *smRoot = gsmRoot; 12006 smIORequestBody_t *smIORequestBody = agNULL; 12007 smSatIOContext_t *satIOContext; 12008 smDeviceHandle_t *smDeviceHandle; 12009 smDeviceData_t *oneDeviceData = agNULL; 12010 12011 SM_DBG1(("smaSATAAbortCB: start\n")); 12012 12013 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 12014 if (smIORequestBody == agNULL) 12015 { 12016 SM_DBG1(("smaSATAAbortCB: smIORequestBody is NULL!!! \n")); 12017 return; 12018 } 12019 12020 satIOContext = &(smIORequestBody->transport.SATA.satIOContext); 12021 if (satIOContext == agNULL) 12022 { 12023 SM_DBG1(("smaSATAAbortCB: satIOContext is NULL!!! \n")); 12024 if (smIORequestBody->IOType.InitiatorTMIO.osMemHandle != agNULL) 12025 { 12026 tdsmFreeMemory(smRoot, 12027 smIORequestBody->IOType.InitiatorTMIO.osMemHandle, 12028 sizeof(smIORequestBody_t) 12029 ); 12030 } 12031 return; 12032 } 12033 12034 smDeviceHandle = smIORequestBody->smDevHandle; 12035 if (smDeviceHandle == agNULL) 12036 { 12037 SM_DBG1(("smaSATAAbortCB: smDeviceHandle is NULL!!!\n")); 12038 if (smIORequestBody->IOType.InitiatorTMIO.osMemHandle != agNULL) 12039 { 12040 tdsmFreeMemory(smRoot, 12041 smIORequestBody->IOType.InitiatorTMIO.osMemHandle, 12042 sizeof(smIORequestBody_t) 12043 ); 12044 } 12045 return; 12046 } 12047 12048 oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData; 12049 if (oneDeviceData == agNULL) 12050 { 12051 SM_DBG1(("smaSATAAbortCB: oneDeviceData is NULL!!!\n")); 12052 if (smIORequestBody->IOType.InitiatorTMIO.osMemHandle != agNULL) 12053 { 12054 tdsmFreeMemory(smRoot, 12055 smIORequestBody->IOType.InitiatorTMIO.osMemHandle, 12056 sizeof(smIORequestBody_t) 12057 ); 12058 } 12059 12060 return; 12061 } 12062 12063 if (flag == 2) 12064 { 12065 /* abort per port */ 12066 SM_DBG1(("smaSATAAbortCB: abort per port, not yet!!!\n")); 12067 } 12068 else if (flag == 1) 12069 { 12070 SM_DBG1(("smaSATAAbortCB: abort all!!!\n")); 12071 if (oneDeviceData->OSAbortAll == agTRUE) 12072 { 12073 oneDeviceData->OSAbortAll = agFALSE; 12074 #if 0 12075 ostiInitiatorEvent( tiRoot, 12076 agNULL, 12077 tiDeviceHandle, 12078 tiIntrEventTypeLocalAbort, 12079 tiAbortOK, 12080 agNULL); 12081 #endif 12082 #if 1 12083 tdsmEventCB( smRoot, 12084 smDeviceHandle, 12085 smIntrEventTypeLocalAbort, 12086 smTMOK, 12087 agNULL); 12088 #endif 12089 12090 } 12091 if (smIORequestBody->IOType.InitiatorTMIO.osMemHandle != agNULL) 12092 { 12093 tdsmFreeMemory(smRoot, 12094 smIORequestBody->IOType.InitiatorTMIO.osMemHandle, 12095 sizeof(smIORequestBody_t) 12096 ); 12097 } 12098 } 12099 else if (flag == 0) 12100 { 12101 SM_DBG1(("smaSATAAbortCB: abort one\n")); 12102 if (status == OSSA_IO_SUCCESS) 12103 { 12104 SM_DBG1(("smaSATAAbortCB: OSSA_IO_SUCCESS\n")); 12105 } 12106 else if (status == OSSA_IO_NOT_VALID) 12107 { 12108 SM_DBG1(("smaSATAAbortCB: OSSA_IO_NOT_VALID\n")); 12109 } 12110 else if (status == OSSA_IO_NO_DEVICE) 12111 { 12112 SM_DBG1(("smaSATAAbortCB: OSSA_IO_NO_DEVICE\n")); 12113 } 12114 else if (status == OSSA_IO_ABORT_IN_PROGRESS) 12115 { 12116 SM_DBG1(("smaSATAAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n")); 12117 } 12118 #ifdef REMOVED 12119 else if (status == OSSA_IO_ABORT_DELAYED) 12120 { 12121 SM_DBG1(("smaSATAAbortCB: OSSA_IO_ABORT_DELAYED\n")); 12122 } 12123 #endif 12124 else 12125 { 12126 SM_DBG1(("smaSATAAbortCB: unspecified status 0x%x\n", status )); 12127 } 12128 if (smIORequestBody->IOType.InitiatorTMIO.osMemHandle != agNULL) 12129 { 12130 tdsmFreeMemory(smRoot, 12131 smIORequestBody->IOType.InitiatorTMIO.osMemHandle, 12132 sizeof(smIORequestBody_t) 12133 ); 12134 } 12135 } 12136 else 12137 { 12138 SM_DBG1(("smaSATAAbortCB: wrong flag %d\n", flag)); 12139 } 12140 12141 return; 12142 } 12143 12144 osGLOBAL void 12145 smLocalPhyControlCB( 12146 agsaRoot_t *agRoot, 12147 agsaContext_t *agContext, 12148 bit32 phyId, 12149 bit32 phyOperation, 12150 bit32 status, 12151 void *parm 12152 ) 12153 { 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; 12160 12161 SM_DBG1(("smLocalPhyControlCB: start phyId 0x%x phyOperation 0x%x status 0x%x\n",phyId,phyOperation,status)); 12162 12163 if (agContext == agNULL) 12164 { 12165 SM_DBG1(("smLocalPhyControlCB: agContext is NULL!!!\n")); 12166 return; 12167 } 12168 currentTaskTag = (smIORequest_t *)agContext->osData; 12169 if (currentTaskTag == agNULL) 12170 { 12171 SM_DBG1(("smLocalPhyControlCB: currentTaskTag is NULL!!!\n")); 12172 return; 12173 } 12174 smIORequestBody = (smIORequestBody_t *)currentTaskTag->smData; 12175 if (smIORequestBody == agNULL) 12176 { 12177 SM_DBG1(("smLocalPhyControlCB: smIORequestBody is NULL!!!\n")); 12178 return; 12179 } 12180 smDeviceHandle = smIORequestBody->smDevHandle; 12181 if (smDeviceHandle == agNULL) 12182 { 12183 SM_DBG1(("smLocalPhyControlCB: smDeviceHandle is NULL!!!\n")); 12184 return; 12185 } 12186 oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData; 12187 if (oneDeviceData == agNULL) 12188 { 12189 SM_DBG1(("smLocalPhyControlCB: oneDeviceData is NULL!!!\n")); 12190 return; 12191 } 12192 switch (phyOperation) 12193 { 12194 case AGSA_PHY_LINK_RESET: /* fall through */ 12195 case AGSA_PHY_HARD_RESET: 12196 if (status == OSSA_SUCCESS) 12197 { 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; 12203 #ifdef REMOVED 12204 saSetDeviceState(agRoot, 12205 agNULL, 12206 tdsmRotateQnumber(smRoot, smDeviceHandle), 12207 agDevHandle, 12208 SA_DS_OPERATIONAL 12209 ); 12210 /* TM completed */ 12211 tdsmEventCB( smRoot, 12212 smDeviceHandle, 12213 smIntrEventTypeTaskManagement, 12214 smTMOK, 12215 currentTaskTag); 12216 #endif 12217 } 12218 else 12219 { 12220 SM_DBG1(("smLocalPhyControlCB: callback to TD layer with failure!!!\n")); 12221 /* TM completed */ 12222 tdsmEventCB( smRoot, 12223 smDeviceHandle, 12224 smIntrEventTypeTaskManagement, 12225 smTMFailed, 12226 currentTaskTag); 12227 } 12228 break; 12229 default: 12230 SM_DBG1(("ossaLocalPhyControlCB: error default case. phyOperation is %d!!!\n", phyOperation)); 12231 /* TM completed */ 12232 tdsmEventCB( smRoot, 12233 smDeviceHandle, 12234 smIntrEventTypeTaskManagement, 12235 smTMFailed, 12236 currentTaskTag); 12237 break; 12238 } 12239 return; 12240 } 12241 12242 osGLOBAL void 12243 smsatSetFeaturesAACB( 12244 agsaRoot_t *agRoot, 12245 agsaIORequest_t *agIORequest, 12246 bit32 agIOStatus, 12247 agsaFisHeader_t *agFirstDword, 12248 bit32 agIOInfoLen, 12249 void *agParam, 12250 void *ioContext 12251 ) 12252 { 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; 12268 12269 SM_DBG2(("smsatSetFeaturesAACB: start\n")); 12270 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 12271 satIOContext = (smSatIOContext_t *) ioContext; 12272 if (satIOContext == agNULL) 12273 { 12274 SM_DBG1(("smsatSetFeaturesAACB: satIOContext is NULL\n")); 12275 return; 12276 } 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) 12284 { 12285 SM_DBG5(("smsatSetFeaturesAACB: External smSatInternalIo_t satIntIoContext\n")); 12286 satOrgIOContext = satIOContext; 12287 smOrgIORequest = smIORequestBody->smIORequest; 12288 smIORequest = smOrgIORequest; 12289 } 12290 else 12291 { 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; 12296 } 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) 12302 { 12303 SM_DBG1(("smsatSetFeaturesAACB: fail, case 1 agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 12304 } 12305 if (agIOStatus != OSSA_IO_SUCCESS) 12306 { 12307 SM_DBG1(("smsatSetFeaturesAACB: fail, case 2 status %d!!!\n", agIOStatus)); 12308 } 12309 if (agIOInfoLen != 0 && agIOStatus == OSSA_IO_SUCCESS) 12310 { 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)) 12315 { 12316 SM_DBG1(("smsatSetFeaturesAACB: fail, case 3 ataStatus %d ataError %d!!!\n", ataStatus, ataError)); 12317 } 12318 if (ataError != 0) 12319 { 12320 SM_DBG1(("smsatSetFeaturesAACB: fail, case 4 ataStatus %d ataError %d!!!\n", ataStatus, ataError)); 12321 } 12322 } 12323 /* interal structure free */ 12324 smsatFreeIntIoResource(smRoot,oneDeviceData, satIntIo); 12325 if (smIORequest->tdData == smIORequest->smData) 12326 { 12327 SM_DBG1(("smsatSetFeaturesAACB: the same tdData and smData error!\n")); 12328 } 12329 /*Complete this identify device IO */ 12330 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 12331 SM_DBG2(("smsatSetFeaturesAACB: end\n")); 12332 } 12333 12334 /***************************************************************************** 12335 *! \brief smsatSetFeaturesDMACB 12336 * 12337 * This routine is a callback function called from smllSATACompleted(). 12338 * This CB routine deals with normal non-chained data I/O SATA request. 12339 * 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 12345 * length. 12346 * \param agParam: Additional info based on status. 12347 * \param ioContext: Pointer to smSatIOContext_t. 12348 * 12349 * \return: none 12350 * 12351 *****************************************************************************/ 12352 osGLOBAL void 12353 smsatSetFeaturesDMACB( 12354 agsaRoot_t *agRoot, 12355 agsaIORequest_t *agIORequest, 12356 bit32 agIOStatus, 12357 agsaFisHeader_t *agFirstDword, 12358 bit32 agIOInfoLen, 12359 void *agParam, 12360 void *ioContext 12361 ) 12362 { 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; 12379 12380 SM_DBG2(("smsatSetFeaturesDMACB: start\n")); 12381 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 12382 satIOContext = (smSatIOContext_t *) ioContext; 12383 if (satIOContext == agNULL) 12384 { 12385 SM_DBG1(("smsatSetFeaturesDMACB: satIOContext is NULL\n")); 12386 return; 12387 } 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) 12395 { 12396 SM_DBG2(("smsatSetFeaturesDMACB: External smSatInternalIo_t satIntIoContext\n")); 12397 satOrgIOContext = satIOContext; 12398 smOrgIORequest = smIORequestBody->smIORequest; 12399 scsiCmnd = satIOContext->pScsiCmnd; 12400 } 12401 else 12402 { 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; 12408 } 12409 smIORequest = smOrgIORequestBody->smIORequest; 12410 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 12411 smIORequestBody->ioCompleted = agTRUE; 12412 smIORequestBody->ioStarted = agFALSE; 12413 12414 oneDeviceData->satDMAEnabled = agTRUE; 12415 /* interal structure free */ 12416 smsatFreeIntIoResource(smRoot, 12417 oneDeviceData, 12418 satIntIo); 12419 12420 if (smIORequest->tdData == smIORequest->smData) 12421 { 12422 SM_DBG1(("smsatSetFeaturesDMACB: the same tdData and smData error!\n")); 12423 } 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 12433 ) 12434 { 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)); 12438 return; 12439 } 12440 if (oneDeviceData->satDeviceType == SATA_ATAPI_DEVICE) 12441 { 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)); 12444 return; 12445 } 12446 12447 /* enble read look-ahead feature*/ 12448 if (oneDeviceData->satReadLookAheadSupport == agTRUE) 12449 { 12450 satNewIntIo = smsatAllocIntIoResource(smRoot, 12451 smOrgIORequest, 12452 oneDeviceData, 12453 0, 12454 satNewIntIo); 12455 if (satNewIntIo == agNULL) 12456 { 12457 SM_DBG1(("smsatSetFeaturesDMACB: memory allocation fails\n")); 12458 /*Complete this identify packet device IO */ 12459 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 12460 return; 12461 } /* end memory allocation */ 12462 12463 satNewIOContext = smsatPrepareNewIO(satNewIntIo, 12464 smOrgIORequest, 12465 oneDeviceData, 12466 scsiCmnd, 12467 satOrgIOContext 12468 ); 12469 /* sends SET FEATURES command to enable Read Look-Ahead */ 12470 status = smsatSetFeaturesReadLookAhead(smRoot, 12471 &satNewIntIo->satIntSmIORequest, 12472 satNewIOContext->psmDeviceHandle, 12473 &satNewIntIo->satIntSmScsiXchg, 12474 satNewIOContext 12475 ); 12476 if (status != SM_RC_SUCCESS) 12477 { 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)); 12482 } 12483 SM_DBG2(("smsatSetFeaturesDMACB: end\n")); 12484 return; 12485 } 12486 /* enble Volatile Write Cache feature*/ 12487 if (oneDeviceData->satVolatileWriteCacheSupport == agTRUE) 12488 { 12489 satNewIntIo = smsatAllocIntIoResource(smRoot, 12490 smOrgIORequest, 12491 oneDeviceData, 12492 0, 12493 satNewIntIo); 12494 if (satNewIntIo == agNULL) 12495 { 12496 SM_DBG1(("smsatSetFeaturesDMACB: memory allocation fails\n")); 12497 /*Complete this identify packet device IO */ 12498 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 12499 return; 12500 } /* end memory allocation */ 12501 satNewIOContext = smsatPrepareNewIO(satNewIntIo, 12502 smOrgIORequest, 12503 oneDeviceData, 12504 scsiCmnd, 12505 satOrgIOContext 12506 ); 12507 /* sends SET FEATURES command to enable Volatile Write Cache */ 12508 status = smsatSetFeaturesVolatileWriteCache(smRoot, 12509 &satNewIntIo->satIntSmIORequest, 12510 satNewIOContext->psmDeviceHandle, 12511 &satNewIntIo->satIntSmScsiXchg, 12512 satNewIOContext 12513 ); 12514 if (status != SM_RC_SUCCESS) 12515 { 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)); 12520 } 12521 SM_DBG2(("smsatSetFeaturesDMACB: end\n")); 12522 return; 12523 } 12524 /* turn on DMA Setup FIS auto-activate by sending set feature FIS */ 12525 if (oneDeviceData->satNCQ == agTRUE && oneDeviceData->satDMASetupAA == agTRUE) 12526 { 12527 satNewIntIo = smsatAllocIntIoResource( smRoot, 12528 smOrgIORequest, 12529 oneDeviceData, 12530 0, 12531 satNewIntIo); 12532 12533 if (satNewIntIo == agNULL) 12534 { 12535 SM_DBG1(("smsatSetFeaturesDMACB: momory allocation fails; can't send set feature\n")); 12536 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 12537 return; 12538 } /* end memory allocation */ 12539 satNewIOContext = smsatPrepareNewIO(satNewIntIo, 12540 smOrgIORequest, 12541 oneDeviceData, 12542 agNULL, 12543 satOrgIOContext 12544 ); 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 */ 12550 satNewIOContext); 12551 if (status != SM_RC_SUCCESS) 12552 { 12553 SM_DBG1(("smsatSetFeaturesDMACB: failed to send set feature!!!\n")); 12554 smsatFreeIntIoResource( smRoot, 12555 oneDeviceData, 12556 satNewIntIo); 12557 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData)); 12558 } 12559 } 12560 else 12561 { 12562 /*Complete this identify device IO */ 12563 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 12564 } 12565 SM_DBG2(("smsatSetFeaturesDMACB: end\n")); 12566 } 12567 12568 /***************************************************************************** 12569 *! \brief smsatSetFeaturesReadLookAheadCB 12570 * 12571 * This routine is a callback function called from smllSATACompleted(). 12572 * This CB routine deals with normal non-chained data I/O SATA request. 12573 * 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 12579 * length. 12580 * \param agParam: Additional info based on status. 12581 * \param ioContext: Pointer to smSatIOContext_t. 12582 * 12583 * \return: none 12584 * 12585 *****************************************************************************/ 12586 osGLOBAL void 12587 smsatSetFeaturesReadLookAheadCB( 12588 agsaRoot_t *agRoot, 12589 agsaIORequest_t *agIORequest, 12590 bit32 agIOStatus, 12591 agsaFisHeader_t *agFirstDword, 12592 bit32 agIOInfoLen, 12593 void *agParam, 12594 void *ioContext 12595 ) 12596 { 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; 12613 12614 SM_DBG2(("smsatSetFeaturesReadLookAheadCB: start\n")); 12615 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 12616 satIOContext = (smSatIOContext_t *) ioContext; 12617 if (satIOContext == agNULL) 12618 { 12619 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: satIOContext is NULL\n")); 12620 return; 12621 } 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; 12628 12629 if (satIntIo == agNULL) 12630 { 12631 SM_DBG2(("smsatSetFeaturesReadLookAheadCB: External smSatInternalIo_t satIntIoContext\n")); 12632 satOrgIOContext = satIOContext; 12633 smOrgIORequest = smIORequestBody->smIORequest; 12634 scsiCmnd = satIOContext->pScsiCmnd; 12635 } 12636 else 12637 { 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; 12643 } 12644 smIORequest = smOrgIORequestBody->smIORequest; 12645 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 12646 12647 smIORequestBody->ioCompleted = agTRUE; 12648 smIORequestBody->ioStarted = agFALSE; 12649 12650 oneDeviceData->satLookAheadEnabled = agTRUE; 12651 12652 /* interal structure free */ 12653 smsatFreeIntIoResource(smRoot, 12654 oneDeviceData, 12655 satIntIo); 12656 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 12665 ) 12666 { 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)); 12670 return; 12671 } 12672 12673 12674 12675 /* enble Volatile Write Cache feature*/ 12676 if (oneDeviceData->satVolatileWriteCacheSupport == agTRUE) 12677 { 12678 satNewIntIo = smsatAllocIntIoResource(smRoot, 12679 smOrgIORequest, 12680 oneDeviceData, 12681 0, 12682 satNewIntIo); 12683 if (satNewIntIo == agNULL) 12684 { 12685 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: memory allocation fails\n")); 12686 /*Complete this identify packet device IO */ 12687 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 12688 return; 12689 } /* end memory allocation */ 12690 12691 satNewIOContext = smsatPrepareNewIO(satNewIntIo, 12692 smOrgIORequest, 12693 oneDeviceData, 12694 scsiCmnd, 12695 satOrgIOContext 12696 ); 12697 /* sends SET FEATURES command to enable Volatile Write Cache */ 12698 status = smsatSetFeaturesVolatileWriteCache(smRoot, 12699 &satNewIntIo->satIntSmIORequest, 12700 satNewIOContext->psmDeviceHandle, 12701 &satNewIntIo->satIntSmScsiXchg, 12702 satNewIOContext 12703 ); 12704 if (status != SM_RC_SUCCESS) 12705 { 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)); 12710 } 12711 SM_DBG2(("smsatSetFeaturesReadLookAheadCB: end\n")); 12712 12713 return; 12714 } 12715 12716 /* turn on DMA Setup FIS auto-activate by sending set feature FIS */ 12717 if (oneDeviceData->satNCQ == agTRUE && oneDeviceData->satDMASetupAA == agTRUE) 12718 { 12719 satNewIntIo = smsatAllocIntIoResource( smRoot, 12720 smOrgIORequest, 12721 oneDeviceData, 12722 0, 12723 satNewIntIo); 12724 12725 if (satNewIntIo == agNULL) 12726 { 12727 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: momory allocation fails; can't send set feature\n")); 12728 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 12729 return; 12730 } /* end memory allocation */ 12731 12732 satNewIOContext = smsatPrepareNewIO(satNewIntIo, 12733 smOrgIORequest, 12734 oneDeviceData, 12735 agNULL, 12736 satOrgIOContext 12737 ); 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 */ 12743 satNewIOContext); 12744 12745 if (status != SM_RC_SUCCESS) 12746 { 12747 SM_DBG1(("smsatSetFeaturesReadLookAheadCB: failed to send set feature!!!\n")); 12748 smsatFreeIntIoResource( smRoot, 12749 oneDeviceData, 12750 satNewIntIo); 12751 /* clean up TD layer's IORequestBody */ 12752 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData)); 12753 } 12754 } 12755 else 12756 { 12757 /*Complete this identify device IO */ 12758 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 12759 } 12760 SM_DBG2(("smsatSetFeaturesReadLookAheadCB: end\n")); 12761 } 12762 /***************************************************************************** 12763 *! \brief smsatSetFeaturesVolatileWriteCacheCB 12764 * 12765 * This routine is a callback function called from smllSATACompleted(). 12766 * This CB routine deals with normal non-chained data I/O SATA request. 12767 * 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 12773 * length. 12774 * \param agParam: Additional info based on status. 12775 * \param ioContext: Pointer to smSatIOContext_t. 12776 * 12777 * \return: none 12778 * 12779 *****************************************************************************/ 12780 osGLOBAL void 12781 smsatSetFeaturesVolatileWriteCacheCB( 12782 agsaRoot_t *agRoot, 12783 agsaIORequest_t *agIORequest, 12784 bit32 agIOStatus, 12785 agsaFisHeader_t *agFirstDword, 12786 bit32 agIOInfoLen, 12787 void *agParam, 12788 void *ioContext 12789 ) 12790 { 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; 12809 12810 SM_DBG2(("smsatSetFeaturesVolatileWriteCacheCB: start\n")); 12811 smIORequestBody = (smIORequestBody_t *)agIORequest->osData; 12812 satIOContext = (smSatIOContext_t *) ioContext; 12813 if (satIOContext == agNULL) 12814 { 12815 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: satIOContext is NULL\n")); 12816 return; 12817 } 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) 12825 { 12826 SM_DBG5(("smsatSetFeaturesVolatileWriteCacheCB: External smSatInternalIo_t satIntIoContext\n")); 12827 satOrgIOContext = satIOContext; 12828 smOrgIORequest = smIORequestBody->smIORequest; 12829 smIORequest = smOrgIORequest; 12830 } 12831 else 12832 { 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; 12837 } 12838 smIORequest = smOrgIORequestBody->smIORequest; 12839 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 12840 12841 smIORequestBody->ioCompleted = agTRUE; 12842 smIORequestBody->ioStarted = agFALSE; 12843 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 12844 { 12845 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: fail, case 1 agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 12846 } 12847 if (agIOStatus != OSSA_IO_SUCCESS) 12848 { 12849 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: fail, case 2 status %d!!!\n", agIOStatus)); 12850 } 12851 if (agIOInfoLen != 0 && agIOStatus == OSSA_IO_SUCCESS) 12852 { 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)) 12857 { 12858 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: fail, case 3 ataStatus %d ataError %d!!!\n", ataStatus, ataError)); 12859 } 12860 if (ataError != 0) 12861 { 12862 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: fail, case 4 ataStatus %d ataError %d!!!\n", ataStatus, ataError)); 12863 } 12864 } 12865 12866 oneDeviceData->satWriteCacheEnabled = agTRUE; 12867 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 12878 ) 12879 { 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)); 12883 return; 12884 } 12885 /* turn on DMA Setup FIS auto-activate by sending set feature FIS */ 12886 if (oneDeviceData->satNCQ == agTRUE && oneDeviceData->satDMASetupAA == agTRUE) 12887 { 12888 satNewIntIo = smsatAllocIntIoResource( smRoot, 12889 smOrgIORequest, 12890 oneDeviceData, 12891 0, 12892 satNewIntIo); 12893 if (satNewIntIo == agNULL) 12894 { 12895 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: momory allocation fails; can't send set feature\n")); 12896 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 12897 return; 12898 } /* end memory allocation */ 12899 satNewIOContext = smsatPrepareNewIO(satNewIntIo, 12900 smOrgIORequest, 12901 oneDeviceData, 12902 agNULL, 12903 satOrgIOContext 12904 ); 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 */ 12910 satNewIOContext); 12911 if (status != SM_RC_SUCCESS) 12912 { 12913 SM_DBG1(("smsatSetFeaturesVolatileWriteCacheCB: failed to send set feature!!!\n")); 12914 smsatFreeIntIoResource( smRoot, 12915 oneDeviceData, 12916 satNewIntIo); 12917 /* clean up TD layer's IORequestBody */ 12918 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOFailed, &(oneDeviceData->satIdentifyData)); 12919 } 12920 } 12921 else 12922 { 12923 /*Complete this identify device IO */ 12924 tdsmIDCompletedCB(smRoot, smIORequest, smDeviceHandle, smIOSuccess, &(oneDeviceData->satIdentifyData)); 12925 } 12926 SM_DBG2(("smsatSetFeaturesVolatileWriteCacheCB: end\n")); 12927 } 12928 12929 12930 osGLOBAL void 12931 smsatSMARTEnablePassCB( 12932 agsaRoot_t *agRoot, 12933 agsaIORequest_t *agIORequest, 12934 bit32 agIOStatus, 12935 agsaFisHeader_t *agFirstDword, 12936 bit32 agIOInfoLen, 12937 agsaFrameHandle_t agFrameHandle, 12938 void *ioContext 12939 ) 12940 { 12941 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; 12956 //bit32 status; 12957 smScsiRspSense_t *pSense; 12958 bit8 bSenseKey = 0; 12959 bit16 bSenseCodeInfo = 0; 12960 12961 12962 SM_DBG2(("smsatSMARTEnablePassCB: start\n")); 12963 SM_DBG4(("smsatSMARTEnablePassCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 12964 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; 12973 /*ttttttthe one */ 12974 if (satIntIo == agNULL) 12975 { 12976 SM_DBG4(("smsatSMARTEnablePassCB: External smSatInternalIo_t satIntIoContext\n")); 12977 satOrgIOContext = satIOContext; 12978 smOrgIORequest = smIORequestBody->smIORequest; 12979 scsiCmnd = satOrgIOContext->pScsiCmnd; 12980 pSense = satOrgIOContext->pSense; 12981 } 12982 else 12983 { 12984 SM_DBG4(("smsatSMARTEnablePassCB: Internal smSatInternalIo_t satIntIoContext\n")); 12985 satOrgIOContext = satIOContext->satOrgIOContext; 12986 if (satOrgIOContext == agNULL) 12987 { 12988 SM_DBG4(("smsatSMARTEnablePassCB: satOrgIOContext is NULL, wrong\n")); 12989 return; 12990 } 12991 else 12992 { 12993 SM_DBG4(("smsatSMARTEnablePassCB: satOrgIOContext is NOT NULL\n")); 12994 } 12995 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 12996 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 12997 scsiCmnd = satOrgIOContext->pScsiCmnd; 12998 pSense = satOrgIOContext->pSense; 12999 } 13000 smIORequestBody->ioCompleted = agTRUE; 13001 smIORequestBody->ioStarted = agFALSE; 13002 13003 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 13004 { 13005 SM_DBG1(("smsatSMARTEnablePassCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 13006 tdsmIOCompletedCB( 13007 smRoot, 13008 smOrgIORequest, 13009 smIOFailed, 13010 smDetailOtherError, 13011 agNULL, 13012 satOrgIOContext->interruptContext 13013 ); 13014 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13015 smsatFreeIntIoResource( smRoot, 13016 oneDeviceData, 13017 satIntIo); 13018 return; 13019 } 13020 /* 13021 checking IO status, FIS type and error status 13022 */ 13023 if (agIOStatus != OSSA_IO_SUCCESS) 13024 { 13025 SM_DBG1(("smsatSMARTEnablePassCB: not success status, status %d!!!\n", agIOStatus)); 13026 if (agIOStatus == OSSA_IO_ABORTED) 13027 { 13028 smsatProcessAbort(smRoot, 13029 smOrgIORequest, 13030 satOrgIOContext 13031 ); 13032 13033 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13034 smsatFreeIntIoResource( smRoot, 13035 oneDeviceData, 13036 satIntIo); 13037 return; 13038 } 13039 13040 smsatTranslateATAErrorsToSCSIErrors( 13041 agFirstDword->D2H.status, 13042 agFirstDword->D2H.error, 13043 &bSenseKey, 13044 &bSenseCodeInfo 13045 ); 13046 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 13047 tdsmIOCompletedCB(smRoot, 13048 smOrgIORequest, 13049 smIOSuccess, 13050 SCSI_STAT_CHECK_CONDITION, 13051 satOrgIOContext->pSmSenseData, 13052 satOrgIOContext->interruptContext ); 13053 13054 13055 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13056 13057 smsatFreeIntIoResource( smRoot, 13058 oneDeviceData, 13059 satIntIo); 13060 13061 return; 13062 } 13063 /* process success case */ 13064 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13065 smsatFreeIntIoResource( smRoot, 13066 oneDeviceData, 13067 satIntIo); 13068 13069 SM_DBG1(("smsatSMARTEnablePassCB:success status, status %d!!!\n", agIOStatus)); 13070 tdsmIOCompletedCB( 13071 smRoot, 13072 smOrgIORequest, 13073 smIOSuccess, 13074 SCSI_STAT_GOOD, 13075 agNULL, 13076 satOrgIOContext->interruptContext 13077 ); 13078 13079 13080 13081 return; 13082 } 13083 13084 osGLOBAL void 13085 smsatSMARTRStatusPassCB( 13086 agsaRoot_t *agRoot, 13087 agsaIORequest_t *agIORequest, 13088 bit32 agIOStatus, 13089 agsaFisHeader_t *agFirstDword, 13090 bit32 agIOInfoLen, 13091 void *agParam, 13092 void *ioContext 13093 ) 13094 13095 { 13096 13097 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; 13108 13109 smScsiRspSense_t *pSense; 13110 smIORequest_t *smOrgIORequest; 13111 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; 13121 13122 13123 SM_DBG2(("smsatSMARTRStatusPassCB: start\n")); 13124 SM_DBG5(("smsatSMARTRStatusPassCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 13125 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; 13135 13136 if (satIntIo == agNULL) 13137 { 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])); 13149 13150 13151 } 13152 else 13153 { 13154 SM_DBG4(("smsatSMARTRStatusPassCB: Internal smSatInternalIo_t satIntIoContext\n")); 13155 satOrgIOContext = satIOContext->satOrgIOContext; 13156 if (satOrgIOContext == agNULL) 13157 { 13158 SM_DBG4(("smsatSMARTRStatusPassCB: satOrgIOContext is NULL\n")); 13159 13160 return; 13161 13162 } 13163 else 13164 { 13165 SM_DBG4(("smsatSMARTRStatusPassCB: satOrgIOContext is NOT NULL\n")); 13166 } 13167 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 13168 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 13169 13170 smOrgScsiRequest = satOrgIOContext->smScsiXchg; 13171 /* ATA command response payload */ 13172 smScsiRequest = (smScsiInitiatorRequest_t *)&(satIntIo->satIntSmScsiXchg); 13173 scsiCmnd = satOrgIOContext->pScsiCmnd; 13174 pSense = satOrgIOContext->pSense; 13175 } 13176 13177 smIORequestBody->ioCompleted = agTRUE; 13178 smIORequestBody->ioStarted = agFALSE; 13179 13180 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 13181 { 13182 SM_DBG1(("smsatSMARTRStatusPassCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 13183 tdsmIOCompletedCB( 13184 smRoot, 13185 smOrgIORequest, 13186 smIOFailed, 13187 smDetailOtherError, 13188 agNULL, 13189 satOrgIOContext->interruptContext 13190 ); 13191 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13192 13193 smsatFreeIntIoResource( smRoot, 13194 oneDeviceData, 13195 satIntIo); 13196 return; 13197 } 13198 13199 if( agIOStatus != OSSA_IO_SUCCESS) 13200 { 13201 13202 /* non-data -> device to host fis are expected */ 13203 13204 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 13205 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 13206 13207 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 13208 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 13209 ) 13210 { 13211 /* for debugging */ 13212 if( agIOStatus != OSSA_IO_SUCCESS) 13213 { 13214 SM_DBG1(("smsatSMARTRStatusPassCB: FAILED, NOT IO_SUCCESS!!!\n")); 13215 } 13216 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 13217 { 13218 SM_DBG1(("smsatSMARTRStatusPassCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 13219 } 13220 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 13221 (ataStatus & DF_ATA_STATUS_MASK) 13222 ) 13223 { 13224 SM_DBG1(("smsatSMARTRStatusPassCB: FAILED, FAILED, error status!!!\n")); 13225 } 13226 13227 /* Process abort case */ 13228 if (agIOStatus == OSSA_IO_ABORTED) 13229 { 13230 smsatProcessAbort(smRoot, 13231 smOrgIORequest, 13232 satOrgIOContext 13233 ); 13234 13235 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13236 13237 smsatFreeIntIoResource( smRoot, 13238 oneDeviceData, 13239 satIntIo); 13240 return; 13241 } 13242 13243 smsatTranslateATAErrorsToSCSIErrors( 13244 agFirstDword->D2H.status, 13245 agFirstDword->D2H.error, 13246 &bSenseKey, 13247 &bSenseCodeInfo 13248 ); 13249 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 13250 tdsmIOCompletedCB(smRoot, 13251 smOrgIORequest, 13252 smIOSuccess, 13253 SCSI_STAT_CHECK_CONDITION, 13254 satOrgIOContext->pSmSenseData, 13255 satOrgIOContext->interruptContext ); 13256 13257 13258 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13259 13260 smsatFreeIntIoResource( smRoot, 13261 oneDeviceData, 13262 satIntIo); 13263 return; 13264 13265 } /* error checking */ 13266 } 13267 13268 /* prcessing the success case */ 13269 SM_DBG5(("smsatSMARTRStatusPassCB: SAT_SMART_RETURN_STATUS success\n")); 13270 13271 tdsmIOCompletedCB( smRoot, 13272 smOrgIORequest, 13273 smIOSuccess, 13274 SCSI_STAT_GOOD, 13275 agNULL, 13276 satOrgIOContext->interruptContext); 13277 13278 13279 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13280 13281 smsatFreeIntIoResource( smRoot, 13282 oneDeviceData, 13283 satIntIo); 13284 13285 13286 return; 13287 } 13288 13289 osGLOBAL void 13290 smsatSMARTReadLogCB( 13291 agsaRoot_t *agRoot, 13292 agsaIORequest_t *agIORequest, 13293 bit32 agIOStatus, 13294 agsaFisHeader_t *agFirstDword, 13295 bit32 agIOInfoLen, 13296 void *agParam, 13297 void *ioContext 13298 ) 13299 { 13300 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; 13311 13312 smScsiRspSense_t *pSense; 13313 smIORequest_t *smOrgIORequest; 13314 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; 13321 //bit8 *pLogPage; 13322 // bit8 SelfTestExecutionStatus = 0; 13323 // bit32 i = 0; 13324 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; 13331 13332 SM_DBG2(("smsatSMARTReadLogCB: start\n")); 13333 SM_DBG5(("smsatSMARTReadLogCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 13334 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; 13344 13345 if (satIntIo == agNULL) 13346 { 13347 SM_DBG4(("smsatSMARTReadLogCB: External smSatInternalIo_t satIntIoContext\n")); 13348 satOrgIOContext = satIOContext; 13349 smOrgIORequest = smIORequestBody->smIORequest; 13350 pSense = satOrgIOContext->pSense; 13351 smOrgScsiRequest = satOrgIOContext->smScsiXchg; 13352 13353 /* ATA command response payload */ 13354 smScsiRequest = satOrgIOContext->smScsiXchg; 13355 scsiCmnd = satOrgIOContext->pScsiCmnd; 13356 13357 13358 } 13359 else 13360 { 13361 SM_DBG4(("smsatSMARTReadLogCB: Internal smSatInternalIo_t satIntIoContext\n")); 13362 satOrgIOContext = satIOContext->satOrgIOContext; 13363 if (satOrgIOContext == agNULL) 13364 { 13365 SM_DBG4(("smsatSMARTReadLogCB: satOrgIOContext is NULL\n")); 13366 13367 return; 13368 13369 } 13370 else 13371 { 13372 SM_DBG4(("smsatSMARTReadLogCB: satOrgIOContext is NOT NULL\n")); 13373 } 13374 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 13375 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 13376 13377 pSense = satOrgIOContext->pSense; 13378 smOrgScsiRequest = satOrgIOContext->smScsiXchg; 13379 13380 /* ATA command response payload */ 13381 smScsiRequest = (smScsiInitiatorRequest_t *)&(satIntIo->satIntSmScsiXchg); 13382 scsiCmnd = satOrgIOContext->pScsiCmnd; 13383 } 13384 13385 smIORequestBody->ioCompleted = agTRUE; 13386 smIORequestBody->ioStarted = agFALSE; 13387 13388 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 13389 { 13390 SM_DBG1(("smsatSMARTReadLogCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 13391 tdsmIOCompletedCB( 13392 smRoot, 13393 smOrgIORequest, 13394 smIOFailed, 13395 smDetailOtherError, 13396 agNULL, 13397 satOrgIOContext->interruptContext 13398 ); 13399 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13400 13401 smsatFreeIntIoResource( smRoot, 13402 oneDeviceData, 13403 satIntIo); 13404 return; 13405 } 13406 13407 //for Debuggings 13408 if(agFirstDword != NULL) 13409 { 13410 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 13411 SM_DBG1(("smsatSMARTReadLogCB: statDevToHostFisHeader->status, status %d!!!\n", statDevToHostFisHeader->status)); 13412 } 13413 if ((agIOStatus != OSSA_IO_SUCCESS) && (agFirstDword != NULL)) 13414 { 13415 /* non-data and pio read -> device to host and pio setup fis are expected */ 13416 /* 13417 first, assumed to be Reg Device to Host FIS 13418 This is OK to just find fis type 13419 */ 13420 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 13421 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 13422 } 13423 13424 if( agIOStatus != OSSA_IO_SUCCESS) 13425 { 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)) 13429 ) 13430 { 13431 /* for debugging */ 13432 if( agIOStatus != OSSA_IO_SUCCESS) 13433 { 13434 SM_DBG1(("smsatSMARTReadLogCB: FAILED, NOT IO_SUCCESS!!!\n")); 13435 } 13436 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 13437 { 13438 SM_DBG1(("smsatSMARTReadLogCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 13439 } 13440 else if (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS) 13441 { 13442 SM_DBG1(("smsatSMARTReadLogCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 13443 } 13444 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 13445 (ataStatus & DF_ATA_STATUS_MASK) 13446 ) 13447 { 13448 SM_DBG1(("smsatSMARTReadLogCB: FAILED, FAILED, error status!!!\n")); 13449 } 13450 13451 /* Process abort case */ 13452 if (agIOStatus == OSSA_IO_ABORTED) 13453 { 13454 smsatProcessAbort(smRoot, 13455 smOrgIORequest, 13456 satOrgIOContext 13457 ); 13458 13459 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13460 13461 smsatFreeIntIoResource( smRoot, 13462 oneDeviceData, 13463 satIntIo); 13464 return; 13465 } 13466 13467 /* for debugging */ 13468 13469 if (hostToDevFis->h.command == SAT_SMART) 13470 { 13471 if (hostToDevFis->h.features == SAT_SMART_READ_LOG) 13472 { 13473 SM_DBG1(("smsatSMARTReadLogCB: SAT_SMART_READ_LOG failed!!!\n")); 13474 } 13475 else 13476 { 13477 SM_DBG1(("smsatSMARTReadLogCB: error unknown command 0x%x feature 0x%x!!!\n", hostToDevFis->h.command, hostToDevFis->h.features)); 13478 } 13479 } 13480 else 13481 { 13482 SM_DBG1(("smsatSMARTReadLogCB: error default case command 0x%x!!!\n", hostToDevFis->h.command)); 13483 } 13484 13485 smsatTranslateATAErrorsToSCSIErrors( 13486 agFirstDword->D2H.status, 13487 agFirstDword->D2H.error, 13488 &bSenseKey, 13489 &bSenseCodeInfo 13490 ); 13491 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 13492 tdsmIOCompletedCB(smRoot, 13493 smOrgIORequest, 13494 smIOSuccess, 13495 SCSI_STAT_CHECK_CONDITION, 13496 satOrgIOContext->pSmSenseData, 13497 satOrgIOContext->interruptContext ); 13498 13499 13500 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13501 13502 smsatFreeIntIoResource( smRoot, 13503 oneDeviceData, 13504 satIntIo); 13505 return; 13506 13507 } /* error checking */ 13508 } 13509 13510 /* prcessing the success case */ 13511 13512 13513 tdsmIOCompletedCB( smRoot, 13514 smOrgIORequest, 13515 smIOSuccess, 13516 SCSI_STAT_GOOD, 13517 agNULL, 13518 satOrgIOContext->interruptContext); 13519 13520 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13521 13522 smsatFreeIntIoResource( smRoot, 13523 oneDeviceData, 13524 satIntIo); 13525 13526 return; 13527 } 13528 13529 osGLOBAL void 13530 smsatPassthroughCB( 13531 agsaRoot_t *agRoot, 13532 agsaIORequest_t *agIORequest, 13533 bit32 agIOStatus, 13534 agsaFisHeader_t *agFirstDword, 13535 bit32 agIOInfoLen, 13536 void *agParam, 13537 void *ioContext 13538 ) 13539 { 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 */ 13555 13556 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 13557 smIniScsiCmnd_t *scsiCmnd; 13558 bit8 bSenseKey = 0; 13559 bit16 bSenseCodeInfo = 0; 13560 13561 SM_DBG2(("smsatPassthroughCB: start\n")); 13562 SM_DBG5(("smsatPassthroughCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 13563 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; 13573 13574 if (satIntIo == agNULL) 13575 { 13576 SM_DBG4(("smsatPassthroughCB: External smSatInternalIo_t satIntIoContext\n")); 13577 satOrgIOContext = satIOContext; 13578 smOrgIORequest = smIORequestBody->smIORequest; 13579 pSense = satOrgIOContext->pSense; 13580 smOrgScsiRequest = satOrgIOContext->smScsiXchg; 13581 13582 /* ATA command response payload */ 13583 smScsiRequest = satOrgIOContext->smScsiXchg; 13584 scsiCmnd = satOrgIOContext->pScsiCmnd; 13585 } 13586 else 13587 { 13588 SM_DBG4(("smsatPassthroughCB: Internal smSatInternalIo_t satIntIoContext\n")); 13589 satOrgIOContext = satIOContext->satOrgIOContext; 13590 if (satOrgIOContext == agNULL) 13591 { 13592 SM_DBG4(("smsatPassthroughCB: satOrgIOContext is NULL\n")); 13593 return; 13594 } 13595 else 13596 { 13597 SM_DBG4(("smsatPassthroughCB: satOrgIOContext is NOT NULL\n")); 13598 } 13599 smOrgIORequestBody = (smIORequestBody_t *)satOrgIOContext->smRequestBody; 13600 smOrgIORequest = (smIORequest_t *)smOrgIORequestBody->smIORequest; 13601 13602 pSense = satOrgIOContext->pSense; 13603 smOrgScsiRequest = satOrgIOContext->smScsiXchg; 13604 13605 /* ATA command response payload */ 13606 smScsiRequest = (smScsiInitiatorRequest_t *)&(satIntIo->satIntSmScsiXchg); 13607 scsiCmnd = satOrgIOContext->pScsiCmnd; 13608 } 13609 13610 smIORequestBody->ioCompleted = agTRUE; 13611 smIORequestBody->ioStarted = agFALSE; 13612 13613 13614 if (agIOStatus == OSSA_IO_UNDERFLOW) 13615 { 13616 SM_DBG1(("smsatPassthroughCB: IO_UNDERFLOW, status %d!!!\n", agIOStatus)); 13617 tdsmIOCompletedCB( smRoot, 13618 smOrgIORequest, 13619 smIOUnderRun, 13620 agIOInfoLen, 13621 agNULL, 13622 satOrgIOContext->interruptContext 13623 ); 13624 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13625 13626 smsatFreeIntIoResource( smRoot, 13627 oneDeviceData, 13628 satIntIo); 13629 return; 13630 } 13631 13632 13633 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 13634 { 13635 SM_DBG1(("smsatPassthroughCB: wrong. agFirstDword is NULL when error, status %d!!!\n", agIOStatus)); 13636 tdsmIOCompletedCB( smRoot, 13637 smOrgIORequest, 13638 smIOFailed, 13639 smDetailOtherError, 13640 agNULL, 13641 satOrgIOContext->interruptContext 13642 ); 13643 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13644 13645 smsatFreeIntIoResource( smRoot, 13646 oneDeviceData, 13647 satIntIo); 13648 return; 13649 } 13650 13651 //for Debuggings 13652 13653 if ((agIOStatus != OSSA_IO_SUCCESS) && (agFirstDword != NULL)) 13654 { 13655 /* non-data and pio read -> device to host and pio setup fis are expected */ 13656 /* 13657 first, assumed to be Reg Device to Host FIS 13658 This is OK to just find fis type 13659 */ 13660 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 13661 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 13662 } 13663 if( agIOStatus != OSSA_IO_SUCCESS) 13664 { 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)) 13668 ) 13669 { 13670 /* for debugging */ 13671 if( agIOStatus != OSSA_IO_SUCCESS) 13672 { 13673 SM_DBG1(("smsatPassthroughCB: FAILED, NOT IO_SUCCESS!!!\n")); 13674 } 13675 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 13676 { 13677 SM_DBG1(("smsatPassthroughCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 13678 } 13679 else if (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS) 13680 { 13681 SM_DBG1(("smsatPassthroughCB: FAILED, Wrong FIS type 0x%x!!!\n",statDevToHostFisHeader->fisType)); 13682 } 13683 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 13684 (ataStatus & DF_ATA_STATUS_MASK) 13685 ) 13686 { 13687 SM_DBG1(("smsatPassthroughCB: FAILED, FAILED, error status!!!\n")); 13688 } 13689 13690 /* Process abort case */ 13691 if (agIOStatus == OSSA_IO_ABORTED) 13692 { 13693 smsatProcessAbort( smRoot, 13694 smOrgIORequest, 13695 satOrgIOContext); 13696 13697 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13698 13699 smsatFreeIntIoResource( smRoot, 13700 oneDeviceData, 13701 satIntIo); 13702 return; 13703 } 13704 13705 smsatTranslateATAErrorsToSCSIErrors( agFirstDword->D2H.status, 13706 agFirstDword->D2H.error, 13707 &bSenseKey, 13708 &bSenseCodeInfo 13709 ); 13710 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 13711 tdsmIOCompletedCB( smRoot, 13712 smOrgIORequest, 13713 smIOSuccess, 13714 SCSI_STAT_CHECK_CONDITION, 13715 satOrgIOContext->pSmSenseData, 13716 satOrgIOContext->interruptContext ); 13717 13718 13719 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13720 smsatFreeIntIoResource( smRoot, 13721 oneDeviceData, 13722 satIntIo); 13723 return; 13724 13725 } /* error checking */ 13726 } 13727 13728 /* prcessing the success case */ 13729 if(agFirstDword != NULL) 13730 { 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, 13735 &bSenseKey, 13736 &bSenseCodeInfo); 13737 smsatSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 13738 if(agFirstDword->D2H.status & 0x01) 13739 { 13740 tdsmIOCompletedCB( smRoot, 13741 smOrgIORequest, 13742 smIOSuccess, 13743 SCSI_STAT_CHECK_CONDITION, 13744 satOrgIOContext->pSmSenseData, 13745 satOrgIOContext->interruptContext ); 13746 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13747 smsatFreeIntIoResource( smRoot, 13748 oneDeviceData, 13749 satIntIo); 13750 return; 13751 } 13752 } 13753 13754 tdsmIOCompletedCB( smRoot, 13755 smOrgIORequest, 13756 smIOSuccess, 13757 SCSI_STAT_GOOD, 13758 agNULL, 13759 satOrgIOContext->interruptContext); 13760 13761 smsatDecrementPendingIO(smRoot, smAllShared, satIOContext); 13762 13763 smsatFreeIntIoResource( smRoot, 13764 oneDeviceData, 13765 satIntIo); 13766 13767 return; 13768 } 13769 13770