1 /******************************************************************************* 2 *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved. 3 * 4 *Redistribution and use in source and binary forms, with or without modification, are permitted provided 5 *that the following conditions are met: 6 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the 7 *following disclaimer. 8 *2. Redistributions in binary form must reproduce the above copyright notice, 9 *this list of conditions and the following disclaimer in the documentation and/or other materials provided 10 *with the distribution. 11 * 12 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED 13 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 14 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 15 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 16 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 17 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 18 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 19 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE 20 21 ********************************************************************************/ 22 /*****************************************************************************/ 23 /** \file 24 * 25 * The file implementing SCSI/ATA Translation (SAT) for LL Layer callback 26 * 27 */ 28 /*****************************************************************************/ 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 #include <dev/pms/config.h> 32 33 #include <dev/pms/freebsd/driver/common/osenv.h> 34 #include <dev/pms/freebsd/driver/common/ostypes.h> 35 #include <dev/pms/freebsd/driver/common/osdebug.h> 36 37 #ifdef SATA_ENABLE 38 39 #include <dev/pms/RefTisa/sallsdk/api/sa.h> 40 #include <dev/pms/RefTisa/sallsdk/api/saapi.h> 41 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h> 42 43 #include <dev/pms/RefTisa/tisa/api/titypes.h> 44 #include <dev/pms/RefTisa/tisa/api/ostiapi.h> 45 #include <dev/pms/RefTisa/tisa/api/tiapi.h> 46 #include <dev/pms/RefTisa/tisa/api/tiglobal.h> 47 48 #ifdef FDS_SM 49 #include <dev/pms/RefTisa/sat/api/sm.h> 50 #include <dev/pms/RefTisa/sat/api/smapi.h> 51 #include <dev/pms/RefTisa/sat/api/tdsmapi.h> 52 #endif 53 54 #ifdef FDS_DM 55 #include <dev/pms/RefTisa/discovery/api/dm.h> 56 #include <dev/pms/RefTisa/discovery/api/dmapi.h> 57 #include <dev/pms/RefTisa/discovery/api/tddmapi.h> 58 #endif 59 60 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h> 61 #include <dev/pms/freebsd/driver/common/osstring.h> 62 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h> 63 64 #ifdef INITIATOR_DRIVER 65 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h> 66 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h> 67 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h> 68 #endif 69 70 #ifdef TARGET_DRIVER 71 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h> 72 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h> 73 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h> 74 #endif 75 76 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h> 77 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h> 78 79 #include <dev/pms/RefTisa/tisa/sassata/sata/host/sat.h> 80 #include <dev/pms/RefTisa/tisa/sassata/sata/host/satproto.h> 81 82 /***************************************************************************** 83 *! \brief ossaSATACompleted 84 * 85 * This routine is called to complete a SATA request previously issued to the 86 * LL Layer in saSATAStart() 87 * 88 * \param agRoot: Handles for this instance of SAS/SATA hardware 89 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 90 * \param agIOStatus: Status of completed I/O. 91 * \param agFirstDword:Pointer to the four bytes of FIS. 92 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 93 * length. 94 * \param agParam: Additional info based on status. 95 * 96 * \return: none 97 * 98 *****************************************************************************/ 99 GLOBAL void 100 ossaSATACompleted( 101 agsaRoot_t *agRoot, 102 agsaIORequest_t *agIORequest, 103 bit32 agIOStatus, 104 void *agFirstDword, 105 bit32 agIOInfoLen, 106 void *agParam 107 ) 108 109 { 110 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 111 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 112 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 113 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared); 114 tdIORequestBody_t *tdIORequestBody; 115 satIOContext_t *satIOContext; 116 satDeviceData_t *pSatDevData; 117 tdsaDeviceData_t *tdsaDeviceData = agNULL; 118 tdsaPortContext_t *onePortContext; 119 tiDeviceHandle_t *tiDeviceHandle = agNULL; 120 agsaDevHandle_t *agDevHandle = agNULL; 121 bit32 status; 122 tdsaDeviceData_t *oneDeviceData = agNULL; 123 124 TDSA_OUT_ENTER(tiRoot); 125 126 TI_DBG6(("ossaSATACompleted: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", 127 agIORequest, agIOStatus, agIOInfoLen)); 128 129 if (agIORequest == agNULL) 130 { 131 TI_DBG1(("ossaSATACompleted: agIORequest is NULL!!!!\n")); 132 return; 133 } 134 135 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 136 137 if (tdIORequestBody == agNULL) 138 { 139 TI_DBG1(("ossaSATACompleted: tdIORequestBody is NULL!!!!\n")); 140 return; 141 } 142 /* for debugging */ 143 if (tdIORequestBody->ioCompleted == agTRUE) 144 { 145 tiDeviceHandle = tdIORequestBody->tiDevHandle; 146 if (tiDeviceHandle == agNULL) 147 { 148 TI_DBG1(("ossaSATACompleted: tiDeviceHandle is NULL!!!!\n")); 149 return; 150 } 151 tdsaDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 152 TI_DBG1(("ossaSATACompleted: Error!!!!!! double completion\n")); 153 if (tdsaDeviceData == agNULL) 154 { 155 TI_DBG1(("ossaSATACompleted: tdsaDeviceData is NULL!!!!\n")); 156 return; 157 } 158 TI_DBG1(("ossaSATACompleted: did %d \n", tdsaDeviceData->id)); 159 return; 160 } 161 162 tdIORequestBody->ioCompleted = agTRUE; 163 satIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 164 165 if (satIOContext == agNULL) 166 { 167 TI_DBG1(("ossaSATACompleted: satIOContext is NULL!!!!\n")); 168 return; 169 } 170 171 pSatDevData = satIOContext->pSatDevData; 172 173 if (tdIORequestBody->tiDevHandle != agNULL) 174 { 175 oneDeviceData = (tdsaDeviceData_t *)tdIORequestBody->tiDevHandle->tdData; 176 } 177 178 if (pSatDevData == agNULL && oneDeviceData != agNULL) 179 { 180 TI_DBG1(("ossaSATACompleted: pSatDevData is NULL, loc 1, wrong\n")); 181 pSatDevData = &(oneDeviceData->satDevData); 182 } 183 184 if (pSatDevData == agNULL) 185 { 186 TI_DBG1(("ossaSATACompleted: pSatDevData is NULL loc 2, wrong\n")); 187 if (satIOContext->satOrgIOContext == agNULL) 188 { 189 TI_DBG1(("ossaSATACompleted: external command\n")); 190 } 191 else 192 { 193 TI_DBG1(("ossaSATACompleted: internal command\n")); 194 } 195 goto ext; 196 } 197 198 tdsaDeviceData = (tdsaDeviceData_t *)pSatDevData->satSaDeviceData; 199 if (oneDeviceData != tdsaDeviceData) 200 { 201 if (satIOContext->satOrgIOContext == agNULL) 202 { 203 TI_DBG1(("ossaSATACompleted: diff device handle; external command\n")); 204 } 205 else 206 { 207 TI_DBG1(("ossaSATACompleted: diff device handle; internal command\n")); 208 } 209 } 210 211 if (tdsaDeviceData == agNULL) 212 { 213 TI_DBG1(("ossaSATACompleted: tdsaDeviceData is NULL!!!!\n")); 214 return; 215 } 216 217 onePortContext = tdsaDeviceData->tdPortContext; 218 219 /* retries in OSSA_IO_XFER_OPEN_RETRY_TIMEOUT */ 220 if (agIOStatus == OSSA_IO_XFER_OPEN_RETRY_TIMEOUT) 221 { 222 if (tdsaDeviceData->valid == agTRUE && tdsaDeviceData->registered == agTRUE && 223 tdsaDeviceData->tdPortContext != agNULL ) 224 { 225 if (tdIORequestBody->reTries <= OPEN_RETRY_RETRIES) /* 10 */ 226 { 227 agDevHandle = tdsaDeviceData->agDevHandle; 228 status = saSATAStart( agRoot, 229 agIORequest, 230 tdsaRotateQnumber(tiRoot, tdsaDeviceData), 231 agDevHandle, 232 satIOContext->reqType, 233 &(tdIORequestBody->transport.SATA.agSATARequestBody), 234 satIOContext->sataTag, 235 ossaSATACompleted); 236 237 if (status == AGSA_RC_SUCCESS) 238 { 239 TI_DBG1(("ossaSATACompleted: retried\n")); 240 tdIORequestBody->ioStarted = agTRUE; 241 tdIORequestBody->ioCompleted = agFALSE; 242 tdIORequestBody->reTries++; 243 goto ext; 244 } 245 else 246 { 247 TI_DBG1(("ossaSATACompleted: retry failed\n")); 248 tdIORequestBody->ioStarted = agFALSE; 249 tdIORequestBody->ioCompleted = agTRUE; 250 tdIORequestBody->reTries = 0; 251 } 252 } 253 else 254 { 255 /* retries is over, do nothing */ 256 TI_DBG1(("ossaSATACompleted: retry is over and fail\n")); 257 tdIORequestBody->reTries = 0; 258 } 259 } 260 else 261 { 262 TI_DBG1(("ossaSATACompleted: incorrect device state or no portcontext\n")); 263 tdIORequestBody->reTries = 0; 264 } 265 } /* if OSSA_IO_XFER_OPEN_RETRY_TIMEOUT*/ 266 267 /* release tag value for SATA */ 268 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 269 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 270 { 271 satTagRelease(tiRoot, pSatDevData, satIOContext->sataTag); 272 } 273 274 /* send SMP_PHY_CONTROL_HARD_RESET */ 275 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY && tdsaAllShared->FCA) 276 { 277 if (pSatDevData->NumOfFCA <= 0) /* does SMP HARD RESET only upto one time */ 278 { 279 TI_DBG1(("ossaSATACompleted: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; sending HARD_RESET\n")); 280 pSatDevData->NumOfFCA++; 281 tdsaPhyControlSend(tiRoot, 282 tdsaDeviceData, 283 SMP_PHY_CONTROL_HARD_RESET, 284 agNULL, 285 tdsaRotateQnumber(tiRoot, tdsaDeviceData) 286 ); 287 } 288 else 289 { 290 /* given up after one time of SMP HARD RESET; */ 291 TI_DBG1(("ossaSATACompleted: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; NO!!! sending HARD_RESET\n")); 292 if (tdsaDeviceData->registered == agTRUE && tdsaAllShared->ResetInDiscovery == 0) 293 { 294 /* 295 1. remove this device 296 2. device removal event 297 */ 298 tdsaAbortAll(tiRoot, agRoot, tdsaDeviceData); 299 tdsaDeviceData->valid = agFALSE; 300 tdsaDeviceData->valid2 = agFALSE; 301 tdsaDeviceData->registered = agFALSE; 302 // pSatDevData->NumOfFCA = 0; 303 ostiInitiatorEvent( 304 tiRoot, 305 onePortContext->tiPortalContext, 306 agNULL, 307 tiIntrEventTypeDeviceChange, 308 tiDeviceRemoval, 309 agNULL 310 ); 311 } 312 } 313 } 314 315 if (agIOStatus == OSSA_IO_ABORTED) 316 { 317 /* 318 free abort IO request itself - agParam; done in ossaSATAEvent() 319 */ 320 } 321 /* just for debugging */ 322 if (agIOStatus == OSSA_IO_DS_NON_OPERATIONAL) 323 { 324 TI_DBG1(("ossaSATACompleted: agIOStatus is OSSA_IO_DS_NON_OPERATIONAL\n")); 325 } 326 if (agIOStatus == OSSA_IO_DS_IN_RECOVERY) 327 { 328 TI_DBG1(("ossaSATACompleted: agIOStatus is OSSA_IO_DS_IN_RECOVERY\n")); 329 } 330 331 satIOContext->satCompleteCB( agRoot, 332 agIORequest, 333 agIOStatus, 334 agFirstDword, 335 agIOInfoLen, 336 agParam, 337 satIOContext); 338 ext: 339 TDSA_OUT_LEAVE(tiRoot); 340 } 341 342 /***************************************************************************** 343 *! \brief satPacketCB 344 * 345 * This routine is a callback function called from ossaSATACompleted(). 346 * This CB routine deals with normal Packet command I/O SATA request. 347 * 348 * \param agRoot: Handles for this instance of SAS/SATA hardware 349 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 350 * \param agIOStatus: Status of completed I/O. 351 * \param agFirstDword:Pointer to the four bytes of FIS. 352 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 353 * length. 354 * \param agParam: Additional info based on status. 355 * \param ioContext: Pointer to satIOContext_t. 356 * 357 * \return: none 358 * 359 *****************************************************************************/ 360 361 void satPacketCB( 362 agsaRoot_t *agRoot, 363 agsaIORequest_t *agIORequest, 364 bit32 agIOStatus, 365 agsaFisHeader_t *agFirstDword, 366 bit32 agIOInfoLen, 367 void *agParam, 368 void *ioContext 369 ) 370 { 371 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 372 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 373 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 374 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 375 tdIORequestBody_t *tdIORequestBody; 376 tdIORequestBody_t *tdOrgIORequestBody; 377 satIOContext_t *satIOContext; 378 satIOContext_t *satOrgIOContext; 379 satIOContext_t *satNewIOContext; 380 satInternalIo_t *satIntIo; 381 satInternalIo_t *satNewIntIo = agNULL; 382 satDeviceData_t *satDevData; 383 scsiRspSense_t *pSense; 384 tiIORequest_t *tiOrgIORequest; 385 tiIniScsiCmnd_t *scsiCmnd; 386 bit32 interruptContext = osData->IntContext; 387 bit8 bSenseKey = 0; 388 bit16 bSenseCodeInfo = 0; 389 bit32 status = 0; 390 391 TI_DBG4(("satPacketCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 392 393 /* internally generate tiIOContext */ 394 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 395 satIOContext = (satIOContext_t *) ioContext; 396 satIntIo = satIOContext->satIntIoContext; 397 satDevData = satIOContext->pSatDevData; 398 399 /*ttttttthe one */ 400 if (satIntIo == agNULL) 401 { 402 TI_DBG4(("satPacketCB: External satInternalIo_t satIntIoContext\n")); 403 satOrgIOContext = satIOContext; 404 tiOrgIORequest = tdIORequestBody->tiIORequest; 405 pSense = satOrgIOContext->pSense; 406 scsiCmnd = satOrgIOContext->pScsiCmnd; 407 } 408 else 409 { 410 TI_DBG4(("satPacketCB: Internal satInternalIo_t satIntIoContext\n")); 411 satOrgIOContext = satIOContext->satOrgIOContext; 412 if (satOrgIOContext == agNULL) 413 { 414 TI_DBG4(("satPacketCB: satOrgIOContext is NULL, wrong\n")); 415 return; 416 } 417 else 418 { 419 TI_DBG4(("satPacketCB: satOrgIOContext is NOT NULL\n")); 420 } 421 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 422 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 423 pSense = satOrgIOContext->pSense; 424 scsiCmnd = satOrgIOContext->pScsiCmnd; 425 } 426 427 /* Parse CDB */ 428 switch(scsiCmnd->cdb[0]) 429 { 430 case SCSIOPC_TEST_UNIT_READY: 431 //satTestUnitReadyCB(agRoot, agIORequest, agIOStatus, agFirstDword, agIOInfoLen, agParam, ioContext); 432 //break; 433 case SCSIOPC_GET_EVENT_STATUS_NOTIFICATION: 434 //break; 435 case SCSIOPC_READ_CAPACITY_10: 436 case SCSIOPC_READ_CAPACITY_16: 437 //satPacketReadCapacityCB(agRoot, agIORequest, agIOStatus, agFirstDword, agIOInfoLen, agParam, ioContext); 438 //break; 439 default: 440 break; 441 } 442 443 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 444 445 tdIORequestBody->ioCompleted = agTRUE; 446 tdIORequestBody->ioStarted = agFALSE; 447 448 /* interal structure free */ 449 satFreeIntIoResource( tiRoot, satDevData, satIntIo); 450 451 if( agIOStatus == OSSA_IO_SUCCESS && agFirstDword == agNULL) 452 { 453 TI_DBG1(("satPacketCB: agIOStatus == OSSA_IO_SUCCESS, agFirstDword == agNULL \n")); 454 ostiInitiatorIOCompleted( tiRoot, 455 tdIORequestBody->tiIORequest, 456 tiIOSuccess, 457 SCSI_STAT_GOOD, 458 agNULL, 459 interruptContext); 460 } 461 else if (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL) 462 { 463 TI_DBG1(("satPacketCB: wrong. agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL \n")); 464 satNewIntIo = satAllocIntIoResource( tiRoot, 465 tiOrgIORequest, 466 satDevData, 467 32, 468 satNewIntIo); 469 if (satNewIntIo == agNULL) 470 { 471 /* memory allocation failure */ 472 /* just translate the ATAPI error register to sense information */ 473 satTranslateATAPIErrorsToSCSIErrors( 474 scsiCmnd->cdb[0], 475 agFirstDword->D2H.status, 476 agFirstDword->D2H.error, 477 &bSenseKey, 478 &bSenseCodeInfo 479 ); 480 satSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 481 ostiInitiatorIOCompleted( tiRoot, 482 tdIORequestBody->tiIORequest, 483 tiIOSuccess, 484 SCSI_STAT_CHECK_CONDITION, 485 satOrgIOContext->pTiSenseData, 486 interruptContext); 487 TI_DBG1(("satPacketCB: momory allocation fails\n")); 488 return; 489 } /* end memory allocation */ 490 491 satNewIOContext = satPrepareNewIO(satNewIntIo, 492 tiOrgIORequest, 493 satDevData, 494 scsiCmnd, 495 satOrgIOContext 496 ); 497 /* sends request sense to ATAPI device for acquiring sense information */ 498 status = satRequestSenseForATAPI(tiRoot, 499 &satNewIntIo->satIntTiIORequest, 500 satNewIOContext->ptiDeviceHandle, 501 &satNewIntIo->satIntTiScsiXchg, 502 satNewIOContext 503 ); 504 if (status != tiSuccess) 505 { 506 satFreeIntIoResource( tiRoot, 507 satDevData, 508 satNewIntIo); 509 /* just translate the ATAPI error register to sense information */ 510 satTranslateATAPIErrorsToSCSIErrors( 511 scsiCmnd->cdb[0], 512 agFirstDword->D2H.status, 513 agFirstDword->D2H.error, 514 &bSenseKey, 515 &bSenseCodeInfo 516 ); 517 satSetSensePayload(pSense, bSenseKey, 0, bSenseCodeInfo, satOrgIOContext); 518 ostiInitiatorIOCompleted( tiRoot, 519 tdIORequestBody->tiIORequest, 520 tiIOSuccess, 521 SCSI_STAT_CHECK_CONDITION, 522 satOrgIOContext->pTiSenseData, 523 interruptContext); 524 TI_DBG1(("satPacketCB: failed to call satRequestSenseForATAPI()\n")); 525 } 526 } 527 else if (agIOStatus != OSSA_IO_SUCCESS) 528 { 529 TI_DBG1(("satPacketCB: wrong. agIOStatus != OSSA_IO_SUCCESS, status %d\n", agIOStatus)); 530 itdsatProcessAbnormalCompletion( 531 agRoot, 532 agIORequest, 533 agIOStatus, 534 agFirstDword, 535 agIOInfoLen, 536 agParam, 537 satIOContext); 538 } 539 else 540 { 541 TI_DBG1(("satPacketCB: Unknown error \n")); 542 ostiInitiatorIOCompleted( tiRoot, 543 tdIORequestBody->tiIORequest, 544 tiIOFailed, 545 tiDetailOtherError, 546 agNULL, 547 interruptContext); 548 } 549 } 550 /***************************************************************************** 551 *! \brief satRequestSenseForATAPICB 552 * 553 * This routine is a callback function called from ossaSATACompleted(). 554 * This CB routine deals with normal non-chained data I/O SATA request. 555 * 556 * \param agRoot: Handles for this instance of SAS/SATA hardware 557 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 558 * \param agIOStatus: Status of completed I/O. 559 * \param agFirstDword:Pointer to the four bytes of FIS. 560 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 561 * length. 562 * \param agParam: Additional info based on status. 563 * \param ioContext: Pointer to satIOContext_t. 564 * 565 * \return: none 566 * 567 *****************************************************************************/ 568 void satRequestSenseForATAPICB( 569 agsaRoot_t *agRoot, 570 agsaIORequest_t *agIORequest, 571 bit32 agIOStatus, 572 agsaFisHeader_t *agFirstDword, 573 bit32 agIOInfoLen, 574 void *agParam, 575 void *ioContext 576 ) 577 { 578 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 579 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 580 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 581 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 582 tdIORequestBody_t *tdIORequestBody; 583 tdIORequestBody_t *tdOrgIORequestBody; 584 satIOContext_t *satIOContext; 585 satIOContext_t *satOrgIOContext; 586 satInternalIo_t *satIntIo; 587 satDeviceData_t *satDevData; 588 tiIORequest_t *tiOrgIORequest; 589 bit32 interruptContext = osData->IntContext; 590 591 TI_DBG4(("satPacketCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 592 593 /* internally generate tiIOContext */ 594 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 595 satIOContext = (satIOContext_t *) ioContext; 596 satIntIo = satIOContext->satIntIoContext; 597 satDevData = satIOContext->pSatDevData; 598 599 /*ttttttthe one */ 600 if (satIntIo == agNULL) 601 { 602 TI_DBG4(("satPacketCB: External satInternalIo_t satIntIoContext\n")); 603 satOrgIOContext = satIOContext; 604 tiOrgIORequest = tdIORequestBody->tiIORequest; 605 } 606 else 607 { 608 TI_DBG4(("satPacketCB: Internal satInternalIo_t satIntIoContext\n")); 609 satOrgIOContext = satIOContext->satOrgIOContext; 610 if (satOrgIOContext == agNULL) 611 { 612 TI_DBG4(("satPacketCB: satOrgIOContext is NULL, wrong\n")); 613 return; 614 } 615 else 616 { 617 TI_DBG4(("satPacketCB: satOrgIOContext is NOT NULL\n")); 618 } 619 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 620 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 621 } 622 623 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 624 625 tdIORequestBody->ioCompleted = agTRUE; 626 tdIORequestBody->ioStarted = agFALSE; 627 628 /* copy the request sense buffer to original IO buffer*/ 629 if (satIntIo != agNULL) 630 { 631 osti_memcpy(satOrgIOContext->pTiSenseData->senseData, satIntIo->satIntDmaMem.virtPtr, SENSE_DATA_LENGTH); 632 satOrgIOContext->pTiSenseData->senseLen = SENSE_DATA_LENGTH; 633 /* interal structure free */ 634 satFreeIntIoResource( tiRoot, satDevData, satIntIo); 635 } 636 637 /* notify the OS to complete this SRB */ 638 ostiInitiatorIOCompleted( tiRoot, 639 tiOrgIORequest, 640 tiIOSuccess, 641 SCSI_STAT_CHECK_CONDITION, 642 satOrgIOContext->pTiSenseData, 643 interruptContext); 644 } 645 /***************************************************************************** 646 *! \brief satSetFeaturesPIOCB 647 * 648 * This routine is a callback function called from ossaSATACompleted(). 649 * This CB routine deals with normal non-chained data I/O SATA request. 650 * 651 * \param agRoot: Handles for this instance of SAS/SATA hardware 652 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 653 * \param agIOStatus: Status of completed I/O. 654 * \param agFirstDword:Pointer to the four bytes of FIS. 655 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 656 * length. 657 * \param agParam: Additional info based on status. 658 * \param ioContext: Pointer to satIOContext_t. 659 * 660 * \return: none 661 * 662 *****************************************************************************/ 663 void satSetFeaturesPIOCB( 664 agsaRoot_t *agRoot, 665 agsaIORequest_t *agIORequest, 666 bit32 agIOStatus, 667 agsaFisHeader_t *agFirstDword, 668 bit32 agIOInfoLen, 669 void *agParam, 670 void *ioContext 671 ) 672 { 673 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 674 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 675 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 676 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 677 tdIORequestBody_t *tdIORequestBody; 678 tdIORequestBody_t *tdOrgIORequestBody; 679 satIOContext_t *satIOContext; 680 satIOContext_t *satOrgIOContext; 681 satIOContext_t *satNewIOContext; 682 satInternalIo_t *satIntIo; 683 satInternalIo_t *satNewIntIo = agNULL; 684 satDeviceData_t *satDevData; 685 tiIORequest_t *tiOrgIORequest; 686 tiIniScsiCmnd_t *scsiCmnd; 687 bit32 status; 688 689 TI_DBG3(("satSetFeaturesPIOCB start\n")); 690 691 /* internally generate tiIOContext */ 692 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 693 satIOContext = (satIOContext_t *) ioContext; 694 satIntIo = satIOContext->satIntIoContext; 695 satDevData = satIOContext->pSatDevData; 696 697 /*ttttttthe one */ 698 if (satIntIo == agNULL) 699 { 700 TI_DBG4(("satSetFeaturesPIOCB: External satInternalIo_t satIntIoContext\n")); 701 satOrgIOContext = satIOContext; 702 tiOrgIORequest = tdIORequestBody->tiIORequest; 703 scsiCmnd = satOrgIOContext->pScsiCmnd; 704 } 705 else 706 { 707 TI_DBG4(("satSetFeaturesPIOCB: Internal satInternalIo_t satIntIoContext\n")); 708 satOrgIOContext = satIOContext->satOrgIOContext; 709 if (satOrgIOContext == agNULL) 710 { 711 TI_DBG4(("satSetFeaturesPIOCB: satOrgIOContext is NULL, wrong\n")); 712 return; 713 } 714 else 715 { 716 TI_DBG4(("satSetFeaturesPIOCB: satOrgIOContext is NOT NULL\n")); 717 } 718 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 719 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 720 scsiCmnd = satOrgIOContext->pScsiCmnd; 721 } 722 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 723 724 tdIORequestBody->ioCompleted = agTRUE; 725 tdIORequestBody->ioStarted = agFALSE; 726 727 /* interal structure free */ 728 satFreeIntIoResource(tiRoot, 729 satDevData, 730 satIntIo); 731 732 /*if the ATAPI device support DMA, then enble this feature*/ 733 if (satDevData->satDMASupport && satDevData->satDMAEnabled) 734 { 735 satNewIntIo = satAllocIntIoResource( tiRoot, 736 tiOrgIORequest, 737 satDevData, 738 0, 739 satNewIntIo); 740 if (satNewIntIo == agNULL) 741 { 742 TI_DBG1(("satSetFeaturesPIOCB: momory allocation fails\n")); 743 return; 744 } /* end memory allocation */ 745 746 satNewIOContext = satPrepareNewIO(satNewIntIo, 747 tiOrgIORequest, 748 satDevData, 749 scsiCmnd, 750 satOrgIOContext 751 ); 752 /* sends either ATA SET FEATURES based on DMA bit */ 753 status = satSetFeatures(tiRoot, 754 &satNewIntIo->satIntTiIORequest, 755 satNewIOContext->ptiDeviceHandle, 756 &satNewIntIo->satIntTiScsiXchg, 757 satNewIOContext, 758 agTRUE 759 ); 760 if (status != tiSuccess) 761 { 762 satFreeIntIoResource( tiRoot, satDevData, satNewIntIo); 763 TI_DBG1(("satSetFeaturesPIOCB: failed to call satSetFeatures()\n")); 764 } 765 } 766 } 767 768 /***************************************************************************** 769 *! \brief satSetFeaturesCB 770 * 771 * This routine is a callback function called from ossaSATACompleted(). 772 * This CB routine deals with normal non-chained data I/O SATA request. 773 * 774 * \param agRoot: Handles for this instance of SAS/SATA hardware 775 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 776 * \param agIOStatus: Status of completed I/O. 777 * \param agFirstDword:Pointer to the four bytes of FIS. 778 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 779 * length. 780 * \param agParam: Additional info based on status. 781 * \param ioContext: Pointer to satIOContext_t. 782 * 783 * \return: none 784 * 785 *****************************************************************************/ 786 void satSetFeaturesCB( 787 agsaRoot_t *agRoot, 788 agsaIORequest_t *agIORequest, 789 bit32 agIOStatus, 790 agsaFisHeader_t *agFirstDword, 791 bit32 agIOInfoLen, 792 void *agParam, 793 void *ioContext 794 ) 795 { 796 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 797 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 798 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 799 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 800 tdIORequestBody_t *tdIORequestBody; 801 tdIORequestBody_t *tdOrgIORequestBody = agNULL; 802 satIOContext_t *satIOContext; 803 satIOContext_t *satOrgIOContext; 804 satInternalIo_t *satIntIo; 805 satDeviceData_t *satDevData; 806 tdsaPortContext_t *onePortContext = agNULL; 807 tiPortalContext_t *tiPortalContext = agNULL; 808 tdsaDeviceData_t *oneDeviceData = agNULL; 809 bit8 PhyID =0; 810 TI_DBG3(("satSetFeaturesCB start\n")); 811 812 /* internally generate tiIOContext */ 813 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 814 satIOContext = (satIOContext_t *) ioContext; 815 satIntIo = satIOContext->satIntIoContext; 816 satDevData = satIOContext->pSatDevData; 817 oneDeviceData = (tdsaDeviceData_t *)tdIORequestBody->tiDevHandle->tdData; 818 onePortContext = oneDeviceData->tdPortContext; 819 if (onePortContext == agNULL) 820 { 821 TI_DBG4(("satSetFeaturesCB: onePortContext is NULL, wrong\n")); 822 return; 823 } 824 tiPortalContext = onePortContext->tiPortalContext; 825 PhyID = oneDeviceData->phyID; 826 /*ttttttthe one */ 827 if (satIntIo == agNULL) 828 { 829 TI_DBG4(("satSetFeaturesCB: External satInternalIo_t satIntIoContext\n")); 830 satOrgIOContext = satIOContext; 831 } 832 else 833 { 834 TI_DBG4(("satSetFeaturesCB: Internal satInternalIo_t satIntIoContext\n")); 835 satOrgIOContext = satIOContext->satOrgIOContext; 836 if (satOrgIOContext == agNULL) 837 { 838 TI_DBG4(("satSetFeaturesCB: satOrgIOContext is NULL, wrong\n")); 839 return; 840 } 841 else 842 { 843 TI_DBG4(("satSetFeaturesCB: satOrgIOContext is NOT NULL\n")); 844 } 845 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 846 } 847 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 848 849 tdIORequestBody->ioCompleted = agTRUE; 850 tdIORequestBody->ioStarted = agFALSE; 851 852 /* interal structure free */ 853 satFreeIntIoResource(tiRoot, 854 satDevData, 855 satIntIo); 856 857 858 /* clean up TD layer's IORequestBody */ 859 if (tdOrgIORequestBody!= agNULL) 860 { 861 ostiFreeMemory(tiRoot, 862 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 863 sizeof(tdIORequestBody_t) 864 ); 865 } 866 867 if (onePortContext != agNULL) 868 { 869 /* this condition is for tdsaDiscoveryStartIDDevCB routine*/ 870 if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED) 871 { 872 TI_DBG1(("satSetFeaturesCB: ID completed after discovery is done; tiDeviceArrival\n")); 873 /* in case registration is finished after discovery is finished */ 874 ostiInitiatorEvent( 875 tiRoot, 876 tiPortalContext, 877 agNULL, 878 tiIntrEventTypeDeviceChange, 879 tiDeviceArrival, 880 agNULL 881 ); 882 return; 883 } 884 TI_DBG2(("satSetFeaturesCB: pid %d\n", tdsaAllShared->Ports[PhyID].portContext->id)); 885 /* the below codes is for satAddSATAIDDevCB routine*/ 886 /* notifying link up */ 887 ostiPortEvent ( 888 tiRoot, 889 tiPortLinkUp, 890 tiSuccess, 891 (void *)tdsaAllShared->Ports[PhyID].tiPortalContext 892 ); 893 #ifdef INITIATOR_DRIVER 894 /* triggers discovery */ 895 ostiPortEvent( 896 tiRoot, 897 tiPortDiscoveryReady, 898 tiSuccess, 899 (void *) tdsaAllShared->Ports[PhyID].tiPortalContext 900 ); 901 #endif 902 } 903 else 904 { 905 TI_DBG1(("satSetFeaturesCB: onePortContext is NULL, wrong\n")); 906 } 907 } 908 /***************************************************************************** 909 *! \brief satDeviceResetCB 910 * 911 * This routine is a callback function called from ossaSATACompleted(). 912 * This CB routine deals with normal non-chained data I/O SATA request. 913 * 914 * \param agRoot: Handles for this instance of SAS/SATA hardware 915 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 916 * \param agIOStatus: Status of completed I/O. 917 * \param agFirstDword:Pointer to the four bytes of FIS. 918 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 919 * length. 920 * \param agParam: Additional info based on status. 921 * \param ioContext: Pointer to satIOContext_t. 922 * 923 * \return: none 924 * 925 *****************************************************************************/ 926 void satDeviceResetCB( 927 agsaRoot_t *agRoot, 928 agsaIORequest_t *agIORequest, 929 bit32 agIOStatus, 930 agsaFisHeader_t *agFirstDword, 931 bit32 agIOInfoLen, 932 void *agParam, 933 void *ioContext 934 ) 935 { 936 /* callback for satResetDevice */ 937 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 938 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 939 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 940 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 941 tdIORequestBody_t *tdIORequestBody; 942 tdIORequestBody_t *tdOrgIORequestBody = agNULL; 943 satIOContext_t *satIOContext; 944 satIOContext_t *satOrgIOContext; 945 // satIOContext_t *satNewIOContext; 946 satInternalIo_t *satIntIo; 947 // satInternalIo_t *satNewIntIo = agNULL; 948 satDeviceData_t *satDevData; 949 tiIORequest_t *tiOrgIORequest; 950 #ifdef TD_DEBUG_ENABLE 951 bit32 ataStatus = 0; 952 bit32 ataError; 953 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 954 #endif 955 // bit32 status; 956 bit32 report = agFALSE; 957 bit32 AbortTM = agFALSE; 958 959 TI_DBG1(("satDeviceResetCB: start\n")); 960 961 TI_DBG6(("satDeviceResetCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 962 963 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 964 satIOContext = (satIOContext_t *) ioContext; 965 satIntIo = satIOContext->satIntIoContext; 966 satDevData = satIOContext->pSatDevData; 967 968 if (satIntIo == agNULL) 969 { 970 TI_DBG6(("satDeviceResetCB: External, OS generated\n")); 971 satOrgIOContext = satIOContext; 972 tiOrgIORequest = tdIORequestBody->tiIORequest; 973 } 974 else 975 { 976 TI_DBG6(("satDeviceResetCB: Internal, TD generated\n")); 977 satOrgIOContext = satIOContext->satOrgIOContext; 978 if (satOrgIOContext == agNULL) 979 { 980 TI_DBG6(("satDeviceResetCB: satOrgIOContext is NULL, wrong\n")); 981 return; 982 } 983 else 984 { 985 TI_DBG6(("satDeviceResetCB: satOrgIOContext is NOT NULL\n")); 986 } 987 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 988 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 989 } 990 991 tdIORequestBody->ioCompleted = agTRUE; 992 tdIORequestBody->ioStarted = agFALSE; 993 994 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 995 { 996 TI_DBG1(("satDeviceResetCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 997 998 if (satOrgIOContext->NotifyOS == agTRUE) 999 { 1000 ostiInitiatorEvent( tiRoot, 1001 NULL, 1002 NULL, 1003 tiIntrEventTypeTaskManagement, 1004 tiTMFailed, 1005 tiOrgIORequest ); 1006 } 1007 1008 satDevData->satTmTaskTag = agNULL; 1009 1010 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1011 1012 satFreeIntIoResource( tiRoot, 1013 satDevData, 1014 satIntIo); 1015 return; 1016 } 1017 1018 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED || 1019 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION || 1020 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK || 1021 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS || 1022 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION || 1023 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED || 1024 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION || 1025 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR || 1026 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY 1027 ) 1028 { 1029 TI_DBG1(("satDeviceResetCB: OSSA_IO_OPEN_CNX_ERROR\n")); 1030 1031 if (satOrgIOContext->NotifyOS == agTRUE) 1032 { 1033 ostiInitiatorEvent( tiRoot, 1034 NULL, 1035 NULL, 1036 tiIntrEventTypeTaskManagement, 1037 tiTMFailed, 1038 tiOrgIORequest ); 1039 } 1040 1041 satDevData->satTmTaskTag = agNULL; 1042 1043 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1044 1045 satFreeIntIoResource( tiRoot, 1046 satDevData, 1047 satIntIo); 1048 return; 1049 } 1050 1051 if (agIOStatus != OSSA_IO_SUCCESS) 1052 { 1053 /* only agsaFisPioSetup_t is expected */ 1054 #ifdef TD_DEBUG_ENABLE 1055 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup); 1056 ataStatus = satPIOSetupHeader->status; /* ATA Status register */ 1057 ataError = satPIOSetupHeader->error; /* ATA Eror register */ 1058 #endif 1059 TI_DBG1(("satDeviceResetCB: ataStatus 0x%x ataError 0x%x\n", ataStatus, ataError)); 1060 1061 if (satOrgIOContext->NotifyOS == agTRUE) 1062 { 1063 ostiInitiatorEvent( tiRoot, 1064 NULL, 1065 NULL, 1066 tiIntrEventTypeTaskManagement, 1067 tiTMFailed, 1068 tiOrgIORequest ); 1069 } 1070 1071 satDevData->satTmTaskTag = agNULL; 1072 1073 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1074 1075 satFreeIntIoResource( tiRoot, 1076 satDevData, 1077 satIntIo); 1078 return; 1079 } 1080 1081 /* success */ 1082 if (satOrgIOContext->TMF == AG_ABORT_TASK) 1083 { 1084 AbortTM = agTRUE; 1085 } 1086 1087 if (satOrgIOContext->NotifyOS == agTRUE) 1088 { 1089 report = agTRUE; 1090 } 1091 1092 if (AbortTM == agTRUE) 1093 { 1094 TI_DBG1(("satDeResetDeviceCB: calling satAbort\n")); 1095 satAbort(agRoot, satOrgIOContext->satToBeAbortedIOContext); 1096 } 1097 satDevData->satTmTaskTag = agNULL; 1098 1099 satDevData->satDriveState = SAT_DEV_STATE_NORMAL; 1100 1101 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1102 1103 TI_DBG1(("satDeviceResetCB: satPendingIO %d satNCQMaxIO %d\n", satDevData->satPendingIO, satDevData->satNCQMaxIO )); 1104 TI_DBG1(("satDeviceResetCB: satPendingNCQIO %d satPendingNONNCQIO %d\n", satDevData->satPendingNCQIO, satDevData->satPendingNONNCQIO)); 1105 1106 satFreeIntIoResource( tiRoot, 1107 satDevData, 1108 satIntIo); 1109 1110 /* clean up TD layer's IORequestBody */ 1111 if (tdOrgIORequestBody != agNULL) 1112 { 1113 ostiFreeMemory( 1114 tiRoot, 1115 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 1116 sizeof(tdIORequestBody_t) 1117 ); 1118 } 1119 else 1120 { 1121 TI_DBG1(("satDeviceResetCB: tdOrgIORequestBody is NULL, wrong\n")); 1122 } 1123 1124 1125 if (report) 1126 { 1127 ostiInitiatorEvent( tiRoot, 1128 NULL, 1129 NULL, 1130 tiIntrEventTypeTaskManagement, 1131 tiTMOK, 1132 tiOrgIORequest ); 1133 } 1134 1135 1136 TI_DBG5(("satDeviceResetCB: device %p pending IO %d\n", satDevData, satDevData->satPendingIO)); 1137 TI_DBG6(("satDeviceResetCB: end\n")); 1138 return; 1139 } 1140 1141 /***************************************************************************** 1142 *! \brief satExecuteDeviceDiagnosticCB 1143 * 1144 * This routine is a callback function called from ossaSATACompleted(). 1145 * This CB routine deals with normal non-chained data I/O SATA request. 1146 * 1147 * \param agRoot: Handles for this instance of SAS/SATA hardware 1148 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 1149 * \param agIOStatus: Status of completed I/O. 1150 * \param agFirstDword:Pointer to the four bytes of FIS. 1151 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 1152 * length. 1153 * \param agParam: Additional info based on status. 1154 * \param ioContext: Pointer to satIOContext_t. 1155 * 1156 * \return: none 1157 * 1158 *****************************************************************************/ 1159 void satExecuteDeviceDiagnosticCB( 1160 agsaRoot_t *agRoot, 1161 agsaIORequest_t *agIORequest, 1162 bit32 agIOStatus, 1163 agsaFisHeader_t *agFirstDword, 1164 bit32 agIOInfoLen, 1165 void *agParam, 1166 void *ioContext 1167 ) 1168 { 1169 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 1170 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 1171 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1172 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1173 tdIORequestBody_t *tdIORequestBody; 1174 satIOContext_t *satIOContext; 1175 satIOContext_t *satOrgIOContext; 1176 satInternalIo_t *satIntIo; 1177 satDeviceData_t *satDevData; 1178 1179 TI_DBG3(("satExecuteDeviceDiagnosticCB start\n")); 1180 1181 /* internally generate tiIOContext */ 1182 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 1183 satIOContext = (satIOContext_t *) ioContext; 1184 satIntIo = satIOContext->satIntIoContext; 1185 satDevData = satIOContext->pSatDevData; 1186 1187 /*ttttttthe one */ 1188 if (satIntIo == agNULL) 1189 { 1190 TI_DBG4(("satExecuteDeviceDiagnosticCB: External satInternalIo_t satIntIoContext\n")); 1191 satOrgIOContext = satIOContext; 1192 } 1193 else 1194 { 1195 TI_DBG4(("satExecuteDeviceDiagnosticCB: Internal satInternalIo_t satIntIoContext\n")); 1196 satOrgIOContext = satIOContext->satOrgIOContext; 1197 if (satOrgIOContext == agNULL) 1198 { 1199 TI_DBG4(("satExecuteDeviceDiagnosticCB: satOrgIOContext is NULL, wrong\n")); 1200 return; 1201 } 1202 else 1203 { 1204 TI_DBG4(("satExecuteDeviceDiagnosticCB: satOrgIOContext is NOT NULL\n")); 1205 } 1206 } 1207 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1208 1209 tdIORequestBody->ioCompleted = agTRUE; 1210 tdIORequestBody->ioStarted = agFALSE; 1211 1212 /* interal structure free */ 1213 satFreeIntIoResource(tiRoot, 1214 satDevData, 1215 satIntIo); 1216 } 1217 /***************************************************************************** 1218 *! \brief satNonChainedDataIOCB 1219 * 1220 * This routine is a callback function called from ossaSATACompleted(). 1221 * This CB routine deals with normal non-chained data I/O SATA request. 1222 * 1223 * \param agRoot: Handles for this instance of SAS/SATA hardware 1224 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 1225 * \param agIOStatus: Status of completed I/O. 1226 * \param agFirstDword:Pointer to the four bytes of FIS. 1227 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 1228 * length. 1229 * \param agParam: Additional info based on status. 1230 * \param ioContext: Pointer to satIOContext_t. 1231 * 1232 * \return: none 1233 * 1234 *****************************************************************************/ 1235 1236 void satNonChainedDataIOCB( 1237 agsaRoot_t *agRoot, 1238 agsaIORequest_t *agIORequest, 1239 bit32 agIOStatus, 1240 agsaFisHeader_t *agFirstDword, 1241 bit32 agIOInfoLen, 1242 void *agParam, 1243 void *ioContext 1244 ) 1245 { 1246 1247 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 1248 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 1249 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1250 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1251 tdIORequestBody_t *tdIORequestBody; 1252 bit32 interruptContext = osData->IntContext; 1253 satIOContext_t *satIOContext; 1254 satInternalIo_t *SatIntIo; 1255 satDeviceData_t *SatDevData; 1256 1257 TI_DBG6(("satNonChainedDataIOCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", 1258 agIORequest, agIOStatus, agIOInfoLen)); 1259 1260 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 1261 satIOContext = (satIOContext_t *) ioContext; 1262 SatIntIo = satIOContext->satIntIoContext; 1263 SatDevData = satIOContext->pSatDevData; 1264 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1265 tdIORequestBody->ioCompleted = agTRUE; 1266 tdIORequestBody->ioStarted = agFALSE; 1267 1268 /* interal structure free */ 1269 satFreeIntIoResource( tiRoot, 1270 SatDevData, 1271 SatIntIo); 1272 1273 /* Process completion */ 1274 if( (agIOStatus == OSSA_IO_SUCCESS) && (agIOInfoLen == 0)) 1275 { 1276 TI_DBG5(("satNonChainedDataIOCB: success\n")); 1277 TI_DBG5(("satNonChainedDataIOCB: success agIORequest %p\n", agIORequest)); 1278 /* 1279 * Command was completed OK, this is the normal path. 1280 * Now call the OS-App Specific layer about this completion. 1281 */ 1282 ostiInitiatorIOCompleted( tiRoot, 1283 tdIORequestBody->tiIORequest, 1284 tiIOSuccess, 1285 SCSI_STAT_GOOD, 1286 agNULL, 1287 interruptContext); 1288 } 1289 else 1290 { 1291 TI_DBG1(("satNonChainedDataIOCB: calling itdsatProcessAbnormalCompletion\n")); 1292 /* More checking needed */ 1293 itdsatProcessAbnormalCompletion( agRoot, 1294 agIORequest, 1295 agIOStatus, 1296 agFirstDword, 1297 agIOInfoLen, 1298 agParam, 1299 satIOContext); 1300 } 1301 1302 return; 1303 1304 1305 } 1306 /***************************************************************************** 1307 *! \brief satChainedDataIOCB 1308 * 1309 * This routine is a callback function called from ossaSATACompleted(). 1310 * This CB routine deals with normal chained data I/O SATA request. 1311 * 1312 * \param agRoot: Handles for this instance of SAS/SATA hardware 1313 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 1314 * \param agIOStatus: Status of completed I/O. 1315 * \param agFirstDword:Pointer to the four bytes of FIS. 1316 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 1317 * length. 1318 * \param agParam: Additional info based on status. 1319 * \param ioContext: Pointer to satIOContext_t. 1320 * 1321 * \return: none 1322 * 1323 *****************************************************************************/ 1324 void satChainedDataIOCB( 1325 agsaRoot_t *agRoot, 1326 agsaIORequest_t *agIORequest, 1327 bit32 agIOStatus, 1328 agsaFisHeader_t *agFirstDword, 1329 bit32 agIOInfoLen, 1330 void *agParam, 1331 void *ioContext 1332 ) 1333 { 1334 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 1335 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 1336 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1337 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1338 tdIORequestBody_t *tdIORequestBody; 1339 tdIORequestBody_t *tdOrgIORequestBody; 1340 satIOContext_t *satIOContext; 1341 satIOContext_t *satOrgIOContext; 1342 satIOContext_t *satNewIOContext; 1343 satInternalIo_t *satIntIo; 1344 satInternalIo_t *satNewIntIo = agNULL; 1345 satDeviceData_t *satDevData; 1346 scsiRspSense_t *pSense; 1347 tiIniScsiCmnd_t *scsiCmnd; 1348 tiIORequest_t *tiOrgIORequest; 1349 1350 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 1351 bit32 ataStatus = 0; 1352 bit32 status = tiError; 1353 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 1354 bit32 dataLength; 1355 1356 TI_DBG6(("satChainedDataIOCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", 1357 agIORequest, agIOStatus, agIOInfoLen)); 1358 1359 1360 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 1361 satIOContext = (satIOContext_t *) ioContext; 1362 if (satIOContext == agNULL) 1363 { 1364 TI_DBG1(("satChainedDataIOCB: satIOContext is NULL\n")); 1365 return; 1366 } 1367 satIntIo = satIOContext->satIntIoContext; 1368 satDevData = satIOContext->pSatDevData; 1369 hostToDevFis = satIOContext->pFis; 1370 1371 if (satIntIo == agNULL) 1372 { 1373 TI_DBG5(("satChainedDataIOCB: External satInternalIo_t satIntIoContext\n")); 1374 satOrgIOContext = satIOContext; 1375 tiOrgIORequest = tdIORequestBody->tiIORequest; 1376 pSense = satIOContext->pSense; 1377 scsiCmnd = satIOContext->pScsiCmnd; 1378 } 1379 else 1380 { 1381 TI_DBG5(("satChainedDataIOCB: Internal satInternalIo_t satIntIoContext\n")); 1382 satOrgIOContext = satIOContext->satOrgIOContext; 1383 if (satOrgIOContext == agNULL) 1384 { 1385 TI_DBG5(("satChainedDataIOCB: satOrgIOContext is NULL\n")); 1386 } 1387 else 1388 { 1389 TI_DBG5(("satChainedDataIOCB: satOrgIOContext is NOT NULL\n")); 1390 } 1391 1392 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 1393 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 1394 1395 pSense = satOrgIOContext->pSense; 1396 scsiCmnd = satOrgIOContext->pScsiCmnd; 1397 } 1398 1399 tdIORequestBody->ioCompleted = agTRUE; 1400 tdIORequestBody->ioStarted = agFALSE; 1401 1402 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 1403 { 1404 TI_DBG1(("satChainedDataIOCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 1405 satSetSensePayload( pSense, 1406 SCSI_SNSKEY_NO_SENSE, 1407 0, 1408 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1409 satOrgIOContext); 1410 1411 ostiInitiatorIOCompleted( tiRoot, 1412 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 1413 tiIOSuccess, 1414 SCSI_STAT_CHECK_CONDITION, 1415 satOrgIOContext->pTiSenseData, 1416 satOrgIOContext->interruptContext ); 1417 1418 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1419 1420 satFreeIntIoResource( tiRoot, 1421 satDevData, 1422 satIntIo); 1423 return; 1424 } 1425 1426 /* 1427 checking IO status, FIS type and error status 1428 */ 1429 if (agIOStatus != OSSA_IO_SUCCESS) 1430 { 1431 /* agsaFisPioSetup_t or agsaFisRegDeviceToHost_t or agsaFisSetDevBits_t for read 1432 agsaFisRegDeviceToHost_t or agsaFisSetDevBits_t for write 1433 first, assumed to be Reg Device to Host FIS 1434 This is OK to just find fis type 1435 */ 1436 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 1437 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 1438 /* for debugging */ 1439 if( (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS) && 1440 (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) && 1441 (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS) 1442 ) 1443 { 1444 TI_DBG1(("satChainedDataIOCB: FAILED, Wrong FIS type 0x%x\n", statDevToHostFisHeader->fisType)); 1445 } 1446 1447 /* for debugging */ 1448 if ( (ataStatus & ERR_ATA_STATUS_MASK) || 1449 (ataStatus & DF_ATA_STATUS_MASK) 1450 ) 1451 { 1452 TI_DBG1(("satChainedDataIOCB: FAILED, error status and command 0x%x\n", hostToDevFis->h.command)); 1453 } 1454 1455 /* the function below handles abort case */ 1456 itdsatDelayedProcessAbnormalCompletion(agRoot, 1457 agIORequest, 1458 agIOStatus, 1459 agFirstDword, 1460 agIOInfoLen, 1461 agParam, 1462 satIOContext); 1463 1464 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1465 satFreeIntIoResource( tiRoot, 1466 satDevData, 1467 satIntIo); 1468 return; 1469 } /* end of error */ 1470 1471 switch (hostToDevFis->h.command) 1472 { 1473 case SAT_READ_DMA: /* fall through */ 1474 case SAT_READ_SECTORS: /* fall through */ 1475 case SAT_READ_DMA_EXT: /* fall through */ 1476 case SAT_READ_SECTORS_EXT: /* fall through */ 1477 case SAT_READ_FPDMA_QUEUED: /* fall through */ 1478 case SAT_WRITE_DMA: /* fall through */ 1479 case SAT_WRITE_SECTORS:/* fall through */ 1480 case SAT_WRITE_DMA_FUA_EXT: /* fall through */ 1481 case SAT_WRITE_DMA_EXT: /* fall through */ 1482 case SAT_WRITE_SECTORS_EXT: /* fall through */ 1483 case SAT_WRITE_FPDMA_QUEUED: 1484 1485 TI_DBG5(("satChainedDataIOCB: READ/WRITE success case\n")); 1486 1487 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1488 1489 /* done with internally genereated SAT_SMART_RETURN_STATUS */ 1490 satFreeIntIoResource( tiRoot, 1491 satDevData, 1492 satIntIo); 1493 /* let's loop till TL */ 1494 1495 /* lba = lba + tl 1496 loopnum--; 1497 if (loopnum == 0) done 1498 */ 1499 (satOrgIOContext->LoopNum)--; 1500 if (satOrgIOContext->LoopNum == 0) 1501 { 1502 /* done with read */ 1503 ostiInitiatorIOCompleted( tiRoot, 1504 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 1505 tiIOSuccess, 1506 SCSI_STAT_GOOD, 1507 agNULL, 1508 satOrgIOContext->interruptContext ); 1509 return; 1510 } 1511 if (satOrgIOContext->superIOFlag) 1512 { 1513 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->scsiCmnd.expDataLength; 1514 } 1515 else 1516 { 1517 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->scsiCmnd.expDataLength; 1518 } 1519 1520 satNewIntIo = satAllocIntIoResource( tiRoot, 1521 tiOrgIORequest, 1522 satDevData, 1523 dataLength, 1524 satNewIntIo); 1525 if (satNewIntIo == agNULL) 1526 { 1527 /* memory allocation failure */ 1528 satFreeIntIoResource( tiRoot, 1529 satDevData, 1530 satNewIntIo); 1531 ostiInitiatorIOCompleted( tiRoot, 1532 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 1533 tiIOFailed, 1534 tiDetailOtherError, 1535 agNULL, 1536 satOrgIOContext->interruptContext ); 1537 1538 TI_DBG1(("satChainedDataIOCB: momory allocation fails\n")); 1539 return; 1540 } /* end of memory allocation failure */ 1541 1542 /* 1543 * Need to initialize all the fields within satIOContext 1544 */ 1545 1546 satNewIOContext = satPrepareNewIO( 1547 satNewIntIo, 1548 tiOrgIORequest, 1549 satDevData, 1550 scsiCmnd, 1551 satOrgIOContext 1552 ); 1553 1554 /* sending another ATA command */ 1555 switch (scsiCmnd->cdb[0]) 1556 { 1557 case SCSIOPC_READ_6: 1558 /* no loop should occur with READ6 since it fits in one ATA command */ 1559 break; 1560 case SCSIOPC_READ_10: /* fall through */ 1561 case SCSIOPC_READ_12: /* fall through */ 1562 case SCSIOPC_READ_16: /* fall through */ 1563 status = satRead_1( tiRoot, 1564 &satNewIntIo->satIntTiIORequest, 1565 satNewIOContext->ptiDeviceHandle, 1566 &satNewIntIo->satIntTiScsiXchg, 1567 satNewIOContext); 1568 break; 1569 case SCSIOPC_WRITE_6: 1570 /* no loop should occur with WRITE6 since it fits in one ATA command */ 1571 break; 1572 case SCSIOPC_WRITE_10: /* fall through */ 1573 case SCSIOPC_WRITE_12: /* fall through */ 1574 case SCSIOPC_WRITE_16: /* fall through */ 1575 status = satWrite_1( tiRoot, 1576 &satNewIntIo->satIntTiIORequest, 1577 satNewIOContext->ptiDeviceHandle, 1578 &satNewIntIo->satIntTiScsiXchg, 1579 satNewIOContext); 1580 break; 1581 default: 1582 TI_DBG1(("satChainedDataIOCB: success but default case scsi cmd 0x%x ata cmd 0x%x\n",scsiCmnd->cdb[0], hostToDevFis->h.command)); 1583 status = tiError; 1584 break; 1585 } 1586 1587 1588 1589 if (status != tiSuccess) 1590 { 1591 satFreeIntIoResource( tiRoot, 1592 satDevData, 1593 satNewIntIo); 1594 ostiInitiatorIOCompleted( tiRoot, 1595 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 1596 tiIOFailed, 1597 tiDetailOtherError, 1598 agNULL, 1599 satOrgIOContext->interruptContext ); 1600 TI_DBG1(("satChainedDataIOCB: calling satRead10_1 fails\n")); 1601 return; 1602 } 1603 1604 break; 1605 1606 1607 default: 1608 TI_DBG1(("satChainedDataIOCB: success but default case command 0x%x\n",hostToDevFis->h.command)); 1609 ostiInitiatorIOCompleted( tiRoot, 1610 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 1611 tiIOFailed, 1612 tiDetailOtherError, 1613 agNULL, 1614 satOrgIOContext->interruptContext ); 1615 1616 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1617 1618 satFreeIntIoResource( tiRoot, 1619 satDevData, 1620 satIntIo); 1621 1622 break; 1623 } 1624 1625 1626 return; 1627 } 1628 void satNonChainedWriteNVerifyCB( 1629 agsaRoot_t *agRoot, 1630 agsaIORequest_t *agIORequest, 1631 bit32 agIOStatus, 1632 agsaFisHeader_t *agFirstDword, 1633 bit32 agIOInfoLen, 1634 void *agParam, 1635 void *ioContext 1636 ) 1637 { 1638 1639 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 1640 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 1641 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1642 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1643 tdIORequestBody_t *tdIORequestBody; 1644 tdIORequestBody_t *tdOrgIORequestBody; 1645 satIOContext_t *satIOContext; 1646 satIOContext_t *satOrgIOContext; 1647 satIOContext_t *satNewIOContext; 1648 satInternalIo_t *satIntIo; 1649 satInternalIo_t *satNewIntIo = agNULL; 1650 satDeviceData_t *satDevData; 1651 scsiRspSense_t *pSense; 1652 tiIniScsiCmnd_t *scsiCmnd; 1653 tiIORequest_t *tiOrgIORequest; 1654 1655 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 1656 bit32 ataStatus = 0; 1657 bit32 status; 1658 tiScsiInitiatorRequest_t *tiScsiRequest; /* tiScsiXchg */ 1659 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 1660 agsaFisSetDevBitsHeader_t *statSetDevBitFisHeader = agNULL; 1661 1662 TI_DBG5(("satNonChainedWriteNVerifyCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 1663 1664 /* internally generate tiIOContext */ 1665 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 1666 satIOContext = (satIOContext_t *) ioContext; 1667 satIntIo = satIOContext->satIntIoContext; 1668 satDevData = satIOContext->pSatDevData; 1669 hostToDevFis = satIOContext->pFis; 1670 1671 /* SPC: Self-Test Result Log page */ 1672 tiScsiRequest = satIOContext->tiScsiXchg; 1673 1674 if (satIntIo == agNULL) 1675 { 1676 TI_DBG4(("satNonChainedWriteNVerifyCB: External satInternalIo_t satIntIoContext\n")); 1677 satOrgIOContext = satIOContext; 1678 tiOrgIORequest = tdIORequestBody->tiIORequest; 1679 pSense = satOrgIOContext->pSense; 1680 scsiCmnd = satOrgIOContext->pScsiCmnd; 1681 } 1682 else 1683 { 1684 TI_DBG4(("satNonChainedWriteNVerifyCB: Internal satInternalIo_t satIntIoContext\n")); 1685 satOrgIOContext = satIOContext->satOrgIOContext; 1686 if (satOrgIOContext == agNULL) 1687 { 1688 TI_DBG4(("satNonChainedWriteNVerifyCB: satOrgIOContext is NULL, wrong\n")); 1689 return; 1690 } 1691 else 1692 { 1693 TI_DBG4(("satNonChainedWriteNVerifyCB: satOrgIOContext is NOT NULL\n")); 1694 } 1695 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 1696 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 1697 1698 pSense = satOrgIOContext->pSense; 1699 scsiCmnd = satOrgIOContext->pScsiCmnd; 1700 } 1701 1702 tdIORequestBody->ioCompleted = agTRUE; 1703 tdIORequestBody->ioStarted = agFALSE; 1704 1705 1706 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 1707 { 1708 TI_DBG1(("satNonChainedWriteNVerifyCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 1709 ostiInitiatorIOCompleted ( 1710 tiRoot, 1711 tiOrgIORequest, 1712 tiIOFailed, 1713 tiDetailOtherError, 1714 agNULL, 1715 satOrgIOContext->interruptContext 1716 ); 1717 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1718 1719 satFreeIntIoResource( tiRoot, 1720 satDevData, 1721 satIntIo); 1722 return; 1723 } 1724 1725 1726 if (agIOStatus != OSSA_IO_SUCCESS) 1727 { 1728 /* 1729 FIS type should be either REG_DEV_TO_HOST_FIS or SET_DEV_BITS_FIS 1730 */ 1731 /* First, assumed to be Reg Device to Host FIS */ 1732 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 1733 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 1734 } 1735 1736 if (agIOStatus != OSSA_IO_SUCCESS) 1737 { 1738 if (statDevToHostFisHeader->fisType == SET_DEV_BITS_FIS) 1739 { 1740 statSetDevBitFisHeader = (agsaFisSetDevBitsHeader_t *)&(agFirstDword->D2H); 1741 1742 /* Get ATA Status register */ 1743 ataStatus = (statSetDevBitFisHeader->statusHi_Lo & 0x70); /* bits 4,5,6 */ 1744 ataStatus = ataStatus | (statSetDevBitFisHeader->statusHi_Lo & 0x07); /* bits 0,1,2 */ 1745 1746 /* ATA Eror register */ 1747 } 1748 } 1749 1750 1751 if( agIOStatus != OSSA_IO_SUCCESS) 1752 { 1753 /* 1754 checking IO status, FIS type and error status 1755 FIS type should be either REG_DEV_TO_HOST_FIS or SET_DEV_BITS_FIS 1756 Both have fisType in the same location 1757 */ 1758 if ( ((statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) && 1759 (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS)) || 1760 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 1761 ) 1762 { 1763 /* for debugging */ 1764 if( agIOStatus != OSSA_IO_SUCCESS) 1765 { 1766 TI_DBG1(("satNonChainedWriteNVerifyCB: FAILED, NOT IO_SUCCESS\n")); 1767 } 1768 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 1769 { 1770 TI_DBG1(("satNonChainedWriteNVerifyCB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 1771 } 1772 else if (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS) 1773 { 1774 TI_DBG1(("satNonChainedWriteNVerifyCB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 1775 } 1776 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 1777 (ataStatus & DF_ATA_STATUS_MASK) 1778 ) 1779 { 1780 TI_DBG1(("satNonChainedWriteNVerifyCB: FAILED, FAILED, error status\n")); 1781 } 1782 1783 1784 /* Process abort case */ 1785 if (agIOStatus == OSSA_IO_ABORTED) 1786 { 1787 satProcessAbort(tiRoot, 1788 tiOrgIORequest, 1789 satOrgIOContext 1790 ); 1791 1792 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1793 1794 satFreeIntIoResource( tiRoot, 1795 satDevData, 1796 satIntIo); 1797 return; 1798 } 1799 1800 /* for debugging */ 1801 switch (hostToDevFis->h.command) 1802 { 1803 case SAT_WRITE_DMA_FUA_EXT: 1804 TI_DBG1(("satNonChainedWriteNVerifyCB: SAT_WRITE_DMA_FUA_EXT\n")); 1805 break; 1806 case SAT_WRITE_DMA_EXT: 1807 TI_DBG1(("satNonChainedWriteNVerifyCB: SAT_WRITE_DMA_EXT\n")); 1808 break; 1809 case SAT_WRITE_SECTORS_EXT: 1810 TI_DBG1(("satNonChainedWriteNVerifyCB: SAT_WRITE_SECTORS_EXT\n")); 1811 break; 1812 case SAT_WRITE_FPDMA_QUEUED: 1813 TI_DBG1(("satNonChainedWriteNVerifyCB: SAT_WRITE_FPDMA_QUEUED\n")); 1814 break; 1815 case SAT_READ_VERIFY_SECTORS: 1816 TI_DBG1(("satNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS\n")); 1817 break; 1818 case SAT_READ_VERIFY_SECTORS_EXT: 1819 TI_DBG1(("satNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS_EXT\n")); 1820 break; 1821 default: 1822 TI_DBG1(("satNonChainedWriteNVerifyCB: error default case command 0x%x\n", hostToDevFis->h.command)); 1823 break; 1824 } 1825 1826 satSetSensePayload( pSense, 1827 SCSI_SNSKEY_NO_SENSE, 1828 0, 1829 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1830 satOrgIOContext); 1831 1832 ostiInitiatorIOCompleted( tiRoot, 1833 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 1834 tiIOSuccess, 1835 SCSI_STAT_CHECK_CONDITION, 1836 satOrgIOContext->pTiSenseData, 1837 satOrgIOContext->interruptContext ); 1838 1839 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1840 1841 satFreeIntIoResource( tiRoot, 1842 satDevData, 1843 satIntIo); 1844 return; 1845 } /* end error checking */ 1846 } 1847 1848 /* process success from this point on */ 1849 1850 switch (hostToDevFis->h.command) 1851 { 1852 case SAT_WRITE_DMA_FUA_EXT: 1853 TI_DBG5(("satNonChainedWriteNVerifyCB: SAT_WRITE_DMA_FUA_EXT success\n")); 1854 break; 1855 case SAT_WRITE_DMA_EXT: 1856 TI_DBG5(("satNonChainedWriteNVerifyCB: SAT_WRITE_DMA_EXT success\n")); 1857 break; 1858 case SAT_WRITE_SECTORS_EXT: 1859 TI_DBG5(("satNonChainedWriteNVerifyCB: SAT_WRITE_SECTORS_EXT succes\n")); 1860 1861 break; 1862 case SAT_WRITE_FPDMA_QUEUED: 1863 TI_DBG5(("satNonChainedWriteNVerifyCB: SAT_WRITE_FPDMA_QUEUED succes\n")); 1864 break; 1865 case SAT_READ_VERIFY_SECTORS: 1866 TI_DBG5(("satNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS succes\n")); 1867 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1868 1869 /* free */ 1870 satFreeIntIoResource( tiRoot, 1871 satDevData, 1872 satIntIo); 1873 1874 /* return stat_good */ 1875 ostiInitiatorIOCompleted( tiRoot, 1876 tiOrgIORequest, 1877 tiIOSuccess, 1878 SCSI_STAT_GOOD, 1879 agNULL, 1880 satOrgIOContext->interruptContext ); 1881 return; 1882 break; 1883 case SAT_READ_VERIFY_SECTORS_EXT: 1884 TI_DBG5(("satNonChainedWriteNVerifyCB: SAT_READ_VERIFY_SECTORS_EXT succes\n")); 1885 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1886 1887 /* free */ 1888 satFreeIntIoResource( tiRoot, 1889 satDevData, 1890 satIntIo); 1891 1892 /* return stat_good */ 1893 ostiInitiatorIOCompleted( tiRoot, 1894 tiOrgIORequest, 1895 tiIOSuccess, 1896 SCSI_STAT_GOOD, 1897 agNULL, 1898 satOrgIOContext->interruptContext ); 1899 return; 1900 break; 1901 default: 1902 TI_DBG1(("satNonChainedWriteNVerifyCB: error default case command 0x%x success\n", hostToDevFis->h.command)); 1903 1904 satSetSensePayload( pSense, 1905 SCSI_SNSKEY_NO_SENSE, 1906 0, 1907 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1908 satOrgIOContext); 1909 1910 ostiInitiatorIOCompleted( tiRoot, 1911 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 1912 tiIOSuccess, 1913 SCSI_STAT_CHECK_CONDITION, 1914 satOrgIOContext->pTiSenseData, 1915 satOrgIOContext->interruptContext ); 1916 1917 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1918 1919 satFreeIntIoResource( tiRoot, 1920 satDevData, 1921 satIntIo); 1922 return; 1923 break; 1924 } 1925 1926 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 1927 1928 /* free */ 1929 satFreeIntIoResource( tiRoot, 1930 satDevData, 1931 satIntIo); 1932 1933 satNewIntIo = satAllocIntIoResource( tiRoot, 1934 tiOrgIORequest, 1935 satDevData, 1936 0, 1937 satNewIntIo); 1938 if (satNewIntIo == agNULL) 1939 { 1940 /* memory allocation failure */ 1941 satFreeIntIoResource( tiRoot, 1942 satDevData, 1943 satNewIntIo); 1944 1945 satSetSensePayload( pSense, 1946 SCSI_SNSKEY_NO_SENSE, 1947 0, 1948 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1949 satOrgIOContext); 1950 1951 ostiInitiatorIOCompleted( tiRoot, 1952 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 1953 tiIOSuccess, 1954 SCSI_STAT_CHECK_CONDITION, 1955 satOrgIOContext->pTiSenseData, 1956 satOrgIOContext->interruptContext ); 1957 TI_DBG1(("satNonChainedWriteNVerifyCB: momory allocation fails\n")); 1958 return; 1959 } /* end memory allocation */ 1960 1961 satNewIOContext = satPrepareNewIO( 1962 satNewIntIo, 1963 tiOrgIORequest, 1964 satDevData, 1965 scsiCmnd, 1966 satOrgIOContext 1967 ); 1968 1969 /* sends ATA verify command(READ_VERIFY_SECTORS or READ_VERIFY_SECTORS_EXT) */ 1970 status = satNonChainedWriteNVerify_Verify(tiRoot, 1971 &satNewIntIo->satIntTiIORequest, 1972 satNewIOContext->ptiDeviceHandle, 1973 tiScsiRequest, /* orginal from OS layer */ 1974 satNewIOContext 1975 ); 1976 1977 1978 if (status != tiSuccess) 1979 { 1980 /* sending ATA command fails */ 1981 satFreeIntIoResource( tiRoot, 1982 satDevData, 1983 satNewIntIo); 1984 satSetSensePayload( pSense, 1985 SCSI_SNSKEY_NO_SENSE, 1986 0, 1987 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 1988 satOrgIOContext); 1989 1990 ostiInitiatorIOCompleted( tiRoot, 1991 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 1992 tiIOSuccess, 1993 SCSI_STAT_CHECK_CONDITION, 1994 satOrgIOContext->pTiSenseData, 1995 satOrgIOContext->interruptContext ); 1996 TI_DBG1(("satNonChainedWriteNVerifyCB: calling satWriteAndVerify10_1 fails\n")); 1997 return; 1998 } /* end send fails */ 1999 2000 return; 2001 } 2002 2003 2004 void satChainedWriteNVerifyCB( 2005 agsaRoot_t *agRoot, 2006 agsaIORequest_t *agIORequest, 2007 bit32 agIOStatus, 2008 agsaFisHeader_t *agFirstDword, 2009 bit32 agIOInfoLen, 2010 void *agParam, 2011 void *ioContext 2012 ) 2013 { 2014 /* 2015 send write in loop 2016 then, send verify in loop 2017 */ 2018 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 2019 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 2020 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2021 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2022 tdIORequestBody_t *tdIORequestBody; 2023 tdIORequestBody_t *tdOrgIORequestBody; 2024 satIOContext_t *satIOContext; 2025 satIOContext_t *satOrgIOContext; 2026 satIOContext_t *satNewIOContext; 2027 satInternalIo_t *satIntIo; 2028 satInternalIo_t *satNewIntIo = agNULL; 2029 satDeviceData_t *satDevData; 2030 scsiRspSense_t *pSense; 2031 tiIniScsiCmnd_t *scsiCmnd; 2032 tiIORequest_t *tiOrgIORequest; 2033 2034 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 2035 bit32 ataStatus = 0; 2036 bit32 dataLength; 2037 bit32 status = tiError; 2038 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 2039 2040 TI_DBG6(("satChainedWriteNVerifyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", 2041 agIORequest, agIOStatus, agIOInfoLen)); 2042 2043 2044 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 2045 satIOContext = (satIOContext_t *) ioContext; 2046 satIntIo = satIOContext->satIntIoContext; 2047 satDevData = satIOContext->pSatDevData; 2048 hostToDevFis = satIOContext->pFis; 2049 2050 if (satIntIo == agNULL) 2051 { 2052 TI_DBG5(("satChainedWriteNVerifyCB: External satInternalIo_t satIntIoContext\n")); 2053 satOrgIOContext = satIOContext; 2054 tiOrgIORequest = tdIORequestBody->tiIORequest; 2055 pSense = satIOContext->pSense; 2056 scsiCmnd = satIOContext->pScsiCmnd; 2057 } 2058 else 2059 { 2060 TI_DBG5(("satChainedWriteNVerifyCB: Internal satInternalIo_t satIntIoContext\n")); 2061 satOrgIOContext = satIOContext->satOrgIOContext; 2062 if (satOrgIOContext == agNULL) 2063 { 2064 TI_DBG5(("satChainedWriteNVerifyCB: satOrgIOContext is NULL, wrong\n")); 2065 return; 2066 } 2067 else 2068 { 2069 TI_DBG5(("satChainedWriteNVerifyCB: satOrgIOContext is NOT NULL\n")); 2070 } 2071 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 2072 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 2073 2074 pSense = satOrgIOContext->pSense; 2075 scsiCmnd = satOrgIOContext->pScsiCmnd; 2076 } 2077 2078 tdIORequestBody->ioCompleted = agTRUE; 2079 tdIORequestBody->ioStarted = agFALSE; 2080 2081 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 2082 { 2083 TI_DBG1(("satChainedWriteNVerifyCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 2084 satSetSensePayload( pSense, 2085 SCSI_SNSKEY_NO_SENSE, 2086 0, 2087 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 2088 satOrgIOContext); 2089 2090 ostiInitiatorIOCompleted( tiRoot, 2091 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 2092 tiIOSuccess, 2093 SCSI_STAT_CHECK_CONDITION, 2094 satOrgIOContext->pTiSenseData, 2095 satOrgIOContext->interruptContext ); 2096 2097 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 2098 2099 satFreeIntIoResource( tiRoot, 2100 satDevData, 2101 satIntIo); 2102 return; 2103 } 2104 2105 /* 2106 checking IO status, FIS type and error status 2107 */ 2108 if (agIOStatus != OSSA_IO_SUCCESS) 2109 { 2110 /* agsaFisPioSetup_t or agsaFisRegDeviceToHost_t or agsaFisSetDevBits_t for read 2111 agsaFisRegDeviceToHost_t or agsaFisSetDevBits_t for write 2112 first, assumed to be Reg Device to Host FIS 2113 This is OK to just find fis type 2114 */ 2115 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 2116 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 2117 /* for debugging */ 2118 if( (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS) && 2119 (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) && 2120 (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS) 2121 ) 2122 { 2123 TI_DBG1(("satChainedWriteNVerifyCB: FAILED, Wrong FIS type 0x%x\n", statDevToHostFisHeader->fisType)); 2124 } 2125 2126 /* for debugging */ 2127 if ( (ataStatus & ERR_ATA_STATUS_MASK) || 2128 (ataStatus & DF_ATA_STATUS_MASK) 2129 ) 2130 { 2131 TI_DBG1(("satChainedWriteNVerifyCB: FAILED, error status and command 0x%x\n", hostToDevFis->h.command)); 2132 } 2133 2134 /* the function below handles abort case */ 2135 itdsatDelayedProcessAbnormalCompletion(agRoot, 2136 agIORequest, 2137 agIOStatus, 2138 agFirstDword, 2139 agIOInfoLen, 2140 agParam, 2141 satIOContext); 2142 2143 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 2144 satFreeIntIoResource( tiRoot, 2145 satDevData, 2146 satIntIo); 2147 return; 2148 } /* end of error */ 2149 2150 /* process the success case */ 2151 switch (hostToDevFis->h.command) 2152 { 2153 case SAT_WRITE_DMA: /* fall through */ 2154 case SAT_WRITE_SECTORS:/* fall through */ 2155 // case SAT_WRITE_DMA_FUA_EXT: /* fall through */ 2156 case SAT_WRITE_DMA_EXT: /* fall through */ 2157 case SAT_WRITE_SECTORS_EXT: /* fall through */ 2158 case SAT_WRITE_FPDMA_QUEUED: 2159 2160 TI_DBG5(("satChainedWriteNVerifyCB: WRITE success case\n")); 2161 2162 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 2163 2164 /* done with internally genereated SAT_SMART_RETURN_STATUS */ 2165 satFreeIntIoResource( tiRoot, 2166 satDevData, 2167 satIntIo); 2168 /* let's loop till TL */ 2169 2170 2171 (satOrgIOContext->LoopNum)--; 2172 2173 if (satOrgIOContext->superIOFlag) 2174 { 2175 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->scsiCmnd.expDataLength; 2176 } 2177 else 2178 { 2179 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->scsiCmnd.expDataLength; 2180 } 2181 2182 satNewIntIo = satAllocIntIoResource( tiRoot, 2183 tiOrgIORequest, 2184 satDevData, 2185 dataLength, 2186 satNewIntIo); 2187 if (satNewIntIo == agNULL) 2188 { 2189 /* memory allocation failure */ 2190 satFreeIntIoResource( tiRoot, 2191 satDevData, 2192 satNewIntIo); 2193 ostiInitiatorIOCompleted( tiRoot, 2194 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 2195 tiIOFailed, 2196 tiDetailOtherError, 2197 agNULL, 2198 satOrgIOContext->interruptContext ); 2199 2200 TI_DBG1(("satChainedWriteNVerifyCB: momory allocation fails\n")); 2201 return; 2202 } /* end of memory allocation failure */ 2203 2204 /* 2205 * Need to initialize all the fields within satIOContext 2206 */ 2207 2208 satNewIOContext = satPrepareNewIO( 2209 satNewIntIo, 2210 tiOrgIORequest, 2211 satDevData, 2212 scsiCmnd, 2213 satOrgIOContext 2214 ); 2215 2216 if (satOrgIOContext->LoopNum == 0) 2217 { 2218 /* 2219 done with write 2220 start with verify 2221 */ 2222 satOrgIOContext->LoopNum = satOrgIOContext->LoopNum2; 2223 status = satChainedWriteNVerify_Start_Verify(tiRoot, 2224 &satNewIntIo->satIntTiIORequest, 2225 satNewIOContext->ptiDeviceHandle, 2226 &satNewIntIo->satIntTiScsiXchg, 2227 satNewIOContext); 2228 } 2229 else 2230 { 2231 status = satChainedWriteNVerify_Write(tiRoot, 2232 &satNewIntIo->satIntTiIORequest, 2233 satNewIOContext->ptiDeviceHandle, 2234 &satNewIntIo->satIntTiScsiXchg, 2235 satNewIOContext); 2236 } 2237 2238 if (status != tiSuccess) 2239 { 2240 satFreeIntIoResource( tiRoot, 2241 satDevData, 2242 satNewIntIo); 2243 ostiInitiatorIOCompleted( tiRoot, 2244 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 2245 tiIOFailed, 2246 tiDetailOtherError, 2247 agNULL, 2248 satOrgIOContext->interruptContext ); 2249 TI_DBG1(("satChainedWriteNVerifyCB: calling satChainedWriteNVerify_Write fails\n")); 2250 return; 2251 } 2252 2253 break; 2254 2255 case SAT_READ_VERIFY_SECTORS: /* fall through */ 2256 case SAT_READ_VERIFY_SECTORS_EXT: 2257 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 2258 2259 /* done with internally genereated SAT_SMART_RETURN_STATUS */ 2260 satFreeIntIoResource( tiRoot, 2261 satDevData, 2262 satIntIo); 2263 /* let's loop till TL */ 2264 2265 /* lba = lba + tl 2266 loopnum--; 2267 if (loopnum == 0) done 2268 */ 2269 (satOrgIOContext->LoopNum)--; 2270 if (satOrgIOContext->LoopNum == 0) 2271 { 2272 /* 2273 done with write and verify 2274 */ 2275 ostiInitiatorIOCompleted( tiRoot, 2276 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 2277 tiIOSuccess, 2278 SCSI_STAT_GOOD, 2279 agNULL, 2280 satOrgIOContext->interruptContext ); 2281 return; 2282 } 2283 2284 if (satOrgIOContext->superIOFlag) 2285 { 2286 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->scsiCmnd.expDataLength; 2287 } 2288 else 2289 { 2290 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->scsiCmnd.expDataLength; 2291 } 2292 2293 satNewIntIo = satAllocIntIoResource( tiRoot, 2294 tiOrgIORequest, 2295 satDevData, 2296 dataLength, 2297 satNewIntIo); 2298 if (satNewIntIo == agNULL) 2299 { 2300 /* memory allocation failure */ 2301 satFreeIntIoResource( tiRoot, 2302 satDevData, 2303 satNewIntIo); 2304 ostiInitiatorIOCompleted( tiRoot, 2305 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 2306 tiIOFailed, 2307 tiDetailOtherError, 2308 agNULL, 2309 satOrgIOContext->interruptContext ); 2310 2311 TI_DBG1(("satChainedWriteNVerifyCB: momory allocation fails\n")); 2312 return; 2313 } /* end of memory allocation failure */ 2314 2315 /* 2316 * Need to initialize all the fields within satIOContext 2317 */ 2318 2319 satNewIOContext = satPrepareNewIO( 2320 satNewIntIo, 2321 tiOrgIORequest, 2322 satDevData, 2323 scsiCmnd, 2324 satOrgIOContext 2325 ); 2326 status = satChainedWriteNVerify_Verify(tiRoot, 2327 &satNewIntIo->satIntTiIORequest, 2328 satNewIOContext->ptiDeviceHandle, 2329 &satNewIntIo->satIntTiScsiXchg, 2330 satNewIOContext); 2331 2332 if (status != tiSuccess) 2333 { 2334 satFreeIntIoResource( tiRoot, 2335 satDevData, 2336 satNewIntIo); 2337 ostiInitiatorIOCompleted( tiRoot, 2338 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 2339 tiIOFailed, 2340 tiDetailOtherError, 2341 agNULL, 2342 satOrgIOContext->interruptContext ); 2343 TI_DBG1(("satChainedWriteNVerifyCB: calling satChainedWriteNVerify_Verify fails\n")); 2344 return; 2345 } 2346 2347 break; 2348 2349 default: 2350 TI_DBG1(("satChainedWriteNVerifyCB: success but default case command 0x%x\n",hostToDevFis->h.command)); 2351 ostiInitiatorIOCompleted( tiRoot, 2352 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 2353 tiIOFailed, 2354 tiDetailOtherError, 2355 agNULL, 2356 satOrgIOContext->interruptContext ); 2357 2358 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 2359 2360 satFreeIntIoResource( tiRoot, 2361 satDevData, 2362 satIntIo); 2363 2364 break; 2365 } 2366 2367 2368 return; 2369 } 2370 /***************************************************************************** 2371 *! \brief itdsatProcessAbnormalCompletion 2372 * 2373 * This routine is called to complete error case for SATA request previously 2374 * issued to the LL Layer in saSATAStart() 2375 * 2376 * \param agRoot: Handles for this instance of SAS/SATA hardware 2377 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 2378 * \param agIOStatus: Status of completed I/O. 2379 * \param agFirstDword:Pointer to the four bytes of FIS. 2380 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 2381 * length. 2382 * \param agParam: Additional info based on status. 2383 * \param ioContext: Pointer to satIOContext_t. 2384 * 2385 * \return: none 2386 * 2387 *****************************************************************************/ 2388 void itdsatProcessAbnormalCompletion( 2389 agsaRoot_t *agRoot, 2390 agsaIORequest_t *agIORequest, 2391 bit32 agIOStatus, 2392 agsaFisHeader_t *agFirstDword, 2393 bit32 agIOInfoLen, 2394 void *agParam, 2395 satIOContext_t *satIOContext 2396 ) 2397 { 2398 2399 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 2400 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 2401 bit32 interruptContext = osData->IntContext; 2402 tdIORequestBody_t *tdIORequestBody; 2403 satDeviceData_t *pSatDevData; 2404 tiDeviceHandle_t *tiDeviceHandle; 2405 tdsaDeviceData_t *oneDeviceData = agNULL; 2406 agsaDevHandle_t *agDevHandle = agNULL; 2407 2408 TI_DBG5(("itdsatProcessAbnormalCompletion: agIORequest=%p agIOStatus=0x%x agIOInfoLen=%d\n", 2409 agIORequest, agIOStatus, agIOInfoLen)); 2410 2411 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 2412 pSatDevData = satIOContext->pSatDevData; 2413 tiDeviceHandle = satIOContext->ptiDeviceHandle; 2414 2415 /* Get into the detail */ 2416 switch(agIOStatus) 2417 { 2418 case OSSA_IO_SUCCESS: 2419 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_SUCCESS agIOInfoLen %d calling osSatIOCompleted\n", agIOInfoLen)); 2420 /* 2421 * At this point agIOInfoLen should be non-zero and there is valid FIS 2422 * to read. Pass this info to the SAT layer in order to do the ATA status 2423 * to SCSI status translation. 2424 */ 2425 osSatIOCompleted( tiRoot, 2426 tdIORequestBody->tiIORequest, 2427 agFirstDword, 2428 agIOInfoLen, 2429 agParam, 2430 satIOContext, 2431 interruptContext); 2432 break; 2433 2434 2435 case OSSA_IO_ABORTED: 2436 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORTED\n")); 2437 2438 ostiInitiatorIOCompleted( tiRoot, 2439 tdIORequestBody->tiIORequest, 2440 tiIOFailed, 2441 tiDetailAborted, 2442 agNULL, 2443 interruptContext); 2444 2445 if ( pSatDevData->satTmTaskTag != agNULL ) 2446 { 2447 TI_DBG1(("itdsatProcessAbnormalCompletion: TM callback\n")); 2448 if (tiDeviceHandle == agNULL) 2449 { 2450 TI_DBG1(("itdsatProcessAbnormalCompletion: wrong, tiDeviceHandle is NULL\n")); 2451 } 2452 /* TM completed */ 2453 ostiInitiatorEvent( tiRoot, 2454 agNULL, /* portalContext not used */ 2455 tiDeviceHandle, 2456 tiIntrEventTypeTaskManagement, 2457 tiTMOK, 2458 pSatDevData->satTmTaskTag); 2459 /* 2460 * Reset flag 2461 */ 2462 pSatDevData->satTmTaskTag = agNULL; 2463 } 2464 2465 /* 2466 * Check if we are in recovery mode and need to update the recovery flag 2467 */ 2468 if ((pSatDevData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) && 2469 (pSatDevData->satPendingIO == 0 )) 2470 { 2471 pSatDevData->satDriveState = SAT_DEV_STATE_NORMAL; 2472 TI_DBG1(("itdsatProcessAbnormalCompletion: STATE NORMAL.\n")); 2473 } 2474 2475 TI_DBG1(("itdsatProcessAbnormalCompletion: satDriveState %d\n", pSatDevData->satDriveState)); 2476 TI_DBG1(("itdsatProcessAbnormalCompletion: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 2477 TI_DBG1(("itdsatProcessAbnormalCompletion: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 2478 2479 break; 2480 case OSSA_IO_UNDERFLOW: 2481 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_UNDERFLOW\n")); 2482 ostiInitiatorIOCompleted( tiRoot, 2483 tdIORequestBody->tiIORequest, 2484 tiIOUnderRun, 2485 agIOInfoLen, 2486 agNULL, 2487 interruptContext); 2488 break; 2489 2490 2491 case OSSA_IO_FAILED: 2492 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_FAILED\n")); 2493 ostiInitiatorIOCompleted( tiRoot, 2494 tdIORequestBody->tiIORequest, 2495 tiIOFailed, 2496 tiDetailOtherError, 2497 agNULL, 2498 interruptContext); 2499 break; 2500 2501 case OSSA_IO_ABORT_RESET: 2502 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORT_RESET\n")); 2503 ostiInitiatorIOCompleted( tiRoot, 2504 tdIORequestBody->tiIORequest, 2505 tiIOFailed, 2506 tiDetailAbortReset, 2507 agNULL, 2508 interruptContext); 2509 /* 2510 * Check if we are in recovery mode and need to update the recovery flag 2511 */ 2512 if ((pSatDevData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) && 2513 (pSatDevData->satPendingIO == 0 )) 2514 { 2515 pSatDevData->satDriveState = SAT_DEV_STATE_NORMAL; 2516 TI_DBG1(("itdsatProcessAbnormalCompletion: STATE NORMAL.\n")); 2517 } 2518 2519 TI_DBG1(("itdsatProcessAbnormalCompletion: satDriveState %d\n", pSatDevData->satDriveState)); 2520 TI_DBG1(("itdsatProcessAbnormalCompletion: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 2521 TI_DBG1(("itdsatProcessAbnormalCompletion: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 2522 2523 break; 2524 2525 2526 case OSSA_IO_NO_DEVICE: 2527 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_NO_DEVICE\n")); 2528 ostiInitiatorIOCompleted( tiRoot, 2529 tdIORequestBody->tiIORequest, 2530 tiIOFailed, 2531 tiDetailNoLogin, 2532 agNULL, 2533 interruptContext); 2534 break; 2535 2536 case OSSA_IO_PROG_ERROR: 2537 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_PROG_ERROR\n")); 2538 ostiInitiatorIOCompleted( tiRoot, 2539 tdIORequestBody->tiIORequest, 2540 tiIOFailed, 2541 tiDetailOtherError, 2542 agNULL, 2543 interruptContext); 2544 break; 2545 case OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED: /* fall through */ 2546 case OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION: /* fall through */ 2547 case OSSA_IO_OPEN_CNX_ERROR_BREAK: /* fall through */ 2548 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS: /* fall through */ 2549 case OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION: /* fall through */ 2550 case OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED: /* fall through */ 2551 case OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION: /* fall through */ 2552 case OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR: /* fall through */ 2553 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_OPEN_CNX_ERROR_* 0x%x\n", agIOStatus)); 2554 if (tiDeviceHandle == agNULL) 2555 { 2556 TI_DBG1(("itdsatProcessAbnormalCompletion: wrong, tiDeviceHandle is NULL\n")); 2557 ostiInitiatorIOCompleted( tiRoot, 2558 tdIORequestBody->tiIORequest, 2559 tiIOFailed, 2560 tiDetailOtherError, 2561 agNULL, 2562 interruptContext); 2563 return; 2564 } 2565 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 2566 if (oneDeviceData == agNULL) 2567 { 2568 TI_DBG1(("itdsatProcessAbnormalCompletion: wrong, oneDeviceData is NULL\n")); 2569 } 2570 else 2571 { 2572 TI_DBG1(("itdsatProcessAbnormalCompletion: did %d\n", oneDeviceData->id)); 2573 } 2574 2575 ostiInitiatorIOCompleted( tiRoot, 2576 tdIORequestBody->tiIORequest, 2577 tiIOFailed, 2578 tiDetailOtherError, 2579 agNULL, 2580 interruptContext); 2581 break; 2582 2583 case OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY: 2584 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY\n")); 2585 ostiInitiatorIOCompleted( tiRoot, 2586 tdIORequestBody->tiIORequest, 2587 tiIOFailed, 2588 tiDetailOtherError, //tiDetailNoDeviceError, //tiDetailAborted, 2589 agNULL, 2590 interruptContext); 2591 break; 2592 2593 case OSSA_IO_XFER_ERROR_BREAK: /* fall throuth */ 2594 case OSSA_IO_XFER_ERROR_PHY_NOT_READY: /* fall throuth */ 2595 case OSSA_IO_XFER_ERROR_PEER_ABORTED: /* fall throuth */ 2596 case OSSA_IO_XFER_ERROR_DMA: /* fall throuth */ 2597 case OSSA_IO_XFER_ERROR_SATA_LINK_TIMEOUT: /* fall throuth */ 2598 case OSSA_IO_XFER_ERROR_ABORTED_DUE_TO_SRST: /* fall throuth */ 2599 case OSSA_IO_XFER_ERROR_REJECTED_NCQ_MODE: /* fall throuth */ 2600 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_ERROR_* 0x%x\n", agIOStatus)); 2601 ostiInitiatorIOCompleted( tiRoot, 2602 tdIORequestBody->tiIORequest, 2603 tiIOFailed, 2604 tiDetailOtherError, 2605 agNULL, 2606 interruptContext); 2607 break; 2608 case OSSA_IO_DS_IN_ERROR: 2609 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_IN_ERROR\n")); 2610 if (tiDeviceHandle == agNULL) 2611 { 2612 TI_DBG1(("itdsatProcessAbnormalCompletion: wrong, tiDeviceHandle is NULL\n")); 2613 ostiInitiatorIOCompleted( tiRoot, 2614 tdIORequestBody->tiIORequest, 2615 tiIOFailed, 2616 tiDetailOtherError, 2617 agNULL, 2618 interruptContext); 2619 return; 2620 } 2621 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 2622 if (oneDeviceData == agNULL) 2623 { 2624 TI_DBG1(("itdsatProcessAbnormalCompletion: wrong, oneDeviceData is NULL\n")); 2625 } 2626 else 2627 { 2628 TI_DBG1(("itdsatProcessAbnormalCompletion: did %d\n", oneDeviceData->id)); 2629 } 2630 ostiInitiatorIOCompleted( tiRoot, 2631 tdIORequestBody->tiIORequest, 2632 tiIOFailed, 2633 tiDetailOtherError, 2634 agNULL, 2635 interruptContext); 2636 break; 2637 case OSSA_IO_DS_NON_OPERATIONAL: 2638 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_NON_OPERATIONAL\n")); 2639 if (tiDeviceHandle == agNULL) 2640 { 2641 TI_DBG1(("itdsatProcessAbnormalCompletion: wrong, tiDeviceHandle is NULL\n")); 2642 ostiInitiatorIOCompleted( tiRoot, 2643 tdIORequestBody->tiIORequest, 2644 tiIOFailed, 2645 tiDetailOtherError, 2646 agNULL, 2647 interruptContext); 2648 return; 2649 } 2650 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 2651 if (oneDeviceData == agNULL) 2652 { 2653 TI_DBG1(("itdsatProcessAbnormalCompletion: wrong, oneDeviceData is NULL\n")); 2654 } 2655 else 2656 { 2657 TI_DBG1(("itdsatProcessAbnormalCompletion: did %d\n", oneDeviceData->id)); 2658 agDevHandle = oneDeviceData->agDevHandle; 2659 if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE && 2660 oneDeviceData->tdPortContext != agNULL ) 2661 { 2662 saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_OPERATIONAL); 2663 } 2664 } 2665 2666 ostiInitiatorIOCompleted( tiRoot, 2667 tdIORequestBody->tiIORequest, 2668 tiIOFailed, 2669 tiDetailOtherError, 2670 agNULL, 2671 interruptContext); 2672 break; 2673 case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS: /* fall through */ 2674 case OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH: 2675 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = ENCRYPTION ERROR 0x%x\n", agIOStatus)); 2676 itdsatEncryptionHandler(agRoot, 2677 agIORequest, 2678 agIOStatus, 2679 agIOInfoLen, 2680 agParam, 2681 0); 2682 break; 2683 case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH: /* fall through */ 2684 case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH: /* fall through */ 2685 case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH: 2686 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = DIF ERROR 0x%x\n", agIOStatus)); 2687 itdsatDifHandler(agRoot, 2688 agIORequest, 2689 agIOStatus, 2690 agIOInfoLen, 2691 agParam, 2692 0); 2693 break; 2694 default: 2695 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 2696 TI_DBG1(("itdsatProcessAbnormalCompletion: agIOStatus = unknown 0x%x\n", agIOStatus)); 2697 if (oneDeviceData != agNULL) 2698 { 2699 TI_DBG1(("itdsatProcessAbnormalCompletion: did %d\n", oneDeviceData->id)); 2700 } 2701 else 2702 { 2703 TI_DBG1(("itdsatProcessAbnormalCompletion: oneDeviceData is NULL\n")); 2704 } 2705 2706 ostiInitiatorIOCompleted( tiRoot, 2707 tdIORequestBody->tiIORequest, 2708 tiIOFailed, 2709 tiDetailOtherError, 2710 agNULL, 2711 interruptContext); 2712 break; 2713 2714 } /* switch */ 2715 } 2716 2717 2718 /***************************************************************************** 2719 *! \brief itdsatDelayedProcessAbnormalCompletion 2720 * 2721 * This routine is called to complete error case for SATA request previously 2722 * issued to the LL Layer in saSATAStart(). 2723 * This is used when command is chained. 2724 * 2725 * \param agRoot: Handles for this instance of SAS/SATA hardware 2726 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 2727 * \param agIOStatus: Status of completed I/O. 2728 * \param agFirstDword:Pointer to the four bytes of FIS. 2729 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 2730 * length. 2731 * \param agParam: Additional info based on status. 2732 * \param ioContext: Pointer to satIOContext_t. 2733 * 2734 * \return: none 2735 * 2736 *****************************************************************************/ 2737 void itdsatDelayedProcessAbnormalCompletion( 2738 agsaRoot_t *agRoot, 2739 agsaIORequest_t *agIORequest, 2740 bit32 agIOStatus, 2741 agsaFisHeader_t *agFirstDword, 2742 bit32 agIOInfoLen, 2743 void *agParam, 2744 satIOContext_t *satIOContext 2745 ) 2746 { 2747 2748 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 2749 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 2750 bit32 interruptContext = osData->IntContext; 2751 tdIORequestBody_t *tdIORequestBody; 2752 satDeviceData_t *pSatDevData; 2753 tiDeviceHandle_t *tiDeviceHandle; 2754 tdsaDeviceData_t *oneDeviceData = agNULL; 2755 agsaDevHandle_t *agDevHandle = agNULL; 2756 2757 TI_DBG5(("itdsatDelayedProcessAbnormalCompletion: agIORequest=%p agIOStatus=0x%x agIOInfoLen=%d\n", 2758 agIORequest, agIOStatus, agIOInfoLen)); 2759 2760 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 2761 pSatDevData = satIOContext->pSatDevData; 2762 tiDeviceHandle = satIOContext->ptiDeviceHandle; 2763 2764 /* Get into the detail */ 2765 switch(agIOStatus) 2766 { 2767 case OSSA_IO_SUCCESS: 2768 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_SUCCESS calling osSatIOCompleted\n")); 2769 /* do nothing */ 2770 break; 2771 2772 2773 case OSSA_IO_ABORTED: 2774 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORTED\n")); 2775 2776 ostiInitiatorIOCompleted( tiRoot, 2777 tdIORequestBody->tiIORequest, 2778 tiIOFailed, 2779 tiDetailAborted, 2780 agNULL, 2781 interruptContext); 2782 2783 if ( pSatDevData->satTmTaskTag != agNULL ) 2784 { 2785 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: TM callback\n")); 2786 if (tiDeviceHandle == agNULL) 2787 { 2788 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: wrong, tiDeviceHandle is NULL\n")); 2789 } 2790 /* TM completed */ 2791 ostiInitiatorEvent( tiRoot, 2792 agNULL, /* portalContext not used */ 2793 tiDeviceHandle, 2794 tiIntrEventTypeTaskManagement, 2795 tiTMOK, 2796 pSatDevData->satTmTaskTag); 2797 /* 2798 * Reset flag 2799 */ 2800 pSatDevData->satTmTaskTag = agNULL; 2801 } 2802 2803 /* 2804 * Check if we are in recovery mode and need to update the recovery flag 2805 */ 2806 if ((pSatDevData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) && 2807 (pSatDevData->satPendingIO == 0 )) 2808 { 2809 pSatDevData->satDriveState = SAT_DEV_STATE_NORMAL; 2810 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: STATE NORMAL.\n")); 2811 } 2812 2813 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: satDriveState %d\n", pSatDevData->satDriveState)); 2814 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 2815 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 2816 2817 break; 2818 case OSSA_IO_UNDERFLOW: 2819 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_UNDERFLOW\n")); 2820 ostiInitiatorIOCompleted( tiRoot, 2821 tdIORequestBody->tiIORequest, 2822 tiIOUnderRun, 2823 agIOInfoLen, 2824 agNULL, 2825 interruptContext); 2826 break; 2827 2828 2829 case OSSA_IO_FAILED: 2830 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_FAILED\n")); 2831 ostiInitiatorIOCompleted( tiRoot, 2832 tdIORequestBody->tiIORequest, 2833 tiIOFailed, 2834 tiDetailOtherError, 2835 agNULL, 2836 interruptContext); 2837 break; 2838 2839 case OSSA_IO_ABORT_RESET: 2840 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_ABORT_RESET\n")); 2841 ostiInitiatorIOCompleted( tiRoot, 2842 tdIORequestBody->tiIORequest, 2843 tiIOFailed, 2844 tiDetailAbortReset, 2845 agNULL, 2846 interruptContext); 2847 /* 2848 * Check if we are in recovery mode and need to update the recovery flag 2849 */ 2850 if ((pSatDevData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) && 2851 (pSatDevData->satPendingIO == 0 )) 2852 { 2853 pSatDevData->satDriveState = SAT_DEV_STATE_NORMAL; 2854 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: STATE NORMAL.\n")); 2855 } 2856 2857 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: satDriveState %d\n", pSatDevData->satDriveState)); 2858 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 2859 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 2860 2861 break; 2862 2863 2864 case OSSA_IO_NO_DEVICE: 2865 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_NO_DEVICE\n")); 2866 ostiInitiatorIOCompleted( tiRoot, 2867 tdIORequestBody->tiIORequest, 2868 tiIOFailed, 2869 tiDetailNoLogin, 2870 agNULL, 2871 interruptContext); 2872 break; 2873 2874 case OSSA_IO_PROG_ERROR: 2875 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_PROG_ERROR\n")); 2876 ostiInitiatorIOCompleted( tiRoot, 2877 tdIORequestBody->tiIORequest, 2878 tiIOFailed, 2879 tiDetailOtherError, 2880 agNULL, 2881 interruptContext); 2882 break; 2883 case OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED: /* fall through */ 2884 case OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION: /* fall through */ 2885 case OSSA_IO_OPEN_CNX_ERROR_BREAK: /* fall through */ 2886 case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS: /* fall through */ 2887 case OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION: /* fall through */ 2888 case OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED: /* fall through */ 2889 case OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION: /* fall through */ 2890 case OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR: /* fall through */ 2891 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_OPEN_CNX_ERROR_* 0x%x\n", agIOStatus)); 2892 if (tiDeviceHandle == agNULL) 2893 { 2894 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: wrong, tiDeviceHandle is NULL\n")); 2895 ostiInitiatorIOCompleted( tiRoot, 2896 tdIORequestBody->tiIORequest, 2897 tiIOFailed, 2898 tiDetailOtherError, 2899 agNULL, 2900 interruptContext); 2901 return; 2902 } 2903 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 2904 if (oneDeviceData == agNULL) 2905 { 2906 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL\n")); 2907 } 2908 else 2909 { 2910 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: did %d\n", oneDeviceData->id)); 2911 } 2912 ostiInitiatorIOCompleted( tiRoot, 2913 tdIORequestBody->tiIORequest, 2914 tiIOFailed, 2915 tiDetailOtherError, 2916 agNULL, 2917 interruptContext); 2918 break; 2919 2920 case OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY: 2921 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY\n")); 2922 ostiInitiatorIOCompleted( tiRoot, 2923 tdIORequestBody->tiIORequest, 2924 tiIOFailed, 2925 tiDetailOtherError, //tiDetailNoDeviceError, //tiDetailAborted, 2926 agNULL, 2927 interruptContext); 2928 break; 2929 2930 case OSSA_IO_XFER_ERROR_BREAK: /* fall throuth */ 2931 case OSSA_IO_XFER_ERROR_PHY_NOT_READY: /* fall throuth */ 2932 case OSSA_IO_XFER_ERROR_PEER_ABORTED: /* fall throuth */ 2933 case OSSA_IO_XFER_ERROR_DMA: /* fall throuth */ 2934 case OSSA_IO_XFER_ERROR_SATA_LINK_TIMEOUT: /* fall throuth */ 2935 case OSSA_IO_XFER_ERROR_ABORTED_DUE_TO_SRST: /* fall throuth */ 2936 case OSSA_IO_XFER_ERROR_REJECTED_NCQ_MODE: /* fall throuth */ 2937 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_XFER_ERROR_* 0x%x\n", agIOStatus)); 2938 2939 ostiInitiatorIOCompleted( tiRoot, 2940 tdIORequestBody->tiIORequest, 2941 tiIOFailed, 2942 tiDetailOtherError, 2943 agNULL, 2944 interruptContext); 2945 break; 2946 case OSSA_IO_DS_IN_ERROR: 2947 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_IN_ERROR\n")); 2948 if (tiDeviceHandle == agNULL) 2949 { 2950 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: wrong, tiDeviceHandle is NULL\n")); 2951 ostiInitiatorIOCompleted( tiRoot, 2952 tdIORequestBody->tiIORequest, 2953 tiIOFailed, 2954 tiDetailOtherError, 2955 agNULL, 2956 interruptContext); 2957 return; 2958 } 2959 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 2960 if (oneDeviceData == agNULL) 2961 { 2962 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL\n")); 2963 } 2964 else 2965 { 2966 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: did %d\n", oneDeviceData->id)); 2967 } 2968 ostiInitiatorIOCompleted( tiRoot, 2969 tdIORequestBody->tiIORequest, 2970 tiIOFailed, 2971 tiDetailOtherError, 2972 agNULL, 2973 interruptContext); 2974 break; 2975 case OSSA_IO_DS_NON_OPERATIONAL: 2976 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = OSSA_IO_DS_NON_OPERATIONAL\n")); 2977 if (tiDeviceHandle == agNULL) 2978 { 2979 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: wrong, tiDeviceHandle is NULL\n")); 2980 ostiInitiatorIOCompleted( tiRoot, 2981 tdIORequestBody->tiIORequest, 2982 tiIOFailed, 2983 tiDetailOtherError, 2984 agNULL, 2985 interruptContext); 2986 return; 2987 } 2988 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 2989 if (oneDeviceData == agNULL) 2990 { 2991 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: wrong, oneDeviceData is NULL\n")); 2992 } 2993 else 2994 { 2995 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: did %d\n", oneDeviceData->id)); 2996 agDevHandle = oneDeviceData->agDevHandle; 2997 if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE && 2998 oneDeviceData->tdPortContext != agNULL ) 2999 { 3000 saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData), agDevHandle, SA_DS_OPERATIONAL); 3001 } 3002 } 3003 ostiInitiatorIOCompleted( tiRoot, 3004 tdIORequestBody->tiIORequest, 3005 tiIOFailed, 3006 tiDetailOtherError, 3007 agNULL, 3008 interruptContext); 3009 break; 3010 case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS: /* fall through */ 3011 case OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH: 3012 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = ENCRYPTION ERROR 0x%x\n", agIOStatus)); 3013 itdsatEncryptionHandler(agRoot, 3014 agIORequest, 3015 agIOStatus, 3016 agIOInfoLen, 3017 agParam, 3018 0); 3019 break; 3020 case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH: /* fall through */ 3021 case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH: /* fall through */ 3022 case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH: 3023 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = DIF ERROR 0x%x\n", agIOStatus)); 3024 itdsatDifHandler(agRoot, 3025 agIORequest, 3026 agIOStatus, 3027 agIOInfoLen, 3028 agParam, 3029 0); 3030 break; 3031 default: 3032 TI_DBG1(("itdsatDelayedProcessAbnormalCompletion: agIOStatus = unknown\n")); 3033 ostiInitiatorIOCompleted( tiRoot, 3034 tdIORequestBody->tiIORequest, 3035 tiIOFailed, 3036 tiDetailOtherError, 3037 agNULL, 3038 interruptContext); 3039 break; 3040 3041 } /* switch */ 3042 } 3043 3044 /***************************************************************************** 3045 *! \brief itdsatEncryptionHandler 3046 * 3047 * Purpose: This function processes I/Os completed and returned by SATA lower 3048 * layer with any encryption specific agIOStatus. 3049 * 3050 * \param agRoot: pointer to port instance 3051 * \param agIORequest: pointer to I/O request 3052 * \param agIOStatus: I/O status given by LL layer 3053 * \param agIOInfoLen: lenth of complete SAS RESP frame 3054 * \param agParam A Handle used to refer to the response frame or handle 3055 * of abort request 3056 * \return: None 3057 * 3058 * 3059 *****************************************************************************/ 3060 osGLOBAL void 3061 itdsatEncryptionHandler( 3062 agsaRoot_t *agRoot, 3063 agsaIORequest_t *agIORequest, 3064 bit32 agIOStatus, 3065 bit32 agIOInfoLen, 3066 void *agParam, 3067 bit32 agOtherInfo 3068 ) 3069 { 3070 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 3071 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 3072 bit32 intContext = osData->IntContext; 3073 bit32 errorDetail = tiDetailOtherError; 3074 tdIORequestBody_t *tdIORequestBody; 3075 TI_DBG1(("itdsatEncryptionHandler: start\n")); 3076 TI_DBG1(("itdsatEncryptionHandler: agIOStatus 0x%x\n", agIOStatus)); 3077 3078 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 3079 3080 switch (agIOStatus) 3081 { 3082 case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS: 3083 TI_DBG1(("itdsatEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS\n")); 3084 errorDetail = tiDetailDekKeyCacheMiss; 3085 break; 3086 case OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID: 3087 TI_DBG1(("itdsatEncryptionHandler: OSSA_IO_XFR_ERROR_CIPHER_MODE_INVALID\n")); 3088 errorDetail = tiDetailCipherModeInvalid; 3089 break; 3090 case OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH: 3091 TI_DBG1(("itdsatEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_IV_MISMATCH\n")); 3092 errorDetail = tiDetailDekIVMismatch; 3093 break; 3094 case OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR: 3095 TI_DBG1(("itdsatEncryptionHandler: OSSA_IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR\n")); 3096 errorDetail = tiDetailDekRamInterfaceError; 3097 break; 3098 default: 3099 TI_DBG1(("itdsatEncryptionHandler: other error!!! 0x%x\n", agIOStatus)); 3100 errorDetail = tiDetailOtherError; 3101 break; 3102 } 3103 3104 ostiInitiatorIOCompleted ( 3105 tiRoot, 3106 tdIORequestBody->tiIORequest, 3107 tiIOEncryptError, 3108 errorDetail, 3109 agNULL, 3110 intContext 3111 ); 3112 return; 3113 } 3114 3115 /***************************************************************************** 3116 *! \brief itdsatDifHandler 3117 * 3118 * Purpose: This function processes I/Os completed and returned by SATA lower 3119 * layer with any DIF specific agIOStatus. 3120 * 3121 * \param agRoot: pointer to port instance 3122 * \param agIORequest: pointer to I/O request 3123 * \param agIOStatus: I/O status given by LL layer 3124 * \param agIOInfoLen: lenth of complete SAS RESP frame 3125 * \param agParam A Handle used to refer to the response frame or handle 3126 * of abort request 3127 * \return: None 3128 * 3129 * 3130 *****************************************************************************/ 3131 osGLOBAL void 3132 itdsatDifHandler( 3133 agsaRoot_t *agRoot, 3134 agsaIORequest_t *agIORequest, 3135 bit32 agIOStatus, 3136 bit32 agIOInfoLen, 3137 void *agParam, 3138 bit32 agOtherInfo 3139 ) 3140 { 3141 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 3142 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 3143 bit32 intContext = osData->IntContext; 3144 bit32 errorDetail = tiDetailOtherError; 3145 tdIORequestBody_t *tdIORequestBody; 3146 #ifdef TD_DEBUG_ENABLE 3147 agsaDifDetails_t *DifDetail; 3148 #endif 3149 3150 TI_DBG2(("itdsatDifHandler: start\n")); 3151 TI_DBG2(("itdsatDifHandler: agIOStatus 0x%x\n", agIOStatus)); 3152 3153 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 3154 #ifdef TD_DEBUG_ENABLE 3155 DifDetail = (agsaDifDetails_t *)agParam; 3156 #endif 3157 switch (agIOStatus) 3158 { 3159 case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH: 3160 TI_DBG1(("itdsatDifHandler: OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH\n")); 3161 errorDetail = tiDetailDifAppTagMismatch; 3162 break; 3163 case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH: 3164 TI_DBG1(("itdsatDifHandler: OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH\n")); 3165 errorDetail = tiDetailDifRefTagMismatch; 3166 break; 3167 case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH: 3168 TI_DBG1(("itdsatDifHandler: OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH\n")); 3169 errorDetail = tiDetailDifCrcMismatch; 3170 break; 3171 default: 3172 TI_DBG1(("itdsatDifHandler: other error!!! 0x%x\n", agIOStatus)); 3173 errorDetail = tiDetailOtherError; 3174 break; 3175 } 3176 3177 TI_DBG1(("smsatDifHandler: DIF detail UpperLBA 0x%08x LowerLBA 0x%08x\n", DifDetail->UpperLBA, DifDetail->LowerLBA)); 3178 3179 ostiInitiatorIOCompleted ( 3180 tiRoot, 3181 tdIORequestBody->tiIORequest, 3182 tiIODifError, 3183 errorDetail, 3184 agNULL, 3185 intContext 3186 ); 3187 return; 3188 } 3189 3190 /*****************************************************************************/ 3191 /*! \brief satProcessAbort 3192 * 3193 * This function processes abort. 3194 * 3195 * \param tiRoot: Pointer to TISA initiator driver/port instance. 3196 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 3197 * \param satIOContext_t: Pointer to the SAT IO Context 3198 * 3199 * \return 3200 * None 3201 */ 3202 /*****************************************************************************/ 3203 void satProcessAbort( 3204 tiRoot_t *tiRoot, 3205 tiIORequest_t *tiIORequest, 3206 satIOContext_t *satIOContext 3207 ) 3208 { 3209 satDeviceData_t *pSatDevData; 3210 //tiDeviceHandle_t *tiDeviceHandle; 3211 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 3212 3213 TI_DBG5(("satProcessAbort: start\n")); 3214 3215 pSatDevData = satIOContext->pSatDevData; 3216 //tiDeviceHandle = satIOContext->ptiDeviceHandle; 3217 hostToDevFis = satIOContext->pFis; 3218 if ( (hostToDevFis->h.command == SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE) && 3219 (hostToDevFis->d.lbaLow != 0x01 && hostToDevFis->d.lbaLow != 0x02) 3220 ) 3221 { 3222 /* no completion for send diagnotic in background. It is done in satSendDiagnostic() */ 3223 ostiInitiatorIOCompleted( tiRoot, 3224 tiIORequest, 3225 tiIOFailed, 3226 tiDetailAborted, 3227 agNULL, 3228 satIOContext->interruptContext); 3229 } 3230 3231 if ( pSatDevData->satTmTaskTag != agNULL ) 3232 { 3233 TI_DBG1(("satProcessAbort: TM callback\n")); 3234 /* 3235 * Reset flag 3236 */ 3237 pSatDevData->satTmTaskTag = agNULL; 3238 } 3239 3240 /* 3241 * Check if we are in recovery mode and need to update the recovery flag 3242 */ 3243 if ((pSatDevData->satDriveState == SAT_DEV_STATE_IN_RECOVERY ) && 3244 (pSatDevData->satPendingIO == 0 )) 3245 { 3246 pSatDevData->satDriveState = SAT_DEV_STATE_NORMAL; 3247 TI_DBG1(("satProcessAbort: STATE NORMAL.\n")); 3248 } 3249 TI_DBG1(("satProcessAbort: satDriveState %d\n", pSatDevData->satDriveState)); 3250 TI_DBG1(("satProcessAbort: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 3251 TI_DBG1(("satProcessAbort: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 3252 3253 3254 3255 return; 3256 } 3257 3258 /***************************************************************************** 3259 *! \brief satNonDataIOCB 3260 * 3261 * This routine is a callback function called from ossaSATACompleted(). 3262 * This CB routine deals with non-data I/O SATA request. 3263 * 3264 * \param agRoot: Handles for this instance of SAS/SATA hardware 3265 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 3266 * \param agIOStatus: Status of completed I/O. 3267 * \param agFirstDword:Pointer to the four bytes of FIS. 3268 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 3269 * length. 3270 * \param agParam: Additional info based on status. 3271 * \param ioContext: Pointer to satIOContext_t. 3272 * 3273 * \return: none 3274 * 3275 *****************************************************************************/ 3276 void satNonDataIOCB( 3277 agsaRoot_t *agRoot, 3278 agsaIORequest_t *agIORequest, 3279 bit32 agIOStatus, 3280 agsaFisHeader_t *agFirstDword, 3281 bit32 agIOInfoLen, 3282 void *agParam, 3283 void *ioContext 3284 ) 3285 { 3286 3287 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 3288 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 3289 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3290 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3291 tdIORequestBody_t *tdIORequestBody; 3292 bit32 interruptContext = osData->IntContext; 3293 satIOContext_t *satIOContext; 3294 3295 TI_DBG5(("satNonDataIOCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", 3296 agIORequest, agIOStatus, agIOInfoLen)); 3297 3298 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 3299 satIOContext = (satIOContext_t *) ioContext; 3300 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 3301 3302 tdIORequestBody->ioCompleted = agTRUE; 3303 tdIORequestBody->ioStarted = agFALSE; 3304 3305 /* Process completion */ 3306 if( (agIOStatus == OSSA_IO_SUCCESS) && (agIOInfoLen==0)) 3307 { 3308 /* 3309 * !!! We expect that agIOInfoLen should be non-zero !!!!. 3310 * Now call the OS-App Specific layer about this unexpected completion. 3311 */ 3312 TI_DBG1(("satNonDataIOCB: *** ERROR*** agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", 3313 agIORequest, agIOStatus, agIOInfoLen)); 3314 3315 ostiInitiatorIOCompleted( tiRoot, 3316 tdIORequestBody->tiIORequest, 3317 tiIOFailed, 3318 tiDetailOtherError, 3319 agNULL, 3320 interruptContext); 3321 } 3322 else 3323 { 3324 /* More checking needed, for non-data IO this should be the normal case */ 3325 itdsatProcessAbnormalCompletion( agRoot, 3326 agIORequest, 3327 agIOStatus, 3328 agFirstDword, 3329 agIOInfoLen, 3330 agParam, 3331 satIOContext); 3332 } 3333 3334 } 3335 3336 /***************************************************************************** 3337 *! \brief tdssSATADeviceTypeDecode 3338 * 3339 * This routine decodes ATA signature 3340 * 3341 * \param pSignature: ATA signature 3342 * 3343 * 3344 * \return: 3345 * TRUE if ATA signature 3346 * FALSE otherwise 3347 * 3348 *****************************************************************************/ 3349 /* 3350 ATA p65 3351 PM p65 3352 SATAII p79, p80 3353 */ 3354 GLOBAL bit32 3355 tdssSATADeviceTypeDecode( 3356 bit8 *pSignature 3357 ) 3358 { 3359 bit32 deviceType = UNKNOWN_DEVICE; 3360 3361 if ( (pSignature)[0] == 0x01 && (pSignature)[1] == 0x01 3362 && (pSignature)[2] == 0x00 && (pSignature)[3] == 0x00 3363 && (pSignature)[4] == 0xA0 ) /* this is the signature of a Hitachi SATA HDD*/ 3364 { 3365 deviceType = SATA_ATA_DEVICE; 3366 } 3367 else if ( (pSignature)[0] == 0x01 && (pSignature)[1] == 0x01 3368 && (pSignature)[2] == 0x00 && (pSignature)[3] == 0x00 3369 && (pSignature)[4] == 0x00 ) 3370 { 3371 deviceType = SATA_ATA_DEVICE; 3372 } 3373 else if ( (pSignature)[0] == 0x01 && (pSignature)[1] == 0x01 3374 && (pSignature)[2] == 0x14 && (pSignature)[3] == 0xEB 3375 && ( (pSignature)[4] == 0x00 || (pSignature)[4] == 0x10) ) 3376 { 3377 deviceType = SATA_ATAPI_DEVICE; 3378 } 3379 else if ( (pSignature)[0] == 0x01 && (pSignature)[1] == 0x01 3380 && (pSignature)[2] == 0x69 && (pSignature)[3] == 0x96 3381 && (pSignature)[4] == 0x00 ) 3382 { 3383 deviceType = SATA_PM_DEVICE; 3384 } 3385 else if ( (pSignature)[0] == 0x01 && (pSignature)[1] == 0x01 3386 && (pSignature)[2] == 0x3C && (pSignature)[3] == 0xC3 3387 && (pSignature)[4] == 0x00 ) 3388 { 3389 deviceType = SATA_SEMB_DEVICE; 3390 } 3391 else if ( (pSignature)[0] == 0xFF && (pSignature)[1] == 0xFF 3392 && (pSignature)[2] == 0xFF && (pSignature)[3] == 0xFF 3393 && (pSignature)[4] == 0xFF ) 3394 { 3395 deviceType = SATA_SEMB_WO_SEP_DEVICE; 3396 } 3397 3398 return deviceType; 3399 } 3400 3401 /***************************************************************************** 3402 *! \brief ossaDiscoverSataCB 3403 * 3404 * Purpose: This function is called by lower layer to inform TD layer of 3405 * STP/SATA discovery results 3406 * 3407 * 3408 * \param agRoot Pointer to chip/driver Instance. 3409 * \param agPortContext Pointer to the port context of TD and Lower layer 3410 * \param event event type 3411 * \param pParm1 Pointer to data associated with event 3412 * \param pParm2 Pointer to data associated with event 3413 * 3414 * \return: none 3415 * 3416 * \note - For details, refer to SAS/SATA Low-Level API Specification 3417 * 3418 *****************************************************************************/ 3419 3420 osGLOBAL void ossaDiscoverSataCB( agsaRoot_t *agRoot, 3421 agsaPortContext_t *agPortContext, 3422 bit32 event, 3423 void *pParm1, 3424 void *pParm2 3425 ) 3426 { 3427 tdsaRootOsData_t *osData; 3428 tiRoot_t *tiRoot; 3429 tdsaPortContext_t *onePortContext; 3430 tdsaDeviceData_t *oneDeviceData; 3431 agsaDevHandle_t *agDevHandle; 3432 agsaSATADeviceInfo_t *agSATADeviceInfo; 3433 tiPortalContext_t *tiPortalContext; 3434 3435 bit32 devicetype = UNKNOWN_DEVICE; 3436 3437 osData = (tdsaRootOsData_t *)agRoot->osData; 3438 tiRoot = (tiRoot_t *)osData->tiRoot; 3439 3440 TI_DBG5(("ossaDiscoverSataCB: start\n")); 3441 3442 if (agPortContext == agNULL) 3443 { 3444 TI_DBG1(("ossaDiscoverSataCB: NULL agsaPortContext; wrong\n")); 3445 return; 3446 } 3447 3448 onePortContext = (tdsaPortContext_t *)agPortContext->osData; 3449 tiPortalContext = (tiPortalContext_t *)onePortContext->tiPortalContext; 3450 3451 switch ( event ) 3452 { 3453 case OSSA_DISCOVER_STARTED: 3454 { 3455 TI_DBG5(("ossaDiscoverSataCB: STARTED\n")); 3456 /* Do nothing */ 3457 break; 3458 } 3459 3460 case OSSA_DISCOVER_FOUND_DEVICE: 3461 { 3462 TI_DBG5(("ossaDiscoverSataCB: ***** FOUND DEVICE\n")); 3463 agDevHandle = (agsaDevHandle_t *) pParm1; 3464 agSATADeviceInfo = (agsaSATADeviceInfo_t *) pParm2; 3465 3466 /* parse the device type */ 3467 devicetype = tdssSATADeviceTypeDecode(agSATADeviceInfo->signature); 3468 3469 3470 /* for now, TD handles only ATA Device or ATAPI Device */ 3471 if (devicetype == SATA_ATA_DEVICE || devicetype == SATA_ATAPI_DEVICE) 3472 { 3473 TI_DBG5(("ossaDiscoverSataCB: ***** adding ....\n")); 3474 /* Add SATA device */ 3475 tdssAddSATAToSharedcontext( onePortContext, 3476 agRoot, 3477 agDevHandle, 3478 agSATADeviceInfo, 3479 agTRUE, 3480 agSATADeviceInfo->stpPhyIdentifier 3481 ); 3482 #ifdef INITIATOR_DRIVER 3483 ostiInitiatorEvent( 3484 tiRoot, 3485 tiPortalContext, 3486 agNULL, 3487 tiIntrEventTypeDeviceChange, 3488 tiDeviceArrival, 3489 agNULL 3490 ); 3491 #endif 3492 } /* end of ATA_ATA_DEVICE or ATA_ATAPI_DEVICE */ 3493 else 3494 { 3495 TI_DBG5(("ossaDiscoverSataCB: ***** not adding ..... devicetype 0x%x\n", devicetype)); 3496 } 3497 break; 3498 } 3499 3500 case OSSA_DISCOVER_REMOVED_DEVICE: 3501 { 3502 TI_DBG1(("ossaDiscoverSataCB: REMOVED_DEVICE\n")); 3503 agDevHandle = (agsaDevHandle_t *) pParm1; 3504 agSATADeviceInfo = (agsaSATADeviceInfo_t *) pParm2; 3505 3506 oneDeviceData = (tdsaDeviceData_t *) agDevHandle->osData; 3507 3508 TI_DBG1(("ossaDiscoverSataCB: signature: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", 3509 agSATADeviceInfo->signature[0], agSATADeviceInfo->signature[1], 3510 agSATADeviceInfo->signature[2], agSATADeviceInfo->signature[3], 3511 agSATADeviceInfo->signature[4], agSATADeviceInfo->signature[5], 3512 agSATADeviceInfo->signature[6], agSATADeviceInfo->signature[7] )); 3513 3514 if (oneDeviceData == agNULL) 3515 { 3516 TI_DBG1(("ossaDiscoverSataCB: Wrong. DevHandle->osData is NULL but is being removed\n")); 3517 } 3518 tdssRemoveSATAFromSharedcontext( onePortContext, 3519 oneDeviceData, 3520 agRoot 3521 ); 3522 agDevHandle->osData = agNULL; 3523 #ifdef INITIATOR_DRIVER 3524 ostiInitiatorEvent( 3525 tiRoot, 3526 tiPortalContext, 3527 agNULL, 3528 tiIntrEventTypeDeviceChange, 3529 tiDeviceRemoval, 3530 agNULL 3531 ); 3532 #endif 3533 break; 3534 } 3535 3536 case OSSA_DISCOVER_COMPLETE: 3537 { 3538 TI_DBG1(("ossaDiscoverSataCB: COMPLETE\n")); 3539 onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED; 3540 TI_DBG6(("ossaDiscoverSataCB: COMPLETE pid %d\n", onePortContext->id)); 3541 3542 /* Let OS-Apps specific layer know discovery has been successfully complete */ 3543 ostiInitiatorEvent( tiRoot, 3544 tiPortalContext, 3545 agNULL, 3546 tiIntrEventTypeDiscovery, 3547 tiDiscOK, 3548 agNULL ); 3549 break; 3550 } 3551 3552 case OSSA_DISCOVER_ABORT: 3553 { 3554 TI_DBG1(("ossaDiscoverSataCB: OSSA_DISCOVER_ABORT\n")); 3555 /* Let OS-Apps specific layer know discovery has failed */ 3556 ostiInitiatorEvent( tiRoot, 3557 tiPortalContext, 3558 agNULL, 3559 tiIntrEventTypeDiscovery, 3560 tiDiscFailed, 3561 agNULL ); 3562 3563 break; 3564 } 3565 3566 default: 3567 { 3568 TI_DBG1(("ossaDiscoverSataCB: error default event 0x%x\n", event)); 3569 /* Let OS-Apps specific layer know discovery has failed */ 3570 ostiInitiatorEvent( tiRoot, 3571 tiPortalContext, 3572 agNULL, 3573 tiIntrEventTypeDiscovery, 3574 tiDiscFailed, 3575 agNULL ); 3576 break; 3577 } 3578 3579 } /* end of switch */ 3580 3581 return; 3582 } 3583 3584 /***************************************************************************** 3585 *! \brief tdssAddSataToSharedcontext 3586 * 3587 * Purpose: This function adds a discovered SATA device to a device list of 3588 * a port context 3589 * 3590 * \param tsddPortContext_Instance Pointer to the target port context 3591 * \param agRoot Pointer to the root data structure of 3592 * TD and Lower layer 3593 * \param agDevHandle Pointer to a device handle 3594 * \param agSATADeviceInfo Pointer to SATA device info structure 3595 * \param registered indication flag for registration to LL 3596 * 3597 * \Return: none 3598 * 3599 *****************************************************************************/ 3600 /* split into devicedata allocation/registration and sending identify device data */ 3601 osGLOBAL void 3602 tdssAddSATAToSharedcontext( tdsaPortContext_t *tdsaPortContext_Instance, 3603 agsaRoot_t *agRoot, 3604 agsaDevHandle_t *agDevHandle, 3605 agsaSATADeviceInfo_t *agSATADeviceInfo, 3606 bit32 registered, 3607 bit8 phyID 3608 ) 3609 { 3610 tdsaPortContext_t *onePortContext = agNULL; 3611 tdList_t *PortContextList; 3612 tdsaDeviceData_t *oneDeviceData = agNULL; 3613 tdList_t *DeviceListList = agNULL; 3614 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 3615 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 3616 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3617 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3618 satDeviceData_t *pSatDevData; 3619 bit32 Indenom = tdsaAllShared->QueueConfig.numInboundQueues; 3620 bit32 Outdenom = tdsaAllShared->QueueConfig.numOutboundQueues; 3621 bit8 dev_s_rate = 0; 3622 bit8 sasorsata = 1; 3623 bit8 connectionRate; 3624 bit8 flag = 0; 3625 bit8 TLR = 0; 3626 bit32 found = agFALSE; 3627 TI_DBG5(("tdssAddSataToSharedcontext: start\n")); 3628 3629 /* 3630 * Find a right portcontext, then get devicedata from FreeLink in DeviceList. 3631 * Then, add the devicedata to the portcontext. 3632 */ 3633 3634 /* Find a right portcontext */ 3635 PortContextList = tdsaAllShared->MainPortContextList.flink; 3636 while (PortContextList != &(tdsaAllShared->MainPortContextList)) 3637 { 3638 onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList); 3639 if (onePortContext == tdsaPortContext_Instance) 3640 { 3641 TI_DBG5(("tdssAddSataToSharedcontext: found; oneportContext ID %d\n", 3642 onePortContext->id)); 3643 found = agTRUE; 3644 break; 3645 } 3646 PortContextList = PortContextList->flink; 3647 } 3648 3649 if (found == agFALSE) 3650 { 3651 TI_DBG1(("tdssAddSataToSharedcontext: No corressponding tdsaPortContext\n")); 3652 return; 3653 } 3654 3655 /* 3656 1. add the devicedata 3657 2. Send Identify Device Data 3658 3. In CB of Identify Device Data (satAddSATAIDDevCB), finds out the devicedata is new or old 3659 */ 3660 3661 3662 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 3663 if (!TDLIST_NOT_EMPTY(&(tdsaAllShared->FreeDeviceList))) 3664 { 3665 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 3666 TI_DBG1(("tdssAddSataToSharedcontext: ERROR empty DeviceData FreeLink\n")); 3667 /* notifying link up */ 3668 ostiPortEvent ( 3669 tiRoot, 3670 tiPortLinkUp, 3671 tiSuccess, 3672 (void *)tdsaAllShared->Ports[phyID].tiPortalContext 3673 ); 3674 #ifdef INITIATOR_DRIVER 3675 /* triggers discovery */ 3676 ostiPortEvent( 3677 tiRoot, 3678 tiPortDiscoveryReady, 3679 tiSuccess, 3680 (void *) tdsaAllShared->Ports[phyID].tiPortalContext 3681 ); 3682 #endif 3683 return; 3684 } 3685 3686 TDLIST_DEQUEUE_FROM_HEAD(&DeviceListList, &(tdsaAllShared->FreeDeviceList)); 3687 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 3688 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, FreeLink, DeviceListList); 3689 TDLIST_DEQUEUE_THIS(&(oneDeviceData->FreeLink)); 3690 3691 TI_DBG1(("tdssAddSataToSharedcontext: oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id)); 3692 oneDeviceData->InQID = oneDeviceData->id % Indenom; 3693 oneDeviceData->OutQID = oneDeviceData->id % Outdenom; 3694 3695 pSatDevData = (satDeviceData_t *)&(oneDeviceData->satDevData); 3696 pSatDevData->satDriveState = SAT_DEV_STATE_NORMAL; 3697 pSatDevData->satPendingIO = 0; 3698 pSatDevData->satNCQMaxIO = 0; 3699 pSatDevData->satPendingNCQIO = 0; 3700 pSatDevData->satPendingNONNCQIO = 0; 3701 pSatDevData->IDDeviceValid = agFALSE; 3702 pSatDevData->satDeviceType = tdssSATADeviceTypeDecode(onePortContext->remoteSignature); 3703 3704 osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t)); 3705 3706 onePortContext->Count++; 3707 oneDeviceData->DeviceType = TD_SATA_DEVICE; // either TD_SAS_DEVICE or TD_SATA_DEVICE 3708 oneDeviceData->agRoot = agRoot; 3709 // oneDeviceData->agDevHandle = agDevHandle; 3710 3711 // agDevHandle->osData = oneDeviceData; /* TD layer */ 3712 oneDeviceData->tdPortContext = onePortContext; 3713 oneDeviceData->valid = agTRUE; 3714 3715 oneDeviceData->directlyAttached = agTRUE; 3716 oneDeviceData->initiator_ssp_stp_smp = 0; 3717 oneDeviceData->target_ssp_stp_smp = 0x1; /* setting SATA device bit */ 3718 oneDeviceData->phyID = phyID; 3719 3720 /* parse sasIDframe to fill in agDeviceInfo */ 3721 flag = (bit8)((phyID << 4) | TLR); 3722 DEVINFO_PUT_SMPTO(&oneDeviceData->agDeviceInfo, DEFAULT_SMP_TIMEOUT); 3723 DEVINFO_PUT_ITNEXUSTO(&oneDeviceData->agDeviceInfo, (bit16)tdsaAllShared->itNexusTimeout); 3724 DEVINFO_PUT_FBS(&oneDeviceData->agDeviceInfo, 0); 3725 //temp 3726 //DEVINFO_PUT_FLAG(&oneDeviceData->agDeviceInfo, 0); 3727 DEVINFO_PUT_FLAG(&oneDeviceData->agDeviceInfo, flag); 3728 3729 sasorsata = SATA_DEVICE_TYPE; /* SATA disk */ 3730 connectionRate = onePortContext->LinkRate; 3731 dev_s_rate = (bit8)(dev_s_rate | (sasorsata << 4)); 3732 dev_s_rate = (bit8)(dev_s_rate | connectionRate); 3733 DEVINFO_PUT_DEV_S_RATE(&oneDeviceData->agDeviceInfo, dev_s_rate); 3734 3735 DEVINFO_PUT_SAS_ADDRESSLO( 3736 &oneDeviceData->agDeviceInfo, 3737 0 3738 ); 3739 DEVINFO_PUT_SAS_ADDRESSHI( 3740 &oneDeviceData->agDeviceInfo, 3741 0 3742 ); 3743 3744 if (pSatDevData->satDeviceType == SATA_ATAPI_DEVICE ) 3745 { 3746 oneDeviceData->agDeviceInfo.flag |= ATAPI_DEVICE_FLAG; /* ATAPI device flag*/ 3747 } 3748 3749 oneDeviceData->agContext.osData = oneDeviceData; 3750 oneDeviceData->agContext.sdkData = agNULL; 3751 3752 if (oneDeviceData->registered == agFALSE) 3753 { 3754 saRegisterNewDevice( /* tdssAddSATAToSharedcontext */ 3755 agRoot, 3756 &oneDeviceData->agContext, 3757 0,/*tdsaRotateQnumber(tiRoot, oneDeviceData),*/ 3758 &oneDeviceData->agDeviceInfo, 3759 onePortContext->agPortContext, 3760 0 3761 ); 3762 } 3763 return; 3764 } 3765 /***************************************************************************** 3766 *! \brief tdssRetrySATAID 3767 * 3768 * Purpose: This function retries identify device data to directly attached SATA 3769 * device after device registration 3770 * 3771 * \param tiRoot: Pointer to TISA initiator driver/port instance. 3772 * \param oneDeviceData Pointer to a device data 3773 * \Return: none 3774 * 3775 *****************************************************************************/ 3776 osGLOBAL void 3777 tdssRetrySATAID( tiRoot_t *tiRoot, 3778 tdsaDeviceData_t *oneDeviceData 3779 ) 3780 { 3781 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3782 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3783 void *osMemHandle; 3784 tdIORequestBody_t *tdIORequestBody; 3785 bit32 PhysUpper32; 3786 bit32 PhysLower32; 3787 bit32 memAllocStatus; 3788 agsaIORequest_t *agIORequest = agNULL; /* identify device data itself */ 3789 satIOContext_t *satIOContext = agNULL; 3790 bit32 status; 3791 3792 TI_DBG5(("tdssRetrySATAID: start\n")); 3793 /* allocate identify device data and sends it */ 3794 /* allocation tdIORequestBody and pass it to satTM() */ 3795 memAllocStatus = ostiAllocMemory( 3796 tiRoot, 3797 &osMemHandle, 3798 (void **)&tdIORequestBody, 3799 &PhysUpper32, 3800 &PhysLower32, 3801 8, 3802 sizeof(tdIORequestBody_t), 3803 agTRUE 3804 ); 3805 3806 if (memAllocStatus != tiSuccess) 3807 { 3808 TI_DBG1(("tdssRetrySATAID: ostiAllocMemory failed... loc 2\n")); 3809 /* notifying link up */ 3810 ostiPortEvent ( 3811 tiRoot, 3812 tiPortLinkUp, 3813 tiSuccess, 3814 (void *)tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 3815 ); 3816 #ifdef INITIATOR_DRIVER 3817 /* triggers discovery */ 3818 ostiPortEvent( 3819 tiRoot, 3820 tiPortDiscoveryReady, 3821 tiSuccess, 3822 (void *) tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 3823 ); 3824 #endif 3825 3826 return; 3827 } 3828 3829 if (tdIORequestBody == agNULL) 3830 { 3831 TI_DBG1(("tdssRetrySATAID: ostiAllocMemory returned NULL tdIORequestBody loc 2\n")); 3832 /* notifying link up */ 3833 ostiPortEvent ( 3834 tiRoot, 3835 tiPortLinkUp, 3836 tiSuccess, 3837 (void *)tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 3838 ); 3839 #ifdef INITIATOR_DRIVER 3840 /* triggers discovery */ 3841 ostiPortEvent( 3842 tiRoot, 3843 tiPortDiscoveryReady, 3844 tiSuccess, 3845 (void *) tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 3846 ); 3847 #endif 3848 3849 return; 3850 } 3851 3852 /* setup identify device data IO structure */ 3853 tdIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 3854 tdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag = agNULL; 3855 tdIORequestBody->IOType.InitiatorTMIO.TaskTag = agNULL; 3856 3857 /* initialize tiDevhandle */ 3858 tdIORequestBody->tiDevHandle = &(oneDeviceData->tiDeviceHandle); 3859 tdIORequestBody->tiDevHandle->tdData = oneDeviceData; 3860 3861 /* initialize tiIORequest */ 3862 tdIORequestBody->tiIORequest = agNULL; 3863 3864 /* initialize agIORequest */ 3865 agIORequest = &(tdIORequestBody->agIORequest); 3866 agIORequest->osData = (void *) tdIORequestBody; 3867 agIORequest->sdkData = agNULL; /* SA takes care of this */ 3868 3869 /* set up satIOContext */ 3870 satIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 3871 satIOContext->pSatDevData = &(oneDeviceData->satDevData); 3872 satIOContext->pFis = 3873 &(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 3874 3875 3876 satIOContext->tiRequestBody = tdIORequestBody; 3877 satIOContext->ptiDeviceHandle = &(oneDeviceData->tiDeviceHandle); 3878 satIOContext->tiScsiXchg = agNULL; 3879 satIOContext->satIntIoContext = agNULL; 3880 satIOContext->satOrgIOContext = agNULL; 3881 3882 /* followings are used only for internal IO */ 3883 satIOContext->currentLBA = 0; 3884 satIOContext->OrgTL = 0; 3885 3886 3887 satIOContext->satToBeAbortedIOContext = agNULL; 3888 3889 satIOContext->NotifyOS = agFALSE; 3890 3891 satIOContext->pid = tdsaAllShared->Ports[oneDeviceData->phyID].portContext->id; 3892 3893 status = satAddSATAStartIDDev(tiRoot, 3894 agNULL, 3895 &(oneDeviceData->tiDeviceHandle), 3896 agNULL, 3897 satIOContext 3898 ); 3899 3900 /* assumption; always new device data */ 3901 3902 3903 if (status == tiSuccess) 3904 { 3905 TI_DBG6(("tdssRetrySATAID: successfully sent identify device data\n")); 3906 TI_DBG6(("tdssRetrySATAID: one case did %d \n", oneDeviceData->id)); 3907 } 3908 else 3909 { 3910 TI_DBG1(("tdssRetrySATAID: failed in sending identify device data\n")); 3911 /* put onedevicedata back to free list */ 3912 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 3913 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList)); 3914 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 3915 /* notifying link up */ 3916 ostiPortEvent ( 3917 tiRoot, 3918 tiPortLinkUp, 3919 tiSuccess, 3920 (void *)tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 3921 ); 3922 #ifdef INITIATOR_DRIVER 3923 /* triggers discovery */ 3924 ostiPortEvent( 3925 tiRoot, 3926 tiPortDiscoveryReady, 3927 tiSuccess, 3928 (void *) tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 3929 ); 3930 #endif 3931 3932 } 3933 3934 return; 3935 } 3936 3937 /***************************************************************************** 3938 *! \brief tdssSubAddSATAToSharedcontext 3939 * 3940 * Purpose: This function sends identify device data to directly attached SATA 3941 * device after device registration 3942 * 3943 * \param tiRoot: Pointer to TISA initiator driver/port instance. 3944 * \param oneDeviceData Pointer to a device data 3945 * \Return: none 3946 * 3947 *****************************************************************************/ 3948 osGLOBAL void 3949 tdssSubAddSATAToSharedcontext( tiRoot_t *tiRoot, 3950 tdsaDeviceData_t *oneDeviceData 3951 ) 3952 { 3953 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3954 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3955 void *osMemHandle; 3956 tdIORequestBody_t *tdIORequestBody; 3957 bit32 PhysUpper32; 3958 bit32 PhysLower32; 3959 bit32 memAllocStatus; 3960 agsaIORequest_t *agIORequest = agNULL; /* identify device data itself */ 3961 satIOContext_t *satIOContext = agNULL; 3962 bit32 status; 3963 3964 TI_DBG1(("tdssSubAddSATAToSharedcontext: start\n")); 3965 /* allocate identify device data and sends it */ 3966 /* allocation tdIORequestBody and pass it to satTM() */ 3967 memAllocStatus = ostiAllocMemory( 3968 tiRoot, 3969 &osMemHandle, 3970 (void **)&tdIORequestBody, 3971 &PhysUpper32, 3972 &PhysLower32, 3973 8, 3974 sizeof(tdIORequestBody_t), 3975 agTRUE 3976 ); 3977 3978 if (memAllocStatus != tiSuccess) 3979 { 3980 TI_DBG1(("tdssSubAddSATAToSharedcontext: ostiAllocMemory failed... loc 2\n")); 3981 /* notifying link up */ 3982 ostiPortEvent ( 3983 tiRoot, 3984 tiPortLinkUp, 3985 tiSuccess, 3986 (void *)tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 3987 ); 3988 #ifdef INITIATOR_DRIVER 3989 /* triggers discovery */ 3990 ostiPortEvent( 3991 tiRoot, 3992 tiPortDiscoveryReady, 3993 tiSuccess, 3994 (void *) tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 3995 ); 3996 #endif 3997 3998 return; 3999 } 4000 4001 if (tdIORequestBody == agNULL) 4002 { 4003 TI_DBG1(("tdssSubAddSATAToSharedcontext: ostiAllocMemory returned NULL tdIORequestBody loc 2\n")); 4004 /* notifying link up */ 4005 ostiPortEvent ( 4006 tiRoot, 4007 tiPortLinkUp, 4008 tiSuccess, 4009 (void *)tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 4010 ); 4011 #ifdef INITIATOR_DRIVER 4012 /* triggers discovery */ 4013 ostiPortEvent( 4014 tiRoot, 4015 tiPortDiscoveryReady, 4016 tiSuccess, 4017 (void *) tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 4018 ); 4019 #endif 4020 4021 return; 4022 } 4023 4024 /* setup identify device data IO structure */ 4025 tdIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 4026 tdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag = agNULL; 4027 tdIORequestBody->IOType.InitiatorTMIO.TaskTag = agNULL; 4028 4029 /* initialize tiDevhandle */ 4030 tdIORequestBody->tiDevHandle = &(oneDeviceData->tiDeviceHandle); 4031 tdIORequestBody->tiDevHandle->tdData = oneDeviceData; 4032 4033 /* initialize tiIORequest */ 4034 tdIORequestBody->tiIORequest = agNULL; 4035 4036 /* initialize agIORequest */ 4037 agIORequest = &(tdIORequestBody->agIORequest); 4038 agIORequest->osData = (void *) tdIORequestBody; 4039 agIORequest->sdkData = agNULL; /* SA takes care of this */ 4040 4041 /* set up satIOContext */ 4042 satIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 4043 satIOContext->pSatDevData = &(oneDeviceData->satDevData); 4044 satIOContext->pFis = 4045 &(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 4046 4047 4048 satIOContext->tiRequestBody = tdIORequestBody; 4049 satIOContext->ptiDeviceHandle = &(oneDeviceData->tiDeviceHandle); 4050 satIOContext->tiScsiXchg = agNULL; 4051 satIOContext->satIntIoContext = agNULL; 4052 satIOContext->satOrgIOContext = agNULL; 4053 4054 /* followings are used only for internal IO */ 4055 satIOContext->currentLBA = 0; 4056 satIOContext->OrgTL = 0; 4057 4058 4059 satIOContext->satToBeAbortedIOContext = agNULL; 4060 4061 satIOContext->NotifyOS = agFALSE; 4062 4063 satIOContext->pid = tdsaAllShared->Ports[oneDeviceData->phyID].portContext->id; 4064 4065 status = satAddSATAStartIDDev(tiRoot, 4066 agNULL, 4067 &(oneDeviceData->tiDeviceHandle), 4068 agNULL, 4069 satIOContext 4070 ); 4071 4072 /* assumption; always new device data */ 4073 4074 4075 if (status == tiSuccess) 4076 { 4077 TI_DBG6(("tdssSubAddSATAToSharedcontext: successfully sent identify device data\n")); 4078 4079 /* Add the devicedata to the mainlink */ 4080 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 4081 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->MainLink), &(tdsaAllShared->MainDeviceList)); 4082 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 4083 TI_DBG6(("tdssSubAddSATAToSharedcontext: one case did %d \n", oneDeviceData->id)); 4084 } 4085 else 4086 { 4087 TI_DBG1(("tdssSubAddSATAToSharedcontext: failed in sending identify device data\n")); 4088 /* put onedevicedata back to free list */ 4089 tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK); 4090 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList)); 4091 tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK); 4092 /* notifying link up */ 4093 ostiPortEvent ( 4094 tiRoot, 4095 tiPortLinkUp, 4096 tiSuccess, 4097 (void *)tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 4098 ); 4099 #ifdef INITIATOR_DRIVER 4100 /* triggers discovery */ 4101 ostiPortEvent( 4102 tiRoot, 4103 tiPortDiscoveryReady, 4104 tiSuccess, 4105 (void *) tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext 4106 ); 4107 #endif 4108 4109 } 4110 4111 return; 4112 } 4113 4114 4115 /***************************************************************************** 4116 *! \brief tdssRemoveSATAFromSharedcontext 4117 * 4118 * Purpose: This function removes a discovered device from a device list of 4119 * a port context 4120 * 4121 * \param tsddPortContext_Ins Pointer to the target port context 4122 * \param tdsaDeviceData_Ins Pointer to the target device 4123 * \param agRoot Pointer to the root data structure of 4124 * TD and Lower layer 4125 4126 * 4127 * \Return: none 4128 * 4129 *****************************************************************************/ 4130 osGLOBAL void 4131 tdssRemoveSATAFromSharedcontext( 4132 tdsaPortContext_t *tdsaPortContext_Ins, 4133 tdsaDeviceData_t *tdsaDeviceData_ins, 4134 agsaRoot_t *agRoot 4135 ) 4136 { 4137 TI_DBG1(("tdssRemoveSATAFromSharedcontex: start\n")); 4138 return; 4139 } 4140 4141 4142 /***************************************************************************** 4143 *! \brief satSetDevInfo 4144 * 4145 * Purpose: Based on ATA identify device data, this functions sets fields of 4146 * device data maintained in TD layer 4147 * 4148 * \param satDevData Pointer to a device data 4149 * \param SATAIdData Pointer to ATA identify device data 4150 * 4151 * 4152 * \Return: none 4153 * 4154 *****************************************************************************/ 4155 void satSetDevInfo( 4156 satDeviceData_t *satDevData, 4157 agsaSATAIdentifyData_t *SATAIdData 4158 ) 4159 { 4160 TI_DBG3(("satSetDevInfo: start\n")); 4161 4162 satDevData->satDriveState = SAT_DEV_STATE_NORMAL; 4163 satDevData->satFormatState = agFALSE; 4164 satDevData->satDeviceFaultState = agFALSE; 4165 satDevData->satTmTaskTag = agNULL; 4166 satDevData->satAbortAfterReset = agFALSE; 4167 satDevData->satAbortCalled = agFALSE; 4168 satDevData->satSectorDone = 0; 4169 4170 /* Qeueu depth, Word 75 */ 4171 satDevData->satNCQMaxIO = SATAIdData->queueDepth + 1; 4172 TI_DBG3(("satSetDevInfo: max queue depth %d\n",satDevData->satNCQMaxIO)); 4173 4174 /* Support NCQ, if Word 76 bit 8 is set */ 4175 if (SATAIdData->sataCapabilities & 0x100) 4176 { 4177 TI_DBG3(("satSetDevInfo: device supports NCQ\n")); 4178 satDevData->satNCQ = agTRUE; 4179 } 4180 else 4181 { 4182 TI_DBG3(("satSetDevInfo: no NCQ\n")); 4183 satDevData->satNCQ = agFALSE; 4184 } 4185 4186 /* Support 48 bit addressing, if Word 83 bit 10 and Word 86 bit 10 are set */ 4187 if ((SATAIdData->commandSetSupported1 & 0x400) && 4188 (SATAIdData->commandSetFeatureEnabled1 & 0x400) ) 4189 { 4190 TI_DBG3(("satSetDevInfo: support 48 bit addressing\n")); 4191 satDevData->sat48BitSupport = agTRUE; 4192 } 4193 else 4194 { 4195 TI_DBG3(("satSetDevInfo: NO 48 bit addressing\n")); 4196 satDevData->sat48BitSupport = agFALSE; 4197 } 4198 4199 /* Support SMART Self Test, word84 bit 1 */ 4200 if (SATAIdData->commandSetFeatureSupportedExt & 0x02) 4201 { 4202 TI_DBG3(("satSetDevInfo: SMART self-test supported \n")); 4203 satDevData->satSMARTSelfTest = agTRUE; 4204 } 4205 else 4206 { 4207 TI_DBG3(("satSetDevInfo: no SMART self-test suppored\n")); 4208 satDevData->satSMARTSelfTest = agFALSE; 4209 } 4210 4211 4212 4213 /* Support SMART feature set, word82 bit 0 */ 4214 if (SATAIdData->commandSetSupported & 0x01) 4215 { 4216 TI_DBG3(("satSetDevInfo: SMART feature set supported \n")); 4217 satDevData->satSMARTFeatureSet = agTRUE; 4218 } 4219 else 4220 { 4221 TI_DBG3(("satSetDevInfo: no SMART feature set suppored\n")); 4222 satDevData->satSMARTFeatureSet = agFALSE; 4223 } 4224 4225 4226 4227 /* Support SMART enabled, word85 bit 0 */ 4228 if (SATAIdData->commandSetFeatureEnabled & 0x01) 4229 { 4230 TI_DBG3(("satSetDevInfo: SMART enabled \n")); 4231 satDevData->satSMARTEnabled = agTRUE; 4232 } 4233 else 4234 { 4235 TI_DBG3(("satSetDevInfo: no SMART enabled\n")); 4236 satDevData->satSMARTEnabled = agFALSE; 4237 } 4238 4239 satDevData->satVerifyState = 0; 4240 4241 /* Removable Media feature set support, word82 bit 2 */ 4242 if (SATAIdData->commandSetSupported & 0x4) 4243 { 4244 TI_DBG3(("satSetDevInfo: Removable Media supported \n")); 4245 satDevData->satRemovableMedia = agTRUE; 4246 } 4247 else 4248 { 4249 TI_DBG3(("satSetDevInfo: no Removable Media suppored\n")); 4250 satDevData->satRemovableMedia = agFALSE; 4251 } 4252 4253 /* Removable Media feature set enabled, word 85, bit 2 */ 4254 if (SATAIdData->commandSetFeatureEnabled & 0x4) 4255 { 4256 TI_DBG3(("satSetDevInfo: Removable Media enabled\n")); 4257 satDevData->satRemovableMediaEnabled = agTRUE; 4258 } 4259 else 4260 { 4261 TI_DBG3(("satSetDevInfo: no Removable Media enabled\n")); 4262 satDevData->satRemovableMediaEnabled = agFALSE; 4263 } 4264 4265 /* DMA Support, word49 bit8 */ 4266 if (SATAIdData->dma_lba_iod_ios_stimer & 0x100) 4267 { 4268 TI_DBG3(("satSetDevInfo: DMA supported \n")); 4269 satDevData->satDMASupport = agTRUE; 4270 } 4271 else 4272 { 4273 TI_DBG3(("satSetDevInfo: no DMA suppored\n")); 4274 satDevData->satDMASupport = agFALSE; 4275 } 4276 4277 /* DMA Enabled, word88 bit0-6, bit8-14*/ 4278 /* 0x7F7F = 0111 1111 0111 1111*/ 4279 if (SATAIdData->ultraDMAModes & 0x7F7F) 4280 { 4281 TI_DBG3(("satSetDevInfo: DMA enabled \n")); 4282 satDevData->satDMAEnabled = agTRUE; 4283 } 4284 else 4285 { 4286 TI_DBG3(("satSetDevInfo: no DMA enabled\n")); 4287 satDevData->satDMAEnabled = agFALSE; 4288 } 4289 4290 /* 4291 setting MaxUserAddrSectors: max user addressable setctors 4292 word60 - 61, should be 0x 0F FF FF FF 4293 */ 4294 satDevData->satMaxUserAddrSectors 4295 = (SATAIdData->numOfUserAddressableSectorsHi << (8*2) ) 4296 + SATAIdData->numOfUserAddressableSectorsLo; 4297 TI_DBG3(("satSetDevInfo: MaxUserAddrSectors 0x%x decimal %d\n", satDevData->satMaxUserAddrSectors, satDevData->satMaxUserAddrSectors)); 4298 /* Support DMADIR, if Word 62 bit 8 is set */ 4299 if (SATAIdData->word62_74[0] & 0x8000) 4300 { 4301 TI_DBG3(("satSetDevInfo: DMADIR enabled\n")); 4302 satDevData->satDMADIRSupport = agTRUE; 4303 } 4304 else 4305 { 4306 TI_DBG3(("satSetDevInfo: DMADIR disabled\n")); 4307 satDevData->satDMADIRSupport = agFALSE; 4308 } 4309 4310 4311 /* write cache enabled for caching mode page SAT Table 67 p69, word85 bit5 */ 4312 if (SATAIdData->commandSetFeatureEnabled & 0x20) 4313 { 4314 TI_DBG3(("satSetDevInfo: write cache enabled\n")); 4315 satDevData->satWriteCacheEnabled = agTRUE; 4316 } 4317 else 4318 { 4319 TI_DBG3(("satSetDevInfo: no write cache enabled\n")); 4320 satDevData->satWriteCacheEnabled = agFALSE; 4321 } 4322 4323 /* look ahead enabled for caching mode page SAT Table 67 p69, word85 bit6 */ 4324 if (SATAIdData->commandSetFeatureEnabled & 0x40) 4325 { 4326 TI_DBG3(("satSetDevInfo: look ahead enabled\n")); 4327 satDevData->satLookAheadEnabled = agTRUE; 4328 } 4329 else 4330 { 4331 TI_DBG3(("satSetDevInfo: no look ahead enabled\n")); 4332 satDevData->satLookAheadEnabled = agFALSE; 4333 } 4334 4335 /* Support WWN, if Word 87 bit 8 is set */ 4336 if (SATAIdData->commandSetFeatureDefault & 0x100) 4337 { 4338 TI_DBG3(("satSetDevInfo: device supports WWN\n")); 4339 satDevData->satWWNSupport = agTRUE; 4340 } 4341 else 4342 { 4343 TI_DBG3(("satSetDevInfo: no WWN\n")); 4344 satDevData->satWWNSupport = agFALSE; 4345 } 4346 4347 4348 return; 4349 } 4350 4351 /***************************************************************************** 4352 *! \brief satInquiryCB 4353 * 4354 * This routine is a callback function for satInquiry() 4355 * 4356 * \param agRoot: Handles for this instance of SAS/SATA hardware 4357 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 4358 * \param agIOStatus: Status of completed I/O. 4359 * \param agFirstDword:Pointer to the four bytes of FIS. 4360 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 4361 * length. 4362 * \param agParam: Additional info based on status. 4363 * \param ioContext: Pointer to satIOContext_t. 4364 * 4365 * \return: none 4366 * 4367 *****************************************************************************/ 4368 void satInquiryCB( 4369 agsaRoot_t *agRoot, 4370 agsaIORequest_t *agIORequest, 4371 bit32 agIOStatus, 4372 agsaFisHeader_t *agFirstDword, 4373 bit32 agIOInfoLen, 4374 void *agParam, 4375 void *ioContext 4376 ) 4377 { 4378 /* 4379 In the process of Inquiry 4380 Process SAT_IDENTIFY_DEVICE 4381 */ 4382 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 4383 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 4384 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 4385 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 4386 tdIORequestBody_t *tdIORequestBody; 4387 tdIORequestBody_t *tdOrgIORequestBody; 4388 satIOContext_t *satIOContext; 4389 satIOContext_t *satOrgIOContext; 4390 satInternalIo_t *satIntIo; 4391 satDeviceData_t *satDevData; 4392 #ifdef TD_DEBUG_ENABLE 4393 tdsaDeviceData_t *tdsaDeviceData; 4394 bit32 ataStatus = 0; 4395 bit32 ataError; 4396 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 4397 #endif 4398 scsiRspSense_t *pSense; 4399 tiIniScsiCmnd_t *scsiCmnd; 4400 tiIORequest_t *tiOrgIORequest; 4401 tiScsiInitiatorRequest_t *tiScsiRequest; /* TD's tiScsiXchg */ 4402 tiScsiInitiatorRequest_t *tiOrgScsiRequest; /* OS's tiScsiXchg */ 4403 agsaSATAIdentifyData_t *pSATAIdData; 4404 bit8 *pInquiry; 4405 bit8 page = 0xFF; 4406 bit16 *tmpptr,tmpptr_tmp; 4407 bit32 x; 4408 bit32 lenReceived; 4409 bit32 lenNeeded = 0; 4410 4411 TI_DBG6(("satInquiryCB: start\n")); 4412 TI_DBG6(("satInquiryCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 4413 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 4414 satIOContext = (satIOContext_t *) ioContext; 4415 satIntIo = satIOContext->satIntIoContext; 4416 satDevData = satIOContext->pSatDevData; 4417 #ifdef TD_DEBUG_ENABLE 4418 tdsaDeviceData = (tdsaDeviceData_t *)satDevData->satSaDeviceData; 4419 #endif 4420 tiScsiRequest = satIOContext->tiScsiXchg; 4421 if (satIntIo == agNULL) 4422 { 4423 TI_DBG6(("satInquiryCB: External, OS generated\n")); 4424 pSense = satIOContext->pSense; 4425 scsiCmnd = satIOContext->pScsiCmnd; 4426 satOrgIOContext = satIOContext; 4427 tiOrgIORequest = tdIORequestBody->tiIORequest; 4428 } 4429 else 4430 { 4431 TI_DBG6(("satInquiryCB: Internal, TD generated\n")); 4432 satOrgIOContext = satIOContext->satOrgIOContext; 4433 if (satOrgIOContext == agNULL) 4434 { 4435 TI_DBG1(("satInquiryCB: satOrgIOContext is NULL, wrong\n")); 4436 return; 4437 } 4438 else 4439 { 4440 TI_DBG6(("satInquiryCB: satOrgIOContext is NOT NULL\n")); 4441 } 4442 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 4443 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 4444 pSense = satOrgIOContext->pSense; 4445 scsiCmnd = satOrgIOContext->pScsiCmnd; 4446 } 4447 4448 tiOrgScsiRequest = satOrgIOContext->tiScsiXchg; 4449 pInquiry = (bit8 *) tiOrgScsiRequest->sglVirtualAddr; 4450 4451 tdIORequestBody->ioCompleted = agTRUE; 4452 tdIORequestBody->ioStarted = agFALSE; 4453 4454 TI_DBG3(("satInquiryCB: did %d\n", tdsaDeviceData->id)); 4455 4456 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 4457 { 4458 TI_DBG1(("satInquiryCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 4459 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY) 4460 { 4461 TI_DBG1(("satInquiryCB: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY\n")); 4462 /* should NOT be retried */ 4463 ostiInitiatorIOCompleted ( 4464 tiRoot, 4465 tiOrgIORequest, 4466 tiIOFailed, 4467 tiDetailNoLogin, 4468 agNULL, 4469 satOrgIOContext->interruptContext 4470 ); 4471 } 4472 else 4473 { 4474 TI_DBG1(("satInquiryCB: NOT OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY\n")); 4475 ostiInitiatorIOCompleted ( 4476 tiRoot, 4477 tiOrgIORequest, 4478 tiIOFailed, 4479 tiDetailNoLogin, 4480 agNULL, 4481 satOrgIOContext->interruptContext 4482 ); 4483 } 4484 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 4485 4486 satFreeIntIoResource( tiRoot, 4487 satDevData, 4488 satIntIo); 4489 return; 4490 } 4491 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED || 4492 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION || 4493 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK || 4494 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS || 4495 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION || 4496 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED || 4497 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION || 4498 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR || 4499 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY 4500 ) 4501 { 4502 TI_DBG1(("satInquiryCB: OSSA_IO_OPEN_CNX_ERROR\n")); 4503 4504 ostiInitiatorIOCompleted ( 4505 tiRoot, 4506 tiOrgIORequest, 4507 tiIOFailed, 4508 tiDetailNoLogin, 4509 agNULL, 4510 satOrgIOContext->interruptContext 4511 ); 4512 4513 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 4514 4515 satFreeIntIoResource( tiRoot, 4516 satDevData, 4517 satIntIo); 4518 return; 4519 } 4520 4521 if ( agIOStatus != OSSA_IO_SUCCESS || 4522 (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL && agIOInfoLen != 0) 4523 ) 4524 { 4525 #ifdef TD_DEBUG_ENABLE 4526 // only agsaFisPioSetup_t is expected 4527 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup); 4528 ataStatus = satPIOSetupHeader->status; // ATA Status register 4529 ataError = satPIOSetupHeader->error; // ATA Eror register 4530 #endif 4531 TI_DBG1(("satInquiryCB: ataStatus 0x%x ataError 0x%x\n", ataStatus, ataError)); 4532 /* Process abort case */ 4533 if (agIOStatus == OSSA_IO_ABORTED) 4534 { 4535 satProcessAbort(tiRoot, 4536 tiOrgIORequest, 4537 satOrgIOContext 4538 ); 4539 4540 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 4541 4542 satFreeIntIoResource( tiRoot, 4543 satDevData, 4544 satIntIo); 4545 return; 4546 } 4547 4548 ostiInitiatorIOCompleted ( 4549 tiRoot, 4550 tiOrgIORequest, 4551 tiIOFailed, 4552 tiDetailOtherError, 4553 agNULL, 4554 satOrgIOContext->interruptContext 4555 ); 4556 4557 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 4558 4559 satFreeIntIoResource( tiRoot, 4560 satDevData, 4561 satIntIo); 4562 return; 4563 } 4564 4565 /* success */ 4566 4567 4568 /* Convert to host endian */ 4569 tmpptr = (bit16*)(tiScsiRequest->sglVirtualAddr); 4570 for (x=0; x < sizeof(agsaSATAIdentifyData_t)/sizeof(bit16); x++) 4571 { 4572 OSSA_READ_LE_16(AGROOT, &tmpptr_tmp, tmpptr, 0); 4573 *tmpptr = tmpptr_tmp; 4574 tmpptr++; 4575 /*Print tmpptr_tmp here for debugging purpose*/ 4576 } 4577 4578 pSATAIdData = (agsaSATAIdentifyData_t *)(tiScsiRequest->sglVirtualAddr); 4579 4580 TI_DBG5(("satInquiryCB: OS satOrgIOContext %p \n", satOrgIOContext)); 4581 TI_DBG5(("satInquiryCB: TD satIOContext %p \n", satIOContext)); 4582 TI_DBG5(("satInquiryCB: OS tiScsiXchg %p \n", satOrgIOContext->tiScsiXchg)); 4583 TI_DBG5(("satInquiryCB: TD tiScsiXchg %p \n", satIOContext->tiScsiXchg)); 4584 4585 /* copy ID Dev data to satDevData */ 4586 satDevData->satIdentifyData = *pSATAIdData; 4587 satDevData->IDDeviceValid = agTRUE; 4588 #ifdef TD_INTERNAL_DEBUG 4589 tdhexdump("satInquiryCB ID Dev data",(bit8 *)pSATAIdData, sizeof(agsaSATAIdentifyData_t)); 4590 tdhexdump("satInquiryCB Device ID Dev data",(bit8 *)&satDevData->satIdentifyData, sizeof(agsaSATAIdentifyData_t)); 4591 #endif 4592 // tdhexdump("satInquiryCB Device ID Dev data",(bit8 *)&satDevData->satIdentifyData, sizeof(agsaSATAIdentifyData_t)); 4593 4594 /* set satDevData fields from IndentifyData */ 4595 satSetDevInfo(satDevData,pSATAIdData); 4596 4597 lenReceived = ((scsiCmnd->cdb[3]) << 8) + scsiCmnd->cdb[4]; 4598 4599 /* SPC-4, spec 6.4 p 141 */ 4600 /* EVPD bit == 0 */ 4601 if (!(scsiCmnd->cdb[1] & SCSI_EVPD_MASK)) 4602 { 4603 /* Returns the standard INQUIRY data */ 4604 lenNeeded = STANDARD_INQUIRY_SIZE; 4605 4606 4607 satInquiryStandard(pInquiry, pSATAIdData, scsiCmnd); 4608 //tdhexdump("satInquiryCB ***standard***", (bit8 *)pInquiry, 36); 4609 4610 } 4611 else 4612 { 4613 /* EVPD bit != 0 && PAGE CODE != 0 */ 4614 /* returns the pages of vital product data information */ 4615 4616 /* we must support page 00h, 83h and 89h */ 4617 page = scsiCmnd->cdb[2]; 4618 if ((page != INQUIRY_SUPPORTED_VPD_PAGE) && 4619 (page != INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE) && 4620 (page != INQUIRY_ATA_INFORMATION_VPD_PAGE)) 4621 { 4622 satSetSensePayload( pSense, 4623 SCSI_SNSKEY_ILLEGAL_REQUEST, 4624 0, 4625 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 4626 satOrgIOContext); 4627 4628 ostiInitiatorIOCompleted( tiRoot, 4629 tiOrgIORequest, 4630 tiIOSuccess, 4631 SCSI_STAT_CHECK_CONDITION, 4632 satOrgIOContext->pTiSenseData, 4633 satOrgIOContext->interruptContext ); 4634 4635 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 4636 4637 satFreeIntIoResource( tiRoot, 4638 satDevData, 4639 satIntIo); 4640 TI_DBG1(("satInquiryCB: invalid PAGE CODE 0x%x\n", page)); 4641 return; 4642 } 4643 4644 /* checking length */ 4645 switch (page) 4646 { 4647 case INQUIRY_SUPPORTED_VPD_PAGE: 4648 lenNeeded = SATA_PAGE0_INQUIRY_SIZE; /* 36 */ 4649 break; 4650 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE: 4651 if (satDevData->satWWNSupport) 4652 { 4653 lenNeeded = SATA_PAGE83_INQUIRY_WWN_SIZE; /* 16 */ 4654 } 4655 else 4656 { 4657 lenNeeded = SATA_PAGE83_INQUIRY_NO_WWN_SIZE; /* 76 */ 4658 } 4659 break; 4660 case INQUIRY_ATA_INFORMATION_VPD_PAGE: 4661 lenNeeded = SATA_PAGE89_INQUIRY_SIZE; /* 572 */ 4662 break; 4663 default: 4664 TI_DBG1(("satInquiryCB: wrong!!! invalid PAGE CODE 0x%x\n", page)); 4665 break; 4666 } 4667 4668 4669 /* 4670 * Fill in the Inquiry data depending on what Inquiry data we are returning. 4671 */ 4672 switch (page) 4673 { 4674 case INQUIRY_SUPPORTED_VPD_PAGE: 4675 satInquiryPage0(pInquiry, pSATAIdData); 4676 break; 4677 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE: 4678 satInquiryPage83(pInquiry, pSATAIdData, satDevData); 4679 break; 4680 case INQUIRY_ATA_INFORMATION_VPD_PAGE: 4681 satInquiryPage89(pInquiry, pSATAIdData, satDevData); 4682 break; 4683 default: 4684 TI_DBG1(("satInquiryCB: wrong!!! invalidinvalid PAGE CODE 0x%x\n", page)); 4685 break; 4686 } 4687 } /* else */ 4688 4689 TI_DBG6(("satInquiryCB: calling ostiInitiatorIOCompleted\n")); 4690 4691 if (lenReceived > lenNeeded) 4692 { 4693 TI_DBG6(("satInquiryCB reporting underrun lenNeeded=0x%x lenReceived=0x%x tiIORequest=%p\n", 4694 lenNeeded, lenReceived, tiOrgIORequest)); 4695 4696 ostiInitiatorIOCompleted( tiRoot, 4697 tiOrgIORequest, 4698 tiIOUnderRun, 4699 lenReceived - lenNeeded, 4700 agNULL, 4701 satOrgIOContext->interruptContext ); 4702 } 4703 else 4704 { 4705 ostiInitiatorIOCompleted( tiRoot, 4706 tiOrgIORequest, 4707 tiIOSuccess, 4708 SCSI_STAT_GOOD, 4709 agNULL, 4710 satOrgIOContext->interruptContext); 4711 } 4712 4713 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 4714 4715 satFreeIntIoResource( tiRoot, 4716 satDevData, 4717 satIntIo); 4718 TI_DBG5(("satInquiryCB: device %p pending IO %d\n", satDevData, satDevData->satPendingIO)); 4719 TI_DBG6(("satInquiryCB: end\n")); 4720 return; 4721 } 4722 4723 4724 /*****************************************************************************/ 4725 /*! \brief satInquiryIntCB. 4726 * 4727 * This function is part of INQUIRY SAT implementation. This is called when 4728 * ATA identify device data is available. 4729 * 4730 * \param tiRoot: Pointer to TISA initiator driver/port instance. 4731 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 4732 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 4733 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 4734 * \param satIOContext_t: Pointer to the SAT IO Context 4735 * 4736 * \return If command is started successfully 4737 * - \e tiSuccess: I/O request successfully initiated. 4738 * - \e tiBusy: No resources available, try again later. 4739 * - \e tiIONoDevice: Invalid device handle. 4740 * - \e tiError: Other errors. 4741 */ 4742 /*****************************************************************************/ 4743 void satInquiryIntCB( 4744 tiRoot_t *tiRoot, 4745 tiIORequest_t *tiIORequest, 4746 tiDeviceHandle_t *tiDeviceHandle, 4747 tiScsiInitiatorRequest_t *tiScsiRequest, 4748 satIOContext_t *satIOContext 4749 ) 4750 { 4751 scsiRspSense_t *pSense; 4752 tiIniScsiCmnd_t *scsiCmnd; 4753 satDeviceData_t *satDevData; 4754 agsaSATAIdentifyData_t *pSATAIdData; 4755 4756 bit8 *pInquiry; 4757 bit8 page = 0xFF; 4758 bit32 lenReceived; 4759 bit32 lenNeeded = 0; 4760 4761 TI_DBG6(("satInquiryIntCB: start\n")); 4762 4763 pSense = satIOContext->pSense; 4764 scsiCmnd = &tiScsiRequest->scsiCmnd; 4765 pInquiry = (bit8 *) tiScsiRequest->sglVirtualAddr; 4766 satDevData = satIOContext->pSatDevData; 4767 pSATAIdData = &satDevData->satIdentifyData; 4768 4769 4770 lenReceived = ((scsiCmnd->cdb[3]) << 8) + scsiCmnd->cdb[4]; 4771 4772 /* SPC-4, spec 6.4 p 141 */ 4773 /* EVPD bit == 0 */ 4774 if (!(scsiCmnd->cdb[1] & SCSI_EVPD_MASK)) 4775 { 4776 /* Returns the standard INQUIRY data */ 4777 lenNeeded = STANDARD_INQUIRY_SIZE; 4778 4779 satInquiryStandard(pInquiry, pSATAIdData, scsiCmnd); 4780 //tdhexdump("satInquiryIntCB ***standard***", (bit8 *)pInquiry, 36); 4781 4782 } 4783 else 4784 { 4785 /* EVPD bit != 0 && PAGE CODE != 0 */ 4786 /* returns the pages of vital product data information */ 4787 4788 /* we must support page 00h, 83h and 89h */ 4789 page = scsiCmnd->cdb[2]; 4790 if ((page != INQUIRY_SUPPORTED_VPD_PAGE) && 4791 (page != INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE) && 4792 (page != INQUIRY_ATA_INFORMATION_VPD_PAGE) && 4793 (page != INQUIRY_UNIT_SERIAL_NUMBER_VPD_PAGE)) 4794 { 4795 satSetSensePayload( pSense, 4796 SCSI_SNSKEY_ILLEGAL_REQUEST, 4797 0, 4798 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 4799 satIOContext); 4800 4801 ostiInitiatorIOCompleted( tiRoot, 4802 tiIORequest, 4803 tiIOSuccess, 4804 SCSI_STAT_CHECK_CONDITION, 4805 satIOContext->pTiSenseData, 4806 satIOContext->interruptContext ); 4807 4808 TI_DBG1(("satInquiryIntCB: invalid PAGE CODE 0x%x\n", page)); 4809 return; 4810 } 4811 4812 /* checking length */ 4813 switch (page) 4814 { 4815 case INQUIRY_SUPPORTED_VPD_PAGE: 4816 lenNeeded = SATA_PAGE0_INQUIRY_SIZE; /* 36 */ 4817 break; 4818 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE: 4819 if (satDevData->satWWNSupport) 4820 { 4821 lenNeeded = SATA_PAGE83_INQUIRY_WWN_SIZE; /* 16 */ 4822 } 4823 else 4824 { 4825 lenNeeded = SATA_PAGE83_INQUIRY_NO_WWN_SIZE; /* 76 */ 4826 } 4827 break; 4828 case INQUIRY_ATA_INFORMATION_VPD_PAGE: 4829 lenNeeded = SATA_PAGE89_INQUIRY_SIZE; /* 572 */ 4830 break; 4831 case INQUIRY_UNIT_SERIAL_NUMBER_VPD_PAGE: 4832 lenNeeded = SATA_PAGE80_INQUIRY_SIZE; /* 24 */ 4833 break; 4834 4835 default: 4836 TI_DBG1(("satInquiryIntCB: wrong!!! invalidinvalid PAGE CODE 0x%x\n", page)); 4837 break; 4838 } 4839 4840 4841 /* 4842 * Fill in the Inquiry data depending on what Inquiry data we are returning. 4843 */ 4844 switch (page) 4845 { 4846 case INQUIRY_SUPPORTED_VPD_PAGE: 4847 satInquiryPage0(pInquiry, pSATAIdData); 4848 break; 4849 case INQUIRY_DEVICE_IDENTIFICATION_VPD_PAGE: 4850 satInquiryPage83(pInquiry, pSATAIdData, satDevData); 4851 break; 4852 case INQUIRY_ATA_INFORMATION_VPD_PAGE: 4853 satInquiryPage89(pInquiry, pSATAIdData, satDevData); 4854 break; 4855 case INQUIRY_UNIT_SERIAL_NUMBER_VPD_PAGE: 4856 satInquiryPage80(pInquiry, pSATAIdData); 4857 break; 4858 default: 4859 TI_DBG1(("satInquiryIntCB: wrong!!! invalidinvalid PAGE CODE 0x%x\n", page)); 4860 break; 4861 } 4862 } /* else */ 4863 4864 TI_DBG6(("satInquiryIntCB: calling ostiInitiatorIOCompleted\n")); 4865 4866 if (lenReceived > lenNeeded) 4867 { 4868 TI_DBG6(("satInquiryIntCB reporting underrun lenNeeded=0x%x lenReceived=0x%x tiIORequest=%p\n", 4869 lenNeeded, lenReceived, tiIORequest)); 4870 4871 ostiInitiatorIOCompleted( tiRoot, 4872 tiIORequest, 4873 tiIOUnderRun, 4874 lenReceived - lenNeeded, 4875 agNULL, 4876 satIOContext->interruptContext ); 4877 } 4878 else 4879 { 4880 ostiInitiatorIOCompleted( tiRoot, 4881 tiIORequest, 4882 tiIOSuccess, 4883 SCSI_STAT_GOOD, 4884 agNULL, 4885 satIOContext->interruptContext); 4886 } 4887 4888 TI_DBG5(("satInquiryIntCB: device %p pending IO %d\n", satDevData, satDevData->satPendingIO)); 4889 TI_DBG6(("satInquiryIntCB: end\n")); 4890 return; 4891 } 4892 4893 4894 /***************************************************************************** 4895 *! \brief satVerify10CB 4896 * 4897 * This routine is a callback function called from ossaSATACompleted(). 4898 * This CB routine deals with Verify(10) completion. 4899 * 4900 * \param agRoot: Handles for this instance of SAS/SATA hardware 4901 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 4902 * \param agIOStatus: Status of completed I/O. 4903 * \param agFirstDword:Pointer to the four bytes of FIS. 4904 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 4905 * length. 4906 * \param agParam: Additional info based on status. 4907 * \param ioContext: Pointer to satIOContext_t. 4908 * 4909 * \return: none 4910 * 4911 *****************************************************************************/ 4912 void satVerify10CB( 4913 agsaRoot_t *agRoot, 4914 agsaIORequest_t *agIORequest, 4915 bit32 agIOStatus, 4916 agsaFisHeader_t *agFirstDword, 4917 bit32 agIOInfoLen, 4918 void *agParam, 4919 void *ioContext 4920 ) 4921 { 4922 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 4923 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 4924 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 4925 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 4926 tdIORequestBody_t *tdIORequestBody; 4927 tdIORequestBody_t *tdOrgIORequestBody; 4928 satIOContext_t *satIOContext; 4929 satIOContext_t *satOrgIOContext; 4930 satInternalIo_t *satIntIo; 4931 satDeviceData_t *satDevData; 4932 scsiRspSense_t *pSense; 4933 tiIORequest_t *tiOrgIORequest; 4934 4935 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 4936 bit32 ataStatus = 0; 4937 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 4938 4939 TI_DBG5(("satVerify10CB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 4940 4941 /* internally generate tiIOContext */ 4942 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 4943 satIOContext = (satIOContext_t *) ioContext; 4944 satIntIo = satIOContext->satIntIoContext; 4945 satDevData = satIOContext->pSatDevData; 4946 hostToDevFis = satIOContext->pFis; 4947 4948 if (satIntIo == agNULL) 4949 { 4950 TI_DBG4(("satVerify10CB: External satInternalIo_t satIntIoContext\n")); 4951 satOrgIOContext = satIOContext; 4952 tiOrgIORequest = tdIORequestBody->tiIORequest; 4953 pSense = satIOContext->pSense; 4954 } 4955 else 4956 { 4957 TI_DBG4(("satVerify10CB: Internal satInternalIo_t satIntIoContext\n")); 4958 satOrgIOContext = satIOContext->satOrgIOContext; 4959 if (satOrgIOContext == agNULL) 4960 { 4961 TI_DBG4(("satVerify10CB: satOrgIOContext is NULL, wrong\n")); 4962 return; 4963 } 4964 else 4965 { 4966 TI_DBG4(("satVerify10CB: satOrgIOContext is NOT NULL\n")); 4967 } 4968 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 4969 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 4970 pSense = satOrgIOContext->pSense; 4971 } 4972 4973 tdIORequestBody->ioCompleted = agTRUE; 4974 tdIORequestBody->ioStarted = agFALSE; 4975 4976 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 4977 { 4978 TI_DBG1(("satVerify10CB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 4979 satSetSensePayload( pSense, 4980 SCSI_SNSKEY_NO_SENSE, 4981 0, 4982 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 4983 satOrgIOContext); 4984 4985 ostiInitiatorIOCompleted( tiRoot, 4986 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 4987 tiIOSuccess, 4988 SCSI_STAT_CHECK_CONDITION, 4989 satOrgIOContext->pTiSenseData, 4990 satOrgIOContext->interruptContext ); 4991 4992 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 4993 4994 satFreeIntIoResource( tiRoot, 4995 satDevData, 4996 satIntIo); 4997 return; 4998 } 4999 5000 if (agIOStatus != OSSA_IO_SUCCESS) 5001 { 5002 /* only agsaFisRegDeviceToHost_t is expected */ 5003 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 5004 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 5005 } 5006 5007 if( agIOStatus != OSSA_IO_SUCCESS) 5008 { 5009 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 5010 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 5011 ) 5012 { 5013 /* for debugging */ 5014 if( agIOStatus != OSSA_IO_SUCCESS) 5015 { 5016 TI_DBG1(("satVerify10CB: FAILED, NOT IO_SUCCESS\n")); 5017 } 5018 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 5019 { 5020 TI_DBG1(("satVerify10CB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 5021 } 5022 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 5023 (ataStatus & DF_ATA_STATUS_MASK) 5024 ) 5025 { 5026 TI_DBG1(("satVerify10CB: FAILED, FAILED, error status\n")); 5027 } 5028 5029 /* Process abort case */ 5030 if (agIOStatus == OSSA_IO_ABORTED) 5031 { 5032 satProcessAbort(tiRoot, 5033 tiOrgIORequest, 5034 satOrgIOContext 5035 ); 5036 5037 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5038 5039 satFreeIntIoResource( tiRoot, 5040 satDevData, 5041 satIntIo); 5042 return; 5043 } 5044 5045 /* for debugging */ 5046 switch (hostToDevFis->h.command) 5047 { 5048 case SAT_READ_VERIFY_SECTORS_EXT: 5049 TI_DBG1(("satVerify10CB: SAT_READ_VERIFY_SECTORS_EXT\n")); 5050 break; 5051 default: 5052 TI_DBG1(("satVerify10CB: error default case command 0x%x\n", hostToDevFis->h.command)); 5053 break; 5054 } 5055 5056 satSetSensePayload( pSense, 5057 SCSI_SNSKEY_NO_SENSE, 5058 0, 5059 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5060 satOrgIOContext); 5061 5062 ostiInitiatorIOCompleted( tiRoot, 5063 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5064 tiIOSuccess, 5065 SCSI_STAT_CHECK_CONDITION, 5066 satOrgIOContext->pTiSenseData, 5067 satOrgIOContext->interruptContext ); 5068 5069 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5070 5071 satFreeIntIoResource( tiRoot, 5072 satDevData, 5073 satIntIo); 5074 return; 5075 } /* end error checking */ 5076 } 5077 5078 /* process success from this point on */ 5079 switch (hostToDevFis->h.command) 5080 { 5081 case SAT_READ_VERIFY_SECTORS_EXT: 5082 TI_DBG5(("satVerify10CB: SAT_WRITE_DMA_EXT success \n")); 5083 5084 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5085 5086 satFreeIntIoResource( tiRoot, 5087 satDevData, 5088 satIntIo); 5089 5090 ostiInitiatorIOCompleted( tiRoot, 5091 tiOrgIORequest, 5092 tiIOSuccess, 5093 SCSI_STAT_GOOD, 5094 agNULL, 5095 satOrgIOContext->interruptContext); 5096 break; 5097 default: 5098 TI_DBG1(("satVerify10CB: success but error default case command 0x%x\n", hostToDevFis->h.command)); 5099 5100 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5101 5102 satFreeIntIoResource( tiRoot, 5103 satDevData, 5104 satIntIo); 5105 5106 satSetSensePayload( pSense, 5107 SCSI_SNSKEY_NO_SENSE, 5108 0, 5109 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5110 satOrgIOContext); 5111 5112 ostiInitiatorIOCompleted( tiRoot, 5113 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5114 tiIOSuccess, 5115 SCSI_STAT_CHECK_CONDITION, 5116 satOrgIOContext->pTiSenseData, 5117 satOrgIOContext->interruptContext ); 5118 5119 break; 5120 } 5121 5122 return; 5123 } 5124 5125 /* similar to satVerify10CB */ 5126 void satNonChainedVerifyCB( 5127 agsaRoot_t *agRoot, 5128 agsaIORequest_t *agIORequest, 5129 bit32 agIOStatus, 5130 agsaFisHeader_t *agFirstDword, 5131 bit32 agIOInfoLen, 5132 agsaFrameHandle_t agFrameHandle, 5133 void *ioContext 5134 ) 5135 { 5136 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 5137 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 5138 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 5139 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 5140 tdIORequestBody_t *tdIORequestBody; 5141 tdIORequestBody_t *tdOrgIORequestBody; 5142 satIOContext_t *satIOContext; 5143 satIOContext_t *satOrgIOContext; 5144 satInternalIo_t *satIntIo; 5145 satDeviceData_t *satDevData; 5146 scsiRspSense_t *pSense; 5147 tiIORequest_t *tiOrgIORequest; 5148 5149 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 5150 bit32 ataStatus = 0; 5151 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 5152 5153 TI_DBG5(("satNonChainedVerifyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 5154 5155 /* internally generate tiIOContext */ 5156 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 5157 satIOContext = (satIOContext_t *) ioContext; 5158 satIntIo = satIOContext->satIntIoContext; 5159 satDevData = satIOContext->pSatDevData; 5160 hostToDevFis = satIOContext->pFis; 5161 5162 if (satIntIo == agNULL) 5163 { 5164 TI_DBG4(("satNonChainedVerifyCB: External satInternalIo_t satIntIoContext\n")); 5165 satOrgIOContext = satIOContext; 5166 tiOrgIORequest = tdIORequestBody->tiIORequest; 5167 pSense = satIOContext->pSense; 5168 } 5169 else 5170 { 5171 TI_DBG4(("satNonChainedVerifyCB: Internal satInternalIo_t satIntIoContext\n")); 5172 satOrgIOContext = satIOContext->satOrgIOContext; 5173 if (satOrgIOContext == agNULL) 5174 { 5175 TI_DBG4(("satNonChainedVerifyCB: satOrgIOContext is NULL, wrong\n")); 5176 return; 5177 } 5178 else 5179 { 5180 TI_DBG4(("satNonChainedVerifyCB: satOrgIOContext is NOT NULL\n")); 5181 } 5182 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 5183 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 5184 pSense = satOrgIOContext->pSense; 5185 } 5186 5187 tdIORequestBody->ioCompleted = agTRUE; 5188 tdIORequestBody->ioStarted = agFALSE; 5189 5190 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 5191 { 5192 TI_DBG1(("satNonChainedVerifyCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 5193 satSetSensePayload( pSense, 5194 SCSI_SNSKEY_NO_SENSE, 5195 0, 5196 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5197 satOrgIOContext); 5198 5199 ostiInitiatorIOCompleted( tiRoot, 5200 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5201 tiIOSuccess, 5202 SCSI_STAT_CHECK_CONDITION, 5203 satOrgIOContext->pTiSenseData, 5204 satOrgIOContext->interruptContext ); 5205 5206 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5207 5208 satFreeIntIoResource( tiRoot, 5209 satDevData, 5210 satIntIo); 5211 return; 5212 } 5213 5214 if (agIOStatus != OSSA_IO_SUCCESS) 5215 { 5216 /* only agsaFisRegDeviceToHost_t is expected */ 5217 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 5218 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 5219 } 5220 5221 if( agIOStatus != OSSA_IO_SUCCESS) 5222 { 5223 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 5224 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 5225 ) 5226 { 5227 /* for debugging */ 5228 if( agIOStatus != OSSA_IO_SUCCESS) 5229 { 5230 TI_DBG1(("satNonChainedVerifyCB: FAILED, NOT IO_SUCCESS\n")); 5231 } 5232 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 5233 { 5234 TI_DBG1(("satNonChainedVerifyCB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 5235 } 5236 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 5237 (ataStatus & DF_ATA_STATUS_MASK) 5238 ) 5239 { 5240 TI_DBG1(("satNonChainedVerifyCB: FAILED, FAILED, error status\n")); 5241 } 5242 5243 /* Process abort case */ 5244 if (agIOStatus == OSSA_IO_ABORTED) 5245 { 5246 satProcessAbort(tiRoot, 5247 tiOrgIORequest, 5248 satOrgIOContext 5249 ); 5250 5251 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5252 5253 satFreeIntIoResource( tiRoot, 5254 satDevData, 5255 satIntIo); 5256 return; 5257 } 5258 5259 /* for debugging */ 5260 switch (hostToDevFis->h.command) 5261 { 5262 case SAT_READ_VERIFY_SECTORS: 5263 TI_DBG1(("satNonChainedVerifyCB: SAT_READ_VERIFY_SECTORS\n")); 5264 break; 5265 case SAT_READ_VERIFY_SECTORS_EXT: 5266 TI_DBG1(("satNonChainedVerifyCB: SAT_READ_VERIFY_SECTORS_EXT\n")); 5267 break; 5268 default: 5269 TI_DBG1(("satNonChainedVerifyCB: error default case command 0x%x\n", hostToDevFis->h.command)); 5270 break; 5271 } 5272 5273 satSetSensePayload( pSense, 5274 SCSI_SNSKEY_NO_SENSE, 5275 0, 5276 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5277 satOrgIOContext); 5278 5279 ostiInitiatorIOCompleted( tiRoot, 5280 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5281 tiIOSuccess, 5282 SCSI_STAT_CHECK_CONDITION, 5283 satOrgIOContext->pTiSenseData, 5284 satOrgIOContext->interruptContext ); 5285 5286 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5287 5288 satFreeIntIoResource( tiRoot, 5289 satDevData, 5290 satIntIo); 5291 return; 5292 } /* end error checking */ 5293 } 5294 5295 /* process success from this point on */ 5296 switch (hostToDevFis->h.command) 5297 { 5298 case SAT_READ_VERIFY_SECTORS: /* fall through */ 5299 case SAT_READ_VERIFY_SECTORS_EXT: 5300 TI_DBG5(("satNonChainedVerifyCB: SAT_WRITE_DMA_EXT success \n")); 5301 5302 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5303 5304 satFreeIntIoResource( tiRoot, 5305 satDevData, 5306 satIntIo); 5307 5308 ostiInitiatorIOCompleted( tiRoot, 5309 tiOrgIORequest, 5310 tiIOSuccess, 5311 SCSI_STAT_GOOD, 5312 agNULL, 5313 satOrgIOContext->interruptContext); 5314 break; 5315 default: 5316 TI_DBG1(("satNonChainedVerifyCB: success but error default case command 0x%x\n", hostToDevFis->h.command)); 5317 5318 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5319 5320 satFreeIntIoResource( tiRoot, 5321 satDevData, 5322 satIntIo); 5323 5324 satSetSensePayload( pSense, 5325 SCSI_SNSKEY_NO_SENSE, 5326 0, 5327 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5328 satOrgIOContext); 5329 5330 ostiInitiatorIOCompleted( tiRoot, 5331 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5332 tiIOSuccess, 5333 SCSI_STAT_CHECK_CONDITION, 5334 satOrgIOContext->pTiSenseData, 5335 satOrgIOContext->interruptContext ); 5336 5337 break; 5338 } 5339 5340 return; 5341 } 5342 5343 void satChainedVerifyCB( 5344 agsaRoot_t *agRoot, 5345 agsaIORequest_t *agIORequest, 5346 bit32 agIOStatus, 5347 agsaFisHeader_t *agFirstDword, 5348 bit32 agIOInfoLen, 5349 agsaFrameHandle_t agFrameHandle, 5350 void *ioContext 5351 ) 5352 { 5353 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 5354 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 5355 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 5356 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 5357 tdIORequestBody_t *tdIORequestBody; 5358 tdIORequestBody_t *tdOrgIORequestBody; 5359 satIOContext_t *satIOContext; 5360 satIOContext_t *satOrgIOContext; 5361 satIOContext_t *satNewIOContext; 5362 satInternalIo_t *satIntIo; 5363 satInternalIo_t *satNewIntIo = agNULL; 5364 satDeviceData_t *satDevData; 5365 scsiRspSense_t *pSense; 5366 tiIniScsiCmnd_t *scsiCmnd; 5367 tiIORequest_t *tiOrgIORequest; 5368 5369 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 5370 bit32 ataStatus = 0; 5371 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 5372 bit32 status = tiError; 5373 bit32 dataLength; 5374 5375 TI_DBG5(("satChainedVerifyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 5376 5377 /* internally generate tiIOContext */ 5378 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 5379 satIOContext = (satIOContext_t *) ioContext; 5380 satIntIo = satIOContext->satIntIoContext; 5381 satDevData = satIOContext->pSatDevData; 5382 hostToDevFis = satIOContext->pFis; 5383 5384 if (satIntIo == agNULL) 5385 { 5386 TI_DBG4(("satChainedVerifyCB: External satInternalIo_t satIntIoContext\n")); 5387 satOrgIOContext = satIOContext; 5388 tiOrgIORequest = tdIORequestBody->tiIORequest; 5389 pSense = satIOContext->pSense; 5390 scsiCmnd = satIOContext->pScsiCmnd; 5391 } 5392 else 5393 { 5394 TI_DBG4(("satChainedVerifyCB: Internal satInternalIo_t satIntIoContext\n")); 5395 satOrgIOContext = satIOContext->satOrgIOContext; 5396 if (satOrgIOContext == agNULL) 5397 { 5398 TI_DBG4(("satChainedVerifyCB: satOrgIOContext is NULL, wrong\n")); 5399 return; 5400 } 5401 else 5402 { 5403 TI_DBG4(("satChainedVerifyCB: satOrgIOContext is NOT NULL\n")); 5404 } 5405 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 5406 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 5407 pSense = satOrgIOContext->pSense; 5408 scsiCmnd = satOrgIOContext->pScsiCmnd; 5409 } 5410 5411 tdIORequestBody->ioCompleted = agTRUE; 5412 tdIORequestBody->ioStarted = agFALSE; 5413 5414 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 5415 { 5416 TI_DBG1(("satChainedVerifyCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 5417 satSetSensePayload( pSense, 5418 SCSI_SNSKEY_NO_SENSE, 5419 0, 5420 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5421 satOrgIOContext); 5422 5423 ostiInitiatorIOCompleted( tiRoot, 5424 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5425 tiIOSuccess, 5426 SCSI_STAT_CHECK_CONDITION, 5427 satOrgIOContext->pTiSenseData, 5428 satOrgIOContext->interruptContext ); 5429 5430 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5431 5432 satFreeIntIoResource( tiRoot, 5433 satDevData, 5434 satIntIo); 5435 return; 5436 } 5437 5438 if (agIOStatus != OSSA_IO_SUCCESS) 5439 { 5440 /* only agsaFisRegDeviceToHost_t is expected */ 5441 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 5442 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 5443 } 5444 5445 if( agIOStatus != OSSA_IO_SUCCESS) 5446 { 5447 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 5448 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 5449 ) 5450 { 5451 /* for debugging */ 5452 if( agIOStatus != OSSA_IO_SUCCESS) 5453 { 5454 TI_DBG1(("satChainedVerifyCB: FAILED, NOT IO_SUCCESS\n")); 5455 } 5456 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 5457 { 5458 TI_DBG1(("satChainedVerifyCB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 5459 } 5460 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 5461 (ataStatus & DF_ATA_STATUS_MASK) 5462 ) 5463 { 5464 TI_DBG1(("satChainedVerifyCB: FAILED, FAILED, error status\n")); 5465 } 5466 5467 /* Process abort case */ 5468 if (agIOStatus == OSSA_IO_ABORTED) 5469 { 5470 satProcessAbort(tiRoot, 5471 tiOrgIORequest, 5472 satOrgIOContext 5473 ); 5474 5475 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5476 5477 satFreeIntIoResource( tiRoot, 5478 satDevData, 5479 satIntIo); 5480 return; 5481 } 5482 5483 /* for debugging */ 5484 switch (hostToDevFis->h.command) 5485 { 5486 case SAT_READ_VERIFY_SECTORS: 5487 TI_DBG1(("satChainedVerifyCB: SAT_READ_VERIFY_SECTORS\n")); 5488 break; 5489 case SAT_READ_VERIFY_SECTORS_EXT: 5490 TI_DBG1(("satChainedVerifyCB: SAT_READ_VERIFY_SECTORS_EXT\n")); 5491 break; 5492 default: 5493 TI_DBG1(("satChainedVerifyCB: error default case command 0x%x\n", hostToDevFis->h.command)); 5494 break; 5495 } 5496 5497 satSetSensePayload( pSense, 5498 SCSI_SNSKEY_NO_SENSE, 5499 0, 5500 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5501 satOrgIOContext); 5502 5503 ostiInitiatorIOCompleted( tiRoot, 5504 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5505 tiIOSuccess, 5506 SCSI_STAT_CHECK_CONDITION, 5507 satOrgIOContext->pTiSenseData, 5508 satOrgIOContext->interruptContext ); 5509 5510 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5511 5512 satFreeIntIoResource( tiRoot, 5513 satDevData, 5514 satIntIo); 5515 return; 5516 } /* end error checking */ 5517 } 5518 5519 /* process success from this point on */ 5520 switch (hostToDevFis->h.command) 5521 { 5522 case SAT_READ_VERIFY_SECTORS: /* fall through */ 5523 case SAT_READ_VERIFY_SECTORS_EXT: 5524 TI_DBG5(("satChainedVerifyCB: SAT_WRITE_DMA_EXT success \n")); 5525 5526 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5527 5528 satFreeIntIoResource( tiRoot, 5529 satDevData, 5530 satIntIo); 5531 5532 /* let's loop till TL */ 5533 5534 /* lba = lba + tl 5535 loopnum--; 5536 if (loopnum == 0) done 5537 */ 5538 (satOrgIOContext->LoopNum)--; 5539 if (satOrgIOContext->LoopNum == 0) 5540 { 5541 /* 5542 done with write and verify 5543 */ 5544 ostiInitiatorIOCompleted( tiRoot, 5545 5546 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5547 tiIOSuccess, 5548 SCSI_STAT_GOOD, 5549 agNULL, 5550 satOrgIOContext->interruptContext ); 5551 return; 5552 } 5553 5554 if (satOrgIOContext->superIOFlag) 5555 { 5556 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->scsiCmnd.expDataLength; 5557 } 5558 else 5559 { 5560 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->scsiCmnd.expDataLength; 5561 } 5562 5563 satNewIntIo = satAllocIntIoResource( tiRoot, 5564 tiOrgIORequest, 5565 satDevData, 5566 dataLength, 5567 satNewIntIo); 5568 if (satNewIntIo == agNULL) 5569 { 5570 /* memory allocation failure */ 5571 satFreeIntIoResource( tiRoot, 5572 satDevData, 5573 satNewIntIo); 5574 ostiInitiatorIOCompleted( tiRoot, 5575 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5576 tiIOFailed, 5577 tiDetailOtherError, 5578 agNULL, 5579 satOrgIOContext->interruptContext ); 5580 5581 TI_DBG1(("satChainedVerifyCB: momory allocation fails\n")); 5582 return; 5583 } /* end of memory allocation failure */ 5584 5585 /* 5586 * Need to initialize all the fields within satIOContext 5587 */ 5588 5589 satNewIOContext = satPrepareNewIO( 5590 satNewIntIo, 5591 tiOrgIORequest, 5592 satDevData, 5593 scsiCmnd, 5594 satOrgIOContext 5595 ); 5596 status = satChainedVerify(tiRoot, 5597 &satNewIntIo->satIntTiIORequest, 5598 satNewIOContext->ptiDeviceHandle, 5599 &satNewIntIo->satIntTiScsiXchg, 5600 satNewIOContext); 5601 5602 if (status != tiSuccess) 5603 { 5604 satFreeIntIoResource( tiRoot, 5605 satDevData, 5606 satNewIntIo); 5607 ostiInitiatorIOCompleted( tiRoot, 5608 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5609 tiIOFailed, 5610 tiDetailOtherError, 5611 agNULL, 5612 satOrgIOContext->interruptContext ); 5613 TI_DBG1(("satChainedVerifyCB: calling satChainedVerify fails\n")); 5614 return; 5615 } 5616 5617 break; 5618 default: 5619 TI_DBG1(("satChainedVerifyCB: success but error default case command 0x%x\n", hostToDevFis->h.command)); 5620 5621 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5622 5623 satFreeIntIoResource( tiRoot, 5624 satDevData, 5625 satIntIo); 5626 5627 satSetSensePayload( pSense, 5628 SCSI_SNSKEY_NO_SENSE, 5629 0, 5630 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 5631 satOrgIOContext); 5632 5633 ostiInitiatorIOCompleted( tiRoot, 5634 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5635 tiIOSuccess, 5636 SCSI_STAT_CHECK_CONDITION, 5637 satOrgIOContext->pTiSenseData, 5638 satOrgIOContext->interruptContext ); 5639 5640 break; 5641 } 5642 return; 5643 } 5644 5645 /***************************************************************************** 5646 *! \brief satTestUnitReadyCB 5647 * 5648 * This routine is a callback function for satTestUnitReady() 5649 * 5650 * \param agRoot: Handles for this instance of SAS/SATA hardware 5651 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 5652 * \param agIOStatus: Status of completed I/O. 5653 * \param agFirstDword:Pointer to the four bytes of FIS. 5654 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 5655 * length. 5656 * \param agParam: Additional info based on status. 5657 * \param ioContext: Pointer to satIOContext_t. 5658 * 5659 * \return: none 5660 * 5661 *****************************************************************************/ 5662 void satTestUnitReadyCB( 5663 agsaRoot_t *agRoot, 5664 agsaIORequest_t *agIORequest, 5665 bit32 agIOStatus, 5666 agsaFisHeader_t *agFirstDword, 5667 bit32 agIOInfoLen, 5668 void *agParam, 5669 void *ioContext 5670 ) 5671 { 5672 /* 5673 In the process of TestUnitReady 5674 Process SAT_GET_MEDIA_STATUS 5675 Process SAT_CHECK_POWER_MODE 5676 */ 5677 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 5678 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 5679 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 5680 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 5681 tdIORequestBody_t *tdIORequestBody; 5682 tdIORequestBody_t *tdOrgIORequestBody; 5683 satIOContext_t *satIOContext; 5684 satIOContext_t *satOrgIOContext; 5685 satIOContext_t *satNewIOContext; 5686 satInternalIo_t *satIntIo; 5687 satInternalIo_t *satNewIntIo = agNULL; 5688 satDeviceData_t *satDevData; 5689 scsiRspSense_t *pSense; 5690 tiIniScsiCmnd_t *scsiCmnd; 5691 tiIORequest_t *tiOrgIORequest; 5692 5693 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 5694 bit32 ataStatus = 0; 5695 bit32 ataError; 5696 5697 bit32 status; 5698 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 5699 5700 TI_DBG6(("satTestUnitReadyCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 5701 5702 /* internally generate tiIOContext */ 5703 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 5704 satIOContext = (satIOContext_t *) ioContext; 5705 satIntIo = satIOContext->satIntIoContext; 5706 satDevData = satIOContext->pSatDevData; 5707 hostToDevFis = satIOContext->pFis; 5708 5709 if (satIntIo == agNULL) 5710 { 5711 TI_DBG5(("satTestUnitReadyCB: no internal satInternalIo_t satIntIoContext\n")); 5712 pSense = satIOContext->pSense; 5713 scsiCmnd = satIOContext->pScsiCmnd; 5714 satOrgIOContext = satIOContext; 5715 tiOrgIORequest = tdIORequestBody->tiIORequest; 5716 } 5717 else 5718 { 5719 TI_DBG5(("satTestUnitReadyCB: yes internal satInternalIo_t satIntIoContext\n")); 5720 5721 /* orginal tiIOContext */ 5722 tiOrgIORequest = (tiIORequest_t *)satIOContext->satIntIoContext->satOrgTiIORequest; 5723 tdOrgIORequestBody = (tdIORequestBody_t *)tiOrgIORequest->tdData; 5724 satOrgIOContext = &(tdOrgIORequestBody->transport.SATA.satIOContext); 5725 5726 pSense = satOrgIOContext->pSense; 5727 scsiCmnd = satOrgIOContext->pScsiCmnd; 5728 } 5729 5730 tdIORequestBody->ioCompleted = agTRUE; 5731 tdIORequestBody->ioStarted = agFALSE; 5732 5733 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 5734 { 5735 TI_DBG1(("satTestUnitReadyCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 5736 satSetSensePayload( pSense, 5737 SCSI_SNSKEY_NOT_READY, 5738 0, 5739 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 5740 satOrgIOContext); 5741 5742 ostiInitiatorIOCompleted( tiRoot, 5743 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5744 tiIOSuccess, 5745 SCSI_STAT_CHECK_CONDITION, 5746 satOrgIOContext->pTiSenseData, 5747 satOrgIOContext->interruptContext ); 5748 5749 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5750 5751 satFreeIntIoResource( tiRoot, 5752 satDevData, 5753 satIntIo); 5754 5755 return; 5756 } 5757 /* 5758 HW checks an error for us and the results is agIOStatus 5759 */ 5760 if (agIOStatus != OSSA_IO_SUCCESS) 5761 { 5762 /* only agsaFisRegDeviceToHost_t is expected */ 5763 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 5764 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 5765 ataError = statDevToHostFisHeader->error; /* ATA Eror register */ 5766 5767 if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 5768 { 5769 TI_DBG1(("satTestUnitReadyCB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 5770 } 5771 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 5772 (ataStatus & DF_ATA_STATUS_MASK) 5773 ) 5774 { 5775 TI_DBG1(("satTestUnitReadyCB: FAILED, FAILED, error status\n")); 5776 } 5777 5778 /* Process abort case */ 5779 if (agIOStatus == OSSA_IO_ABORTED) 5780 { 5781 satProcessAbort(tiRoot, 5782 tiOrgIORequest, 5783 satOrgIOContext 5784 ); 5785 5786 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5787 5788 satFreeIntIoResource( tiRoot, 5789 satDevData, 5790 satIntIo); 5791 return; 5792 } 5793 5794 switch (hostToDevFis->h.command) 5795 { 5796 case SAT_GET_MEDIA_STATUS: 5797 TI_DBG1(("satTestUnitReadyCB: SAT_GET_MEDIA_STATUS failed \n")); 5798 5799 /* checking NM bit */ 5800 if (ataError & SCSI_NM_MASK) 5801 { 5802 satSetSensePayload( pSense, 5803 SCSI_SNSKEY_NOT_READY, 5804 0, 5805 SCSI_SNSCODE_MEDIUM_NOT_PRESENT, 5806 satOrgIOContext); 5807 } 5808 else 5809 { 5810 satSetSensePayload( pSense, 5811 SCSI_SNSKEY_NOT_READY, 5812 0, 5813 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 5814 satOrgIOContext); 5815 } 5816 5817 ostiInitiatorIOCompleted( tiRoot, 5818 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5819 tiIOSuccess, 5820 SCSI_STAT_CHECK_CONDITION, 5821 satOrgIOContext->pTiSenseData, 5822 satOrgIOContext->interruptContext ); 5823 5824 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5825 5826 satFreeIntIoResource( tiRoot, 5827 satDevData, 5828 satIntIo); 5829 break; 5830 case SAT_CHECK_POWER_MODE: 5831 TI_DBG1(("satTestUnitReadyCB: SAT_CHECK_POWER_MODE failed \n")); 5832 satSetSensePayload( pSense, 5833 SCSI_SNSKEY_NOT_READY, 5834 0, 5835 SCSI_SNSCODE_LOGICAL_UNIT_DOES_NOT_RESPOND_TO_SELECTION, 5836 satOrgIOContext); 5837 5838 ostiInitiatorIOCompleted( tiRoot, 5839 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5840 tiIOSuccess, 5841 SCSI_STAT_CHECK_CONDITION, 5842 satOrgIOContext->pTiSenseData, 5843 satOrgIOContext->interruptContext ); 5844 5845 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5846 5847 satFreeIntIoResource( tiRoot, 5848 satDevData, 5849 satIntIo); 5850 break; 5851 default: 5852 TI_DBG1(("satTestUnitReadyCB: default failed command %d\n", hostToDevFis->h.command)); 5853 5854 satSetSensePayload( pSense, 5855 SCSI_SNSKEY_NOT_READY, 5856 0, 5857 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 5858 satOrgIOContext); 5859 5860 ostiInitiatorIOCompleted( tiRoot, 5861 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5862 tiIOSuccess, 5863 SCSI_STAT_CHECK_CONDITION, 5864 satOrgIOContext->pTiSenseData, 5865 satOrgIOContext->interruptContext ); 5866 5867 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5868 5869 satFreeIntIoResource( tiRoot, 5870 satDevData, 5871 satIntIo); 5872 break; 5873 5874 } 5875 return; 5876 }/* end error */ 5877 5878 /* ATA command completes sucessfully */ 5879 switch (hostToDevFis->h.command) 5880 { 5881 case SAT_GET_MEDIA_STATUS: 5882 5883 TI_DBG5(("satTestUnitReadyCB: SAT_GET_MEDIA_STATUS success\n")); 5884 5885 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5886 5887 satFreeIntIoResource( tiRoot, 5888 satDevData, 5889 satIntIo); 5890 5891 satNewIntIo = satAllocIntIoResource( tiRoot, 5892 tiOrgIORequest, 5893 satDevData, 5894 0, 5895 satNewIntIo); 5896 if (satNewIntIo == agNULL) 5897 { 5898 /* memory allocation failure */ 5899 satFreeIntIoResource( tiRoot, 5900 satDevData, 5901 satNewIntIo); 5902 satSetSensePayload( pSense, 5903 SCSI_SNSKEY_NOT_READY, 5904 0, 5905 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 5906 satOrgIOContext); 5907 5908 ostiInitiatorIOCompleted( tiRoot, 5909 tiOrgIORequest, 5910 tiIOSuccess, 5911 SCSI_STAT_CHECK_CONDITION, 5912 satOrgIOContext->pTiSenseData, 5913 satOrgIOContext->interruptContext ); 5914 5915 TI_DBG1(("satTestUnitReadyCB: momory allocation fails\n")); 5916 return; 5917 } 5918 5919 /* 5920 * Need to initialize all the fields within satIOContext 5921 */ 5922 5923 satNewIOContext = satPrepareNewIO( 5924 satNewIntIo, 5925 tiOrgIORequest, 5926 satDevData, 5927 scsiCmnd, 5928 satOrgIOContext 5929 ); 5930 5931 /* sends SAT_CHECK_POWER_MODE */ 5932 status = satTestUnitReady_1( tiRoot, 5933 &satNewIntIo->satIntTiIORequest, 5934 satNewIOContext->ptiDeviceHandle, 5935 &satNewIntIo->satIntTiScsiXchg, 5936 satNewIOContext); 5937 5938 if (status != tiSuccess) 5939 { 5940 /* sending SAT_CHECK_POWER_MODE fails */ 5941 satFreeIntIoResource( tiRoot, 5942 satDevData, 5943 satNewIntIo); 5944 satSetSensePayload( pSense, 5945 SCSI_SNSKEY_NOT_READY, 5946 0, 5947 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 5948 satOrgIOContext); 5949 5950 ostiInitiatorIOCompleted( tiRoot, 5951 tiOrgIORequest, 5952 tiIOSuccess, 5953 SCSI_STAT_CHECK_CONDITION, 5954 satOrgIOContext->pTiSenseData, 5955 satOrgIOContext->interruptContext ); 5956 5957 TI_DBG1(("satTestUnitReadyCB: calling satTestUnitReady_1 fails\n")); 5958 return; 5959 } 5960 5961 break; 5962 case SAT_CHECK_POWER_MODE: 5963 TI_DBG5(("satTestUnitReadyCB: SAT_CHECK_POWER_MODE success\n")); 5964 5965 5966 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5967 5968 satFreeIntIoResource( tiRoot, 5969 satDevData, 5970 satIntIo); 5971 5972 /* returns good status */ 5973 ostiInitiatorIOCompleted( tiRoot, 5974 tiOrgIORequest, 5975 tiIOSuccess, 5976 SCSI_STAT_GOOD, 5977 agNULL, 5978 satOrgIOContext->interruptContext ); 5979 5980 break; 5981 default: 5982 TI_DBG1(("satTestUnitReadyCB: default success command %d\n", hostToDevFis->h.command)); 5983 satSetSensePayload( pSense, 5984 SCSI_SNSKEY_NOT_READY, 5985 0, 5986 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE, 5987 satOrgIOContext); 5988 5989 ostiInitiatorIOCompleted( tiRoot, 5990 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 5991 tiIOSuccess, 5992 SCSI_STAT_CHECK_CONDITION, 5993 satOrgIOContext->pTiSenseData, 5994 satOrgIOContext->interruptContext ); 5995 5996 5997 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 5998 5999 satFreeIntIoResource( tiRoot, 6000 satDevData, 6001 satIntIo); 6002 break; 6003 } 6004 6005 return; 6006 } 6007 6008 /***************************************************************************** 6009 *! \brief satWriteSame10CB 6010 * 6011 * This routine is a callback function for satWriteSame10() 6012 * 6013 * \param agRoot: Handles for this instance of SAS/SATA hardware 6014 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 6015 * \param agIOStatus: Status of completed I/O. 6016 * \param agFirstDword:Pointer to the four bytes of FIS. 6017 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 6018 * length. 6019 * \param agParam: Additional info based on status. 6020 * \param ioContext: Pointer to satIOContext_t. 6021 * 6022 * \return: none 6023 * 6024 *****************************************************************************/ 6025 void satWriteSame10CB( 6026 agsaRoot_t *agRoot, 6027 agsaIORequest_t *agIORequest, 6028 bit32 agIOStatus, 6029 agsaFisHeader_t *agFirstDword, 6030 bit32 agIOInfoLen, 6031 void *agParam, 6032 void *ioContext 6033 ) 6034 { 6035 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 6036 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 6037 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 6038 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 6039 tdIORequestBody_t *tdIORequestBody; 6040 tdIORequestBody_t *tdOrgIORequestBody; 6041 tdIORequestBody_t *tdNewIORequestBody; 6042 satIOContext_t *satIOContext; 6043 satIOContext_t *satOrgIOContext; 6044 satIOContext_t *satNewIOContext; 6045 satInternalIo_t *satIntIo; 6046 satInternalIo_t *satNewIntIo = agNULL; 6047 satDeviceData_t *satDevData; 6048 scsiRspSense_t *pSense; 6049 tiIniScsiCmnd_t *scsiCmnd; 6050 tiIORequest_t *tiOrgIORequest; 6051 6052 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 6053 bit32 ataStatus = 0; 6054 bit32 status; 6055 6056 bit32 sectorcount = 0; 6057 bit32 lba = 0, tl = 0; 6058 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 6059 agsaFisSetDevBitsHeader_t *statSetDevBitFisHeader = agNULL; 6060 6061 TI_DBG5(("satWriteSame10CB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 6062 6063 /* internally generate tiIOContext */ 6064 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 6065 satIOContext = (satIOContext_t *) ioContext; 6066 satIntIo = satIOContext->satIntIoContext; 6067 satDevData = satIOContext->pSatDevData; 6068 hostToDevFis = satIOContext->pFis; 6069 6070 if (satIntIo == agNULL) 6071 { 6072 TI_DBG4(("satWriteSame10CB: External satInternalIo_t satIntIoContext\n")); 6073 satOrgIOContext = satIOContext; 6074 tiOrgIORequest = tdIORequestBody->tiIORequest; 6075 pSense = satIOContext->pSense; 6076 scsiCmnd = satIOContext->pScsiCmnd; 6077 } 6078 else 6079 { 6080 TI_DBG4(("satWriteSame10CB: Internal satInternalIo_t satIntIoContext\n")); 6081 satOrgIOContext = satIOContext->satOrgIOContext; 6082 if (satOrgIOContext == agNULL) 6083 { 6084 TI_DBG4(("satWriteSame10CB: satOrgIOContext is NULL, wrong\n")); 6085 return; 6086 } 6087 else 6088 { 6089 TI_DBG4(("satWriteSame10CB: satOrgIOContext is NOT NULL\n")); 6090 } 6091 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 6092 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 6093 6094 pSense = satOrgIOContext->pSense; 6095 scsiCmnd = satOrgIOContext->pScsiCmnd; 6096 } 6097 6098 6099 tdIORequestBody->ioCompleted = agTRUE; 6100 tdIORequestBody->ioStarted = agFALSE; 6101 6102 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 6103 { 6104 TI_DBG1(("satWriteSame10CB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 6105 satSetSensePayload( pSense, 6106 SCSI_SNSKEY_NO_SENSE, 6107 0, 6108 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6109 satOrgIOContext); 6110 6111 ostiInitiatorIOCompleted( tiRoot, 6112 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 6113 tiIOSuccess, 6114 SCSI_STAT_CHECK_CONDITION, 6115 satOrgIOContext->pTiSenseData, 6116 satOrgIOContext->interruptContext ); 6117 6118 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6119 6120 satFreeIntIoResource( tiRoot, 6121 satDevData, 6122 satIntIo); 6123 return; 6124 } 6125 6126 if (agIOStatus != OSSA_IO_SUCCESS) 6127 { 6128 /* FP, DMA and PIO write */ 6129 /* First, assumed to be Reg Device to Host FIS */ 6130 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 6131 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 6132 } 6133 6134 if (agIOStatus != OSSA_IO_SUCCESS) 6135 { 6136 if (statDevToHostFisHeader->fisType == SET_DEV_BITS_FIS) 6137 { 6138 statSetDevBitFisHeader = (agsaFisSetDevBitsHeader_t *)&(agFirstDword->D2H); 6139 6140 /* Get ATA Status register */ 6141 ataStatus = (statSetDevBitFisHeader->statusHi_Lo & 0x70); /* bits 4,5,6 */ 6142 ataStatus = ataStatus | (statSetDevBitFisHeader->statusHi_Lo & 0x07); /* bits 0,1,2 */ 6143 6144 /* ATA Eror register */ 6145 6146 } 6147 } 6148 6149 if( agIOStatus != OSSA_IO_SUCCESS) 6150 { 6151 /* 6152 checking IO status, FIS type and error status 6153 FIS type should be either REG_DEV_TO_HOST_FIS or SET_DEV_BITS_FIS 6154 */ 6155 if ( ((statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) && 6156 (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS)) || 6157 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 6158 ) 6159 { 6160 /* for debugging */ 6161 if( agIOStatus != OSSA_IO_SUCCESS) 6162 { 6163 TI_DBG1(("satWriteSame10CB: FAILED, NOT IO_SUCCESS\n")); 6164 } 6165 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 6166 { 6167 TI_DBG1(("satWriteSame10CB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 6168 } 6169 else if (statDevToHostFisHeader->fisType != SET_DEV_BITS_FIS) 6170 { 6171 TI_DBG1(("satWriteSame10CB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 6172 } 6173 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 6174 (ataStatus & DF_ATA_STATUS_MASK) 6175 ) 6176 { 6177 TI_DBG1(("satWriteSame10CB: FAILED, FAILED, error status\n")); 6178 } 6179 6180 /* Process abort case */ 6181 if (agIOStatus == OSSA_IO_ABORTED) 6182 { 6183 satProcessAbort(tiRoot, 6184 tiOrgIORequest, 6185 satOrgIOContext 6186 ); 6187 6188 6189 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6190 6191 satFreeIntIoResource( tiRoot, 6192 satDevData, 6193 satIntIo); 6194 return; 6195 } 6196 6197 /* for debugging */ 6198 switch (hostToDevFis->h.command) 6199 { 6200 case SAT_WRITE_DMA_EXT: 6201 TI_DBG1(("satWriteSame10CB: SAT_WRITE_DMA_EXT\n")); 6202 break; 6203 case SAT_WRITE_SECTORS_EXT: 6204 TI_DBG1(("satWriteSame10CB: SAT_WRITE_SECTORS_EXT\n")); 6205 break; 6206 case SAT_WRITE_FPDMA_QUEUED: 6207 TI_DBG1(("satWriteSame10CB: SAT_WRITE_FPDMA_QUEUED\n")); 6208 break; 6209 default: 6210 TI_DBG1(("satWriteSame10CB: error default case command 0x%x\n", hostToDevFis->h.command)); 6211 break; 6212 } 6213 6214 satSetSensePayload( pSense, 6215 SCSI_SNSKEY_NO_SENSE, 6216 0, 6217 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6218 satOrgIOContext); 6219 6220 ostiInitiatorIOCompleted( tiRoot, 6221 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 6222 tiIOSuccess, 6223 SCSI_STAT_CHECK_CONDITION, 6224 satOrgIOContext->pTiSenseData, 6225 satOrgIOContext->interruptContext ); 6226 6227 6228 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6229 6230 satFreeIntIoResource( tiRoot, 6231 satDevData, 6232 satIntIo); 6233 return; 6234 } /* end error */ 6235 } 6236 6237 /* process success from this point on */ 6238 /* 6239 note: inefficient implementation until a single block can be manipulated 6240 */ 6241 6242 if (hostToDevFis->h.command == SAT_WRITE_DMA_EXT) 6243 { 6244 TI_DBG5(("satWriteSame10CB: SAT_WRITE_DMA_EXT success\n")); 6245 } 6246 else if (hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT) 6247 { 6248 TI_DBG5(("satWriteSame10CB: SAT_WRITE_SECTORS_EXT success\n")); 6249 } 6250 else if (hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED) 6251 { 6252 TI_DBG5(("satWriteSame10CB: SAT_WRITE_FPDMA_QUEUED success\n")); 6253 } 6254 else 6255 { 6256 TI_DBG1(("satWriteSame10CB: error case command 0x%x success\n", hostToDevFis->h.command)); 6257 satSetSensePayload( pSense, 6258 SCSI_SNSKEY_NO_SENSE, 6259 0, 6260 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6261 satOrgIOContext); 6262 6263 ostiInitiatorIOCompleted( tiRoot, 6264 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 6265 tiIOSuccess, 6266 SCSI_STAT_CHECK_CONDITION, 6267 satOrgIOContext->pTiSenseData, 6268 satOrgIOContext->interruptContext ); 6269 6270 6271 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6272 6273 satFreeIntIoResource( tiRoot, 6274 satDevData, 6275 satIntIo); 6276 return; 6277 } 6278 6279 6280 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6281 6282 /* free */ 6283 satFreeIntIoResource( tiRoot, 6284 satDevData, 6285 satIntIo); 6286 6287 /* 6288 increment LBA by one, keeping the same sector count(1) 6289 sends another ATA command with the changed parameters 6290 */ 6291 6292 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 6293 satDevData->satSectorDone++; 6294 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 6295 6296 TI_DBG1(("satWriteSame10CB: sectordone %d\n", satDevData->satSectorDone)); 6297 6298 lba = (scsiCmnd->cdb[2] << (8*3)) + (scsiCmnd->cdb[3] << (8*2)) 6299 + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 6300 tl = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 6301 6302 TI_DBG5(("satWriteSame10CB: lba 0x%x tl 0x%x\n", lba, tl)); 6303 6304 if (tl == 0) 6305 { 6306 /* (satDevData->satMaxUserAddrSectors - 1) - lba*/ 6307 sectorcount = (0x0FFFFFFF - 1) - lba; 6308 } 6309 else 6310 { 6311 sectorcount = tl; 6312 } 6313 6314 if (sectorcount <= 0) 6315 { 6316 satSetSensePayload( pSense, 6317 SCSI_SNSKEY_NO_SENSE, 6318 0, 6319 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6320 satOrgIOContext); 6321 6322 ostiInitiatorIOCompleted( tiRoot, 6323 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 6324 tiIOSuccess, 6325 SCSI_STAT_CHECK_CONDITION, 6326 satOrgIOContext->pTiSenseData, 6327 satOrgIOContext->interruptContext ); 6328 TI_DBG1(("satWriteSame10CB: incorrect sectorcount 0x%x\n", sectorcount)); 6329 return; 6330 } 6331 6332 if (sectorcount == satDevData->satSectorDone) 6333 { 6334 /* 6335 done with writesame 6336 */ 6337 TI_DBG1(("satWriteSame10CB: return writesame done\n")); 6338 satDevData->satSectorDone = 0; 6339 6340 ostiInitiatorIOCompleted( tiRoot, 6341 tiOrgIORequest, 6342 tiIOSuccess, 6343 SCSI_STAT_GOOD, 6344 agNULL, 6345 satOrgIOContext->interruptContext ); 6346 } 6347 else 6348 { 6349 /* sends another ATA command */ 6350 if (hostToDevFis->h.command == SAT_WRITE_DMA_EXT) 6351 { 6352 TI_DBG1(("satWriteSame10CB: sends another SAT_WRITE_DMA_EXT\n")); 6353 } 6354 else if (hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT) 6355 { 6356 TI_DBG1(("satWriteSame10CB: sends another SAT_WRITE_SECTORS_EXT\n")); 6357 } 6358 else if (hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED) 6359 { 6360 TI_DBG1(("satWriteSame10CB: sends another SAT_WRITE_FPDMA_QUEUED\n")); 6361 } 6362 6363 satNewIntIo = satAllocIntIoResource( tiRoot, 6364 tiOrgIORequest, 6365 satDevData, 6366 0, 6367 satNewIntIo); 6368 if (satNewIntIo == agNULL) 6369 { 6370 /* memory allocation failure */ 6371 satFreeIntIoResource( tiRoot, 6372 satDevData, 6373 satNewIntIo); 6374 6375 satSetSensePayload( pSense, 6376 SCSI_SNSKEY_NO_SENSE, 6377 0, 6378 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6379 satOrgIOContext); 6380 6381 ostiInitiatorIOCompleted( tiRoot, 6382 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 6383 tiIOSuccess, 6384 SCSI_STAT_CHECK_CONDITION, 6385 satOrgIOContext->pTiSenseData, 6386 satOrgIOContext->interruptContext ); 6387 TI_DBG1(("satWriteSame10CB: momory allocation fails\n")); 6388 return; 6389 } /* end memory allocation */ 6390 6391 /* the one to be used */ 6392 tdNewIORequestBody = satNewIntIo->satIntRequestBody; 6393 satNewIOContext = &tdNewIORequestBody->transport.SATA.satIOContext; 6394 6395 satNewIOContext->pSatDevData = satDevData; 6396 satNewIOContext->pFis = &tdNewIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev; 6397 satNewIOContext->pScsiCmnd = &satNewIntIo->satIntTiScsiXchg.scsiCmnd; 6398 /* saves scsi command for LBA and number of blocks */ 6399 osti_memcpy(satNewIOContext->pScsiCmnd, scsiCmnd, sizeof(tiIniScsiCmnd_t)); 6400 satNewIOContext->pSense = &tdNewIORequestBody->transport.SATA.sensePayload; 6401 satNewIOContext->pTiSenseData = &tdNewIORequestBody->transport.SATA.tiSenseData; 6402 satNewIOContext->pTiSenseData->senseData = satNewIOContext->pSense; 6403 satNewIOContext->tiRequestBody = satNewIntIo->satIntRequestBody; 6404 satNewIOContext->interruptContext = satNewIOContext->interruptContext; 6405 satNewIOContext->satIntIoContext = satNewIntIo; 6406 satNewIOContext->ptiDeviceHandle = satIOContext->ptiDeviceHandle; 6407 /* saves tiScsiXchg; only for writesame10() */ 6408 satNewIOContext->tiScsiXchg = satOrgIOContext->tiScsiXchg; 6409 6410 if (hostToDevFis->h.command == SAT_WRITE_DMA_EXT) 6411 { 6412 status = satWriteSame10_1( tiRoot, 6413 &satNewIntIo->satIntTiIORequest, 6414 satNewIOContext->ptiDeviceHandle, 6415 &satNewIntIo->satIntTiScsiXchg, 6416 satNewIOContext, 6417 lba + satDevData->satSectorDone 6418 ); 6419 } 6420 else if (hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT) 6421 { 6422 status = satWriteSame10_2( tiRoot, 6423 &satNewIntIo->satIntTiIORequest, 6424 satNewIOContext->ptiDeviceHandle, 6425 &satNewIntIo->satIntTiScsiXchg, 6426 satNewIOContext, 6427 lba + satDevData->satSectorDone 6428 ); 6429 } 6430 else if (hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED) 6431 { 6432 status = satWriteSame10_3( tiRoot, 6433 &satNewIntIo->satIntTiIORequest, 6434 satNewIOContext->ptiDeviceHandle, 6435 &satNewIntIo->satIntTiScsiXchg, 6436 satNewIOContext, 6437 lba + satDevData->satSectorDone 6438 ); 6439 } 6440 else 6441 { 6442 status = tiError; 6443 TI_DBG1(("satWriteSame10CB: sucess but error in command 0x%x\n", hostToDevFis->h.command)); 6444 } 6445 6446 if (status != tiSuccess) 6447 { 6448 /* sending ATA command fails */ 6449 satFreeIntIoResource( tiRoot, 6450 satDevData, 6451 satNewIntIo); 6452 satSetSensePayload( pSense, 6453 SCSI_SNSKEY_NO_SENSE, 6454 0, 6455 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6456 satOrgIOContext); 6457 6458 ostiInitiatorIOCompleted( tiRoot, 6459 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 6460 tiIOSuccess, 6461 SCSI_STAT_CHECK_CONDITION, 6462 satOrgIOContext->pTiSenseData, 6463 satOrgIOContext->interruptContext ); 6464 TI_DBG1(("satWriteSame10CB:calling satWriteSame10_1 fails\n")); 6465 return; 6466 } /* end send fails */ 6467 6468 } /* end sends another ATA command */ 6469 6470 return; 6471 } 6472 /***************************************************************************** 6473 *! \brief satStartStopUnitCB 6474 * 6475 * This routine is a callback function called from ossaSATACompleted(). 6476 * This CB routine deals with Send Diagnostic completion. 6477 * 6478 * \param agRoot: Handles for this instance of SAS/SATA hardware 6479 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 6480 * \param agIOStatus: Status of completed I/O. 6481 * \param agFirstDword:Pointer to the four bytes of FIS. 6482 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 6483 * length. 6484 * \param agParam: Additional info based on status. 6485 * \param ioContext: Pointer to satIOContext_t. 6486 * 6487 * \return: none 6488 * 6489 *****************************************************************************/ 6490 void satStartStopUnitCB( 6491 agsaRoot_t *agRoot, 6492 agsaIORequest_t *agIORequest, 6493 bit32 agIOStatus, 6494 agsaFisHeader_t *agFirstDword, 6495 bit32 agIOInfoLen, 6496 void *agParam, 6497 void *ioContext 6498 ) 6499 { 6500 /* 6501 In the process of StartStopUnit 6502 Process FLUSH CACHE (EXT) 6503 Process STANDBY 6504 Process READ VERIFY SECTOR(S) EXT 6505 Process MEDIA EJECT 6506 */ 6507 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 6508 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 6509 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 6510 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 6511 tdIORequestBody_t *tdIORequestBody; 6512 tdIORequestBody_t *tdOrgIORequestBody; 6513 satIOContext_t *satIOContext; 6514 satIOContext_t *satOrgIOContext; 6515 satIOContext_t *satNewIOContext; 6516 satInternalIo_t *satIntIo; 6517 satInternalIo_t *satNewIntIo = agNULL; 6518 satDeviceData_t *satDevData; 6519 scsiRspSense_t *pSense; 6520 tiIniScsiCmnd_t *scsiCmnd; 6521 tiIORequest_t *tiOrgIORequest; 6522 6523 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 6524 bit32 ataStatus = 0; 6525 bit32 status; 6526 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 6527 6528 TI_DBG5(("satStartStopUnitCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 6529 6530 /* internally generate tiIOContext */ 6531 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 6532 satIOContext = (satIOContext_t *) ioContext; 6533 satIntIo = satIOContext->satIntIoContext; 6534 satDevData = satIOContext->pSatDevData; 6535 hostToDevFis = satIOContext->pFis; 6536 6537 if (satIntIo == agNULL) 6538 { 6539 TI_DBG4(("satStartStopUnitCB: External satInternalIo_t satIntIoContext\n")); 6540 satOrgIOContext = satIOContext; 6541 tiOrgIORequest = tdIORequestBody->tiIORequest; 6542 pSense = satIOContext->pSense; 6543 scsiCmnd = satIOContext->pScsiCmnd; 6544 } 6545 else 6546 { 6547 TI_DBG4(("satStartStopUnitCB: Internal satInternalIo_t satIntIoContext\n")); 6548 satOrgIOContext = satIOContext->satOrgIOContext; 6549 if (satOrgIOContext == agNULL) 6550 { 6551 TI_DBG4(("satStartStopUnitCB: satOrgIOContext is NULL, wrong\n")); 6552 return; 6553 } 6554 else 6555 { 6556 TI_DBG4(("satStartStopUnitCB: satOrgIOContext is NOT NULL\n")); 6557 } 6558 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 6559 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 6560 6561 pSense = satOrgIOContext->pSense; 6562 scsiCmnd = satOrgIOContext->pScsiCmnd; 6563 } 6564 6565 tdIORequestBody->ioCompleted = agTRUE; 6566 tdIORequestBody->ioStarted = agFALSE; 6567 6568 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 6569 { 6570 TI_DBG1(("satStartStopUnitCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 6571 6572 /* IMMED == 0 */ 6573 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 6574 { 6575 TI_DBG1(("satStartStopUnitCB: immed bit 0\n")); 6576 satSetSensePayload( pSense, 6577 SCSI_SNSKEY_ABORTED_COMMAND, 6578 0, 6579 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6580 satOrgIOContext); 6581 6582 ostiInitiatorIOCompleted( tiRoot, 6583 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 6584 tiIOSuccess, 6585 SCSI_STAT_CHECK_CONDITION, 6586 satOrgIOContext->pTiSenseData, 6587 satOrgIOContext->interruptContext ); 6588 6589 6590 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6591 satFreeIntIoResource( tiRoot, 6592 satDevData, 6593 satIntIo); 6594 } 6595 /* IMMED == 1 */ 6596 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK) 6597 { 6598 TI_DBG1(("satStartStopUnitCB: immed bit 1\n")); 6599 satSetDeferredSensePayload( pSense, 6600 SCSI_SNSKEY_ABORTED_COMMAND, 6601 0, 6602 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6603 satOrgIOContext); 6604 6605 ostiInitiatorIOCompleted( tiRoot, 6606 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 6607 tiIOSuccess, 6608 SCSI_STAT_CHECK_CONDITION, 6609 satOrgIOContext->pTiSenseData, 6610 satOrgIOContext->interruptContext ); 6611 6612 6613 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6614 satFreeIntIoResource( tiRoot, 6615 satDevData, 6616 satIntIo); 6617 } 6618 6619 6620 6621 return; 6622 } 6623 6624 if (agIOStatus != OSSA_IO_SUCCESS) 6625 { 6626 /* only agsaFisRegDeviceToHost_t is expected */ 6627 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 6628 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 6629 } 6630 /* 6631 checking IO status, FIS type and error status 6632 */ 6633 if( agIOStatus != OSSA_IO_SUCCESS) 6634 { 6635 if( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 6636 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 6637 ) 6638 { 6639 /* for debugging */ 6640 if( agIOStatus != OSSA_IO_SUCCESS) 6641 { 6642 TI_DBG1(("satStartStopUnitCB: FAILED, NOT IO_SUCCESS\n")); 6643 } 6644 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 6645 { 6646 TI_DBG1(("satStartStopUnitCB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 6647 } 6648 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 6649 (ataStatus & DF_ATA_STATUS_MASK) 6650 ) 6651 { 6652 TI_DBG1(("satStartStopUnitCB: FAILED, FAILED, error status\n")); 6653 } 6654 6655 6656 /* Process abort case */ 6657 if (agIOStatus == OSSA_IO_ABORTED) 6658 { 6659 satProcessAbort(tiRoot, 6660 tiOrgIORequest, 6661 satOrgIOContext 6662 ); 6663 6664 6665 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6666 6667 satFreeIntIoResource( tiRoot, 6668 satDevData, 6669 satIntIo); 6670 return; 6671 } 6672 6673 switch (hostToDevFis->h.command) 6674 { 6675 case SAT_FLUSH_CACHE: /* fall through */ 6676 case SAT_FLUSH_CACHE_EXT: 6677 TI_DBG1(("satStartStopUnitCB: SAT_FLUSH_CACHE(_EXT)\n")); 6678 /* check immed bit in scsi command */ 6679 /* IMMED == 0 */ 6680 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 6681 { 6682 satSetSensePayload( pSense, 6683 SCSI_SNSKEY_ABORTED_COMMAND, 6684 0, 6685 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6686 satOrgIOContext); 6687 6688 ostiInitiatorIOCompleted( tiRoot, 6689 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 6690 tiIOSuccess, 6691 SCSI_STAT_CHECK_CONDITION, 6692 satOrgIOContext->pTiSenseData, 6693 satOrgIOContext->interruptContext ); 6694 6695 6696 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6697 6698 satFreeIntIoResource( tiRoot, 6699 satDevData, 6700 satIntIo); 6701 } 6702 /* IMMED == 1 */ 6703 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK) 6704 { 6705 satSetDeferredSensePayload( pSense, 6706 SCSI_SNSKEY_ABORTED_COMMAND, 6707 0, 6708 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6709 satOrgIOContext); 6710 6711 ostiInitiatorIOCompleted( tiRoot, 6712 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 6713 tiIOSuccess, 6714 SCSI_STAT_CHECK_CONDITION, 6715 satOrgIOContext->pTiSenseData, 6716 satOrgIOContext->interruptContext ); 6717 6718 6719 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6720 6721 satFreeIntIoResource( tiRoot, 6722 satDevData, 6723 satIntIo); 6724 } 6725 break; 6726 case SAT_STANDBY: 6727 TI_DBG5(("satStartStopUnitCB: SAT_STANDBY\n")); 6728 /* check immed bit in scsi command */ 6729 /* IMMED == 0 */ 6730 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 6731 { 6732 satSetSensePayload( pSense, 6733 SCSI_SNSKEY_ABORTED_COMMAND, 6734 0, 6735 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6736 satOrgIOContext); 6737 6738 ostiInitiatorIOCompleted( tiRoot, 6739 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 6740 tiIOSuccess, 6741 SCSI_STAT_CHECK_CONDITION, 6742 satOrgIOContext->pTiSenseData, 6743 satOrgIOContext->interruptContext ); 6744 6745 6746 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6747 6748 satFreeIntIoResource( tiRoot, 6749 satDevData, 6750 satIntIo); 6751 } 6752 /* IMMED == 1 */ 6753 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK) 6754 { 6755 satSetDeferredSensePayload( pSense, 6756 SCSI_SNSKEY_ABORTED_COMMAND, 6757 0, 6758 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6759 satOrgIOContext); 6760 6761 ostiInitiatorIOCompleted( tiRoot, 6762 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 6763 tiIOSuccess, 6764 SCSI_STAT_CHECK_CONDITION, 6765 satOrgIOContext->pTiSenseData, 6766 satOrgIOContext->interruptContext ); 6767 6768 6769 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6770 6771 satFreeIntIoResource( tiRoot, 6772 satDevData, 6773 satIntIo); 6774 } 6775 break; 6776 case SAT_READ_VERIFY_SECTORS: /* fall through */ 6777 case SAT_READ_VERIFY_SECTORS_EXT: 6778 TI_DBG5(("satStartStopUnitCB: SAT_READ_VERIFY_SECTORS(_EXT)\n")); 6779 /* IMMED == 0 */ 6780 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 6781 { 6782 satSetSensePayload( pSense, 6783 SCSI_SNSKEY_ABORTED_COMMAND, 6784 0, 6785 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6786 satOrgIOContext); 6787 6788 ostiInitiatorIOCompleted( tiRoot, 6789 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 6790 tiIOSuccess, 6791 SCSI_STAT_CHECK_CONDITION, 6792 satOrgIOContext->pTiSenseData, 6793 satOrgIOContext->interruptContext ); 6794 6795 6796 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6797 6798 satFreeIntIoResource( tiRoot, 6799 satDevData, 6800 satIntIo); 6801 } 6802 /* IMMED == 1 */ 6803 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK) 6804 { 6805 satSetDeferredSensePayload( pSense, 6806 SCSI_SNSKEY_ABORTED_COMMAND, 6807 0, 6808 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6809 satOrgIOContext); 6810 6811 ostiInitiatorIOCompleted( tiRoot, 6812 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 6813 tiIOSuccess, 6814 SCSI_STAT_CHECK_CONDITION, 6815 satOrgIOContext->pTiSenseData, 6816 satOrgIOContext->interruptContext ); 6817 6818 6819 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6820 6821 satFreeIntIoResource( tiRoot, 6822 satDevData, 6823 satIntIo); 6824 } 6825 break; 6826 case SAT_MEDIA_EJECT: 6827 TI_DBG5(("satStartStopUnitCB: SAT_MEDIA_EJECT\n")); 6828 /* IMMED == 0 */ 6829 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 6830 { 6831 satSetSensePayload( pSense, 6832 SCSI_SNSKEY_ABORTED_COMMAND, 6833 0, 6834 SCSI_SNSCODE_MEDIA_LOAD_OR_EJECT_FAILED, 6835 satOrgIOContext); 6836 6837 ostiInitiatorIOCompleted( tiRoot, 6838 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 6839 tiIOSuccess, 6840 SCSI_STAT_CHECK_CONDITION, 6841 satOrgIOContext->pTiSenseData, 6842 satOrgIOContext->interruptContext ); 6843 6844 6845 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6846 6847 satFreeIntIoResource( tiRoot, 6848 satDevData, 6849 satIntIo); 6850 } 6851 /* IMMED == 1 */ 6852 if ( scsiCmnd->cdb[1] & SCSI_IMMED_MASK) 6853 { 6854 satSetDeferredSensePayload( pSense, 6855 SCSI_SNSKEY_ABORTED_COMMAND, 6856 0, 6857 SCSI_SNSCODE_MEDIA_LOAD_OR_EJECT_FAILED, 6858 satOrgIOContext); 6859 6860 ostiInitiatorIOCompleted( tiRoot, 6861 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 6862 tiIOSuccess, 6863 SCSI_STAT_CHECK_CONDITION, 6864 satOrgIOContext->pTiSenseData, 6865 satOrgIOContext->interruptContext ); 6866 6867 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6868 6869 satFreeIntIoResource( tiRoot, 6870 satDevData, 6871 satIntIo); 6872 } 6873 break; 6874 default: 6875 /* unspecified case, return no sense and no addition info */ 6876 TI_DBG5(("satStartStopUnitCB: default command %d\n", hostToDevFis->h.command)); 6877 satSetSensePayload( pSense, 6878 SCSI_SNSKEY_NO_SENSE, 6879 0, 6880 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 6881 satOrgIOContext); 6882 6883 ostiInitiatorIOCompleted( tiRoot, 6884 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 6885 tiIOSuccess, 6886 SCSI_STAT_CHECK_CONDITION, 6887 satOrgIOContext->pTiSenseData, 6888 satOrgIOContext->interruptContext ); 6889 6890 6891 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6892 6893 satFreeIntIoResource( tiRoot, 6894 satDevData, 6895 satIntIo); 6896 break; 6897 } /* switch */ 6898 6899 return; 6900 } /* error check */ 6901 } 6902 6903 /* ATA command completes sucessfully */ 6904 switch (hostToDevFis->h.command) 6905 { 6906 case SAT_FLUSH_CACHE: /* fall through */ 6907 case SAT_FLUSH_CACHE_EXT: 6908 TI_DBG5(("satStartStopUnitCB: SAT_READ_VERIFY_SECTORS(_EXT) success case\n")); 6909 6910 6911 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 6912 6913 /* done with SAT_FLUSH_CACHE(_EXT) */ 6914 satFreeIntIoResource( tiRoot, 6915 satDevData, 6916 satIntIo); 6917 6918 /* at this point, successful SAT_READ_VERIFY_SECTORS(_EXT) 6919 send SAT_SATNDBY 6920 */ 6921 satNewIntIo = satAllocIntIoResource( tiRoot, 6922 tiOrgIORequest, 6923 satDevData, 6924 0, 6925 satNewIntIo); 6926 if (satNewIntIo == agNULL) 6927 { 6928 /* memory allocation failure */ 6929 satFreeIntIoResource( tiRoot, 6930 satDevData, 6931 satNewIntIo); 6932 /* IMMED == 0 */ 6933 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 6934 { 6935 satSetSensePayload( pSense, 6936 SCSI_SNSKEY_ABORTED_COMMAND, 6937 0, 6938 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6939 satOrgIOContext); 6940 } 6941 else /* IMMED == 1 */ 6942 { 6943 satSetDeferredSensePayload( pSense, 6944 SCSI_SNSKEY_ABORTED_COMMAND, 6945 0, 6946 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6947 satOrgIOContext); 6948 } 6949 ostiInitiatorIOCompleted( tiRoot, 6950 tiOrgIORequest, 6951 tiIOSuccess, 6952 SCSI_STAT_CHECK_CONDITION, 6953 satOrgIOContext->pTiSenseData, 6954 satOrgIOContext->interruptContext ); 6955 6956 TI_DBG1(("satStartStopUnitCB: momory allocation fails\n")); 6957 return; 6958 } /* end of memory allocation failure */ 6959 6960 /* 6961 * Need to initialize all the fields within satIOContext 6962 */ 6963 6964 satNewIOContext = satPrepareNewIO( 6965 satNewIntIo, 6966 tiOrgIORequest, 6967 satDevData, 6968 scsiCmnd, 6969 satOrgIOContext 6970 ); 6971 6972 /* sending SAT_STANDBY */ 6973 status = satStartStopUnit_1( tiRoot, 6974 &satNewIntIo->satIntTiIORequest, 6975 satNewIOContext->ptiDeviceHandle, 6976 &satNewIntIo->satIntTiScsiXchg, 6977 satNewIOContext); 6978 6979 if (status != tiSuccess) 6980 { 6981 /* sending SAT_CHECK_POWER_MODE fails */ 6982 satFreeIntIoResource( tiRoot, 6983 satDevData, 6984 satNewIntIo); 6985 6986 /* IMMED == 0 */ 6987 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 6988 { 6989 satSetSensePayload( pSense, 6990 SCSI_SNSKEY_ABORTED_COMMAND, 6991 0, 6992 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 6993 satOrgIOContext); 6994 } 6995 else /* IMMED == 1 */ 6996 { 6997 satSetDeferredSensePayload( pSense, 6998 SCSI_SNSKEY_ABORTED_COMMAND, 6999 0, 7000 SCSI_SNSCODE_COMMAND_SEQUENCE_ERROR, 7001 satOrgIOContext); 7002 } 7003 ostiInitiatorIOCompleted( tiRoot, 7004 tiOrgIORequest, 7005 tiIOSuccess, 7006 SCSI_STAT_CHECK_CONDITION, 7007 satOrgIOContext->pTiSenseData, 7008 satOrgIOContext->interruptContext ); 7009 7010 TI_DBG1(("satStartStopUnitCB: calling satStartStopUnit_1 fails\n")); 7011 return; 7012 } 7013 break; 7014 case SAT_STANDBY: 7015 TI_DBG5(("satStartStopUnitCB: SAT_STANDBY success case\n")); 7016 7017 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7018 7019 /* done with SAT_STANDBY */ 7020 satFreeIntIoResource( tiRoot, 7021 satDevData, 7022 satIntIo); 7023 /* 7024 if immed == 0, return good status 7025 */ 7026 /* IMMED == 0 */ 7027 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 7028 { 7029 ostiInitiatorIOCompleted( tiRoot, 7030 tiOrgIORequest, 7031 tiIOSuccess, 7032 SCSI_STAT_GOOD, 7033 agNULL, 7034 satOrgIOContext->interruptContext ); 7035 } 7036 satDevData->satStopState = agTRUE; 7037 break; 7038 case SAT_READ_VERIFY_SECTORS: /* fall through */ 7039 case SAT_READ_VERIFY_SECTORS_EXT: 7040 TI_DBG5(("satStartStopUnitCB: SAT_READ_VERIFY_SECTORS(_EXT) success case\n")); 7041 7042 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7043 7044 /* done with SAT_READ_VERIFY_SECTORS(_EXT) */ 7045 satFreeIntIoResource( tiRoot, 7046 satDevData, 7047 satIntIo); 7048 /* 7049 if immed == 0, return good status 7050 */ 7051 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 7052 { 7053 ostiInitiatorIOCompleted( tiRoot, 7054 tiOrgIORequest, 7055 tiIOSuccess, 7056 SCSI_STAT_GOOD, 7057 agNULL, 7058 satOrgIOContext->interruptContext ); 7059 } 7060 /* 7061 if immed == 0, return good status 7062 */ 7063 /* 7064 don't forget to check and set driver state; Active power state 7065 */ 7066 satDevData->satStopState = agFALSE; 7067 break; 7068 case SAT_MEDIA_EJECT: 7069 TI_DBG5(("satStartStopUnitCB: SAT_MEDIA_EJECT success case\n")); 7070 7071 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7072 7073 /* done with SAT_READ_VERIFY_SECTORS(_EXT) */ 7074 satFreeIntIoResource( tiRoot, 7075 satDevData, 7076 satIntIo); 7077 /* 7078 if immed == 0, return good status 7079 */ 7080 if (!( scsiCmnd->cdb[1] & SCSI_IMMED_MASK)) 7081 { 7082 ostiInitiatorIOCompleted( tiRoot, 7083 tiOrgIORequest, 7084 tiIOSuccess, 7085 SCSI_STAT_GOOD, 7086 agNULL, 7087 satOrgIOContext->interruptContext ); 7088 } 7089 break; 7090 default: 7091 TI_DBG1(("satStartStopUnitCB:success but error default case command 0x%x\n", hostToDevFis->h.command)); 7092 7093 /* unspecified case, return no sense and no addition info */ 7094 satSetSensePayload( pSense, 7095 SCSI_SNSKEY_NO_SENSE, 7096 0, 7097 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 7098 satOrgIOContext); 7099 7100 ostiInitiatorIOCompleted( tiRoot, 7101 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 7102 tiIOSuccess, 7103 SCSI_STAT_CHECK_CONDITION, 7104 satOrgIOContext->pTiSenseData, 7105 satOrgIOContext->interruptContext ); 7106 7107 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7108 7109 satFreeIntIoResource( tiRoot, 7110 satDevData, 7111 satIntIo); 7112 break; 7113 } 7114 return; 7115 } 7116 7117 /***************************************************************************** 7118 *! \brief satSendDiagnosticCB 7119 * 7120 * This routine is a callback function called from ossaSATACompleted(). 7121 * This CB routine deals with Send Diagnostic completion. 7122 * 7123 * \param agRoot: Handles for this instance of SAS/SATA hardware 7124 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 7125 * \param agIOStatus: Status of completed I/O. 7126 * \param agFirstDword:Pointer to the four bytes of FIS. 7127 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 7128 * length. 7129 * \param agParam: Additional info based on status. 7130 * \param ioContext: Pointer to satIOContext_t. 7131 * 7132 * \return: none 7133 * 7134 *****************************************************************************/ 7135 void satSendDiagnosticCB( 7136 agsaRoot_t *agRoot, 7137 agsaIORequest_t *agIORequest, 7138 bit32 agIOStatus, 7139 agsaFisHeader_t *agFirstDword, 7140 bit32 agIOInfoLen, 7141 void *agParam, 7142 void *ioContext 7143 ) 7144 { 7145 /* 7146 In the process of SendDiagnotic 7147 Process READ VERIFY SECTOR(S) EXT two time 7148 Process SMART ECECUTE OFF-LINE IMMEDIATE 7149 */ 7150 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7151 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7152 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 7153 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 7154 tdIORequestBody_t *tdIORequestBody; 7155 tdIORequestBody_t *tdOrgIORequestBody; 7156 satIOContext_t *satIOContext; 7157 satIOContext_t *satOrgIOContext; 7158 satIOContext_t *satNewIOContext; 7159 satInternalIo_t *satIntIo; 7160 satInternalIo_t *satNewIntIo = agNULL; 7161 satDeviceData_t *satDevData; 7162 scsiRspSense_t *pSense; 7163 tiIniScsiCmnd_t *scsiCmnd; 7164 tiIORequest_t *tiOrgIORequest; 7165 7166 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 7167 bit32 ataStatus = 0; 7168 bit32 status; 7169 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 7170 7171 7172 TI_DBG5(("satSendDiagnosticCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 7173 7174 /* internally generate tiIOContext */ 7175 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 7176 satIOContext = (satIOContext_t *) ioContext; 7177 satIntIo = satIOContext->satIntIoContext; 7178 satDevData = satIOContext->pSatDevData; 7179 hostToDevFis = satIOContext->pFis; 7180 7181 if (satIntIo == agNULL) 7182 { 7183 TI_DBG4(("satSendDiagnosticCB: External satInternalIo_t satIntIoContext\n")); 7184 satOrgIOContext = satIOContext; 7185 tiOrgIORequest = tdIORequestBody->tiIORequest; 7186 pSense = satOrgIOContext->pSense; 7187 scsiCmnd = satOrgIOContext->pScsiCmnd; 7188 } 7189 else 7190 { 7191 TI_DBG4(("satSendDiagnosticCB: Internal satInternalIo_t satIntIoContext\n")); 7192 satOrgIOContext = satIOContext->satOrgIOContext; 7193 if (satOrgIOContext == agNULL) 7194 { 7195 TI_DBG4(("satSendDiagnosticCB: satOrgIOContext is NULL, wrong\n")); 7196 return; 7197 } 7198 else 7199 { 7200 TI_DBG4(("satSendDiagnosticCB: satOrgIOContext is NOT NULL\n")); 7201 } 7202 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 7203 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 7204 pSense = satOrgIOContext->pSense; 7205 scsiCmnd = satOrgIOContext->pScsiCmnd; 7206 } 7207 7208 tdIORequestBody->ioCompleted = agTRUE; 7209 tdIORequestBody->ioStarted = agFALSE; 7210 7211 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 7212 { 7213 TI_DBG1(("satSendDiagnosticCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 7214 satDevData->satVerifyState = 0; 7215 satDevData->satBGPendingDiag = agFALSE; 7216 7217 if (hostToDevFis->d.lbaLow != 0x01 && hostToDevFis->d.lbaLow != 0x02) 7218 { 7219 /* no completion for background send diagnotic. It is done in satSendDiagnostic() */ 7220 ostiInitiatorIOCompleted ( 7221 tiRoot, 7222 tiOrgIORequest, 7223 tiIOFailed, 7224 tiDetailOtherError, 7225 agNULL, 7226 satOrgIOContext->interruptContext 7227 ); 7228 } 7229 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7230 7231 satFreeIntIoResource( tiRoot, 7232 satDevData, 7233 satIntIo); 7234 return; 7235 7236 } 7237 7238 if (agIOStatus != OSSA_IO_SUCCESS) 7239 { 7240 /* only agsaFisRegDeviceToHost_t is expected */ 7241 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 7242 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 7243 } 7244 7245 TI_DBG5(("satSendDiagnosticCB: fis command 0x%x\n", hostToDevFis->h.command)); 7246 7247 if( agIOStatus != OSSA_IO_SUCCESS) 7248 { 7249 /* 7250 checking IO status, FIS type and error status 7251 */ 7252 satDevData->satVerifyState = 0; 7253 satDevData->satBGPendingDiag = agFALSE; 7254 7255 if( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 7256 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 7257 ) 7258 { 7259 7260 /* for debugging */ 7261 if( agIOStatus != OSSA_IO_SUCCESS) 7262 { 7263 if ( (hostToDevFis->h.command == SAT_SMART_RETURN_STATUS) || 7264 (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT) ) 7265 { 7266 TI_DBG1(("satSendDiagnosticCB: FAILED, NOT IO_SUCCESS and SAT_READ_VERIFY_SECTORS(_EXT)\n")); 7267 } 7268 else 7269 { 7270 TI_DBG1(("satSendDiagnosticCB: FAILED, NOT IO_SUCCESS and SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE\n")); 7271 } 7272 } 7273 7274 /* for debugging */ 7275 if( statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 7276 { 7277 if ( (hostToDevFis->h.command == SAT_SMART_RETURN_STATUS) || 7278 (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT) ) 7279 { 7280 TI_DBG1(("satSendDiagnosticCB: FAILED, Wrong FIS type 0x%x and SAT_READ_VERIFY_SECTORS(_EXT)\n", statDevToHostFisHeader->fisType)); 7281 } 7282 else 7283 { 7284 TI_DBG1(("satSendDiagnosticCB: FAILED, Wrong FIS type 0x%x and SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE\n",statDevToHostFisHeader->fisType)); 7285 } 7286 } 7287 7288 /* for debugging */ 7289 if ( (ataStatus & ERR_ATA_STATUS_MASK) || 7290 (ataStatus & DF_ATA_STATUS_MASK) 7291 ) 7292 { 7293 if ( (hostToDevFis->h.command == SAT_SMART_RETURN_STATUS) || 7294 (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT) ) 7295 { 7296 TI_DBG1(("satSendDiagnosticCB: FAILED, error status and SAT_READ_VERIFY_SECTORS(_EXT)\n")); 7297 } 7298 else 7299 { 7300 TI_DBG1(("satSendDiagnosticCB: FAILED, error status and SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE\n")); 7301 } 7302 } 7303 7304 /* Process abort case */ 7305 if (agIOStatus == OSSA_IO_ABORTED) 7306 { 7307 satProcessAbort(tiRoot, 7308 tiOrgIORequest, 7309 satOrgIOContext 7310 ); 7311 7312 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7313 7314 satFreeIntIoResource( tiRoot, 7315 satDevData, 7316 satIntIo); 7317 return; 7318 } 7319 7320 if ( (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS) || 7321 (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT) ) 7322 { 7323 /* report using the original tiIOrequst */ 7324 /* failed during sending SAT_READ_VERIFY_SECTORS(_EXT) */ 7325 satSetSensePayload( pSense, 7326 SCSI_SNSKEY_HARDWARE_ERROR, 7327 0, 7328 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST, 7329 satOrgIOContext); 7330 7331 ostiInitiatorIOCompleted( tiRoot, 7332 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 7333 tiIOSuccess, 7334 SCSI_STAT_CHECK_CONDITION, 7335 satOrgIOContext->pTiSenseData, 7336 satOrgIOContext->interruptContext ); 7337 7338 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7339 7340 satFreeIntIoResource( tiRoot, 7341 satDevData, 7342 satIntIo); 7343 return; 7344 } 7345 else 7346 { 7347 /* report using the original tiIOrequst */ 7348 /* failed during sending SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE */ 7349 satSetSensePayload( pSense, 7350 SCSI_SNSKEY_HARDWARE_ERROR, 7351 0, 7352 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST, 7353 satOrgIOContext); 7354 7355 if (hostToDevFis->d.lbaLow != 0x01 && hostToDevFis->d.lbaLow != 0x02) 7356 { 7357 /* no completion for background send diagnotic. It is done in satSendDiagnostic() */ 7358 ostiInitiatorIOCompleted( tiRoot, 7359 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 7360 tiIOSuccess, 7361 SCSI_STAT_CHECK_CONDITION, 7362 satOrgIOContext->pTiSenseData, 7363 satOrgIOContext->interruptContext ); 7364 7365 } 7366 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7367 7368 satFreeIntIoResource( tiRoot, 7369 satDevData, 7370 satIntIo); 7371 return; 7372 } 7373 } 7374 } 7375 7376 /* processing success case */ 7377 switch (hostToDevFis->h.command) 7378 { 7379 case SAT_READ_VERIFY_SECTORS: /* fall through */ 7380 case SAT_READ_VERIFY_SECTORS_EXT: 7381 TI_DBG5(("satSendDiagnosticCB: SAT_READ_VERIFY_SECTORS(_EXT) case\n")); 7382 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 7383 satDevData->satVerifyState++; 7384 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 7385 TI_DBG5(("satSendDiagnosticCB: satVerifyState %d\n",satDevData->satVerifyState)); 7386 7387 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7388 7389 /* done with internally genereated AT_READ_VERIFY_SECTORS(_EXT) */ 7390 satFreeIntIoResource( tiRoot, 7391 satDevData, 7392 satIntIo); 7393 7394 if (satDevData->satVerifyState == 3) 7395 { 7396 /* reset satVerifyState */ 7397 satDevData->satVerifyState = 0; 7398 /* return GOOD status */ 7399 TI_DBG5(("satSendDiagnosticCB: return GOOD status\n")); 7400 ostiInitiatorIOCompleted( tiRoot, 7401 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 7402 tiIOSuccess, 7403 SCSI_STAT_GOOD, 7404 agNULL, 7405 satOrgIOContext->interruptContext ); 7406 return; 7407 } 7408 else 7409 { 7410 7411 /* prepare SAT_READ_VERIFY_SECTORS(_EXT) */ 7412 satNewIntIo = satAllocIntIoResource( tiRoot, 7413 tiOrgIORequest, 7414 satDevData, 7415 0, 7416 satNewIntIo); 7417 if (satNewIntIo == agNULL) 7418 { 7419 /* reset satVerifyState */ 7420 satDevData->satVerifyState = 0; 7421 /* memory allocation failure */ 7422 satFreeIntIoResource( tiRoot, 7423 satDevData, 7424 satNewIntIo); 7425 7426 /* failed as a part of sending SAT_READ_VERIFY_SECTORS(_EXT) */ 7427 satSetSensePayload( pSense, 7428 SCSI_SNSKEY_HARDWARE_ERROR, 7429 0, 7430 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST, 7431 satOrgIOContext); 7432 7433 ostiInitiatorIOCompleted( tiRoot, 7434 tiOrgIORequest, 7435 tiIOSuccess, 7436 SCSI_STAT_CHECK_CONDITION, 7437 satOrgIOContext->pTiSenseData, 7438 satOrgIOContext->interruptContext ); 7439 7440 TI_DBG1(("satSendDiagnosticCB: momory allocation fails\n")); 7441 return; 7442 } /* end of memory allocation failure */ 7443 7444 /* 7445 * Need to initialize all the fields within satIOContext 7446 */ 7447 7448 satNewIOContext = satPrepareNewIO( 7449 satNewIntIo, 7450 tiOrgIORequest, 7451 satDevData, 7452 scsiCmnd, 7453 satOrgIOContext 7454 ); 7455 7456 if (satDevData->satVerifyState == 1) 7457 { 7458 /* sending SAT_CHECK_POWER_MODE */ 7459 status = satSendDiagnostic_1( tiRoot, 7460 &satNewIntIo->satIntTiIORequest, 7461 satNewIOContext->ptiDeviceHandle, 7462 &satNewIntIo->satIntTiScsiXchg, 7463 satNewIOContext); 7464 } 7465 else 7466 { 7467 /* satDevData->satVerifyState == 2 */ 7468 status = satSendDiagnostic_2( tiRoot, 7469 &satNewIntIo->satIntTiIORequest, 7470 satNewIOContext->ptiDeviceHandle, 7471 &satNewIntIo->satIntTiScsiXchg, 7472 satNewIOContext); 7473 } 7474 7475 if (status != tiSuccess) 7476 { 7477 /* sending SAT_READ_VERIFY_SECTORS(_EXT) fails */ 7478 satFreeIntIoResource( tiRoot, 7479 satDevData, 7480 satNewIntIo); 7481 7482 /* failed during sending SAT_READ_VERIFY_SECTORS(_EXT) */ 7483 satSetSensePayload( pSense, 7484 SCSI_SNSKEY_HARDWARE_ERROR, 7485 0, 7486 SCSI_SNSCODE_LOGICAL_UNIT_FAILED_SELF_TEST, 7487 satOrgIOContext); 7488 7489 ostiInitiatorIOCompleted( tiRoot, 7490 tiOrgIORequest, 7491 tiIOSuccess, 7492 SCSI_STAT_CHECK_CONDITION, 7493 satOrgIOContext->pTiSenseData, 7494 satOrgIOContext->interruptContext ); 7495 7496 /* reset satVerifyState */ 7497 satDevData->satVerifyState = 0; 7498 TI_DBG1(("satSendDiagnosticCB: calling satSendDiagnostic_1 or _2 fails\n")); 7499 return; 7500 } 7501 } /* satDevData->satVerifyState == 1 or 2 */ 7502 7503 break; 7504 case SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE: 7505 TI_DBG5(("satSendDiagnosticCB: SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE case\n")); 7506 7507 satDevData->satBGPendingDiag = agFALSE; 7508 7509 if (hostToDevFis->d.lbaLow == 0x01 || hostToDevFis->d.lbaLow == 0x02) 7510 { 7511 /* for background send diagnostic, no completion here. It is done already. */ 7512 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7513 7514 /* done with AT_SMART_EXEUTE_OFF_LINE_IMMEDIATE */ 7515 satFreeIntIoResource( tiRoot, 7516 satDevData, 7517 satIntIo); 7518 TI_DBG5(("satSendDiagnosticCB: returning but no IOCompleted\n")); 7519 } 7520 else 7521 { 7522 TI_DBG5(("satSendDiagnosticCB: returning good status for senddiagnostic\n")); 7523 ostiInitiatorIOCompleted( tiRoot, 7524 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 7525 tiIOSuccess, 7526 SCSI_STAT_GOOD, 7527 agNULL, 7528 satOrgIOContext->interruptContext ); 7529 7530 7531 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7532 7533 /* done with AT_SMART_EXEUTE_OFF_LINE_IMMEDIATE */ 7534 satFreeIntIoResource( tiRoot, 7535 satDevData, 7536 satIntIo); 7537 } 7538 7539 break; 7540 default: 7541 TI_DBG1(("satSendDiagnosticCB: success but error default case command 0x%x\n", hostToDevFis->h.command)); 7542 /* unspecified case, return no sense and no addition info */ 7543 satSetSensePayload( pSense, 7544 SCSI_SNSKEY_NO_SENSE, 7545 0, 7546 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 7547 satOrgIOContext); 7548 7549 ostiInitiatorIOCompleted( tiRoot, 7550 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 7551 tiIOSuccess, 7552 SCSI_STAT_CHECK_CONDITION, 7553 satOrgIOContext->pTiSenseData, 7554 satOrgIOContext->interruptContext ); 7555 7556 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7557 7558 satFreeIntIoResource( tiRoot, 7559 satDevData, 7560 satIntIo); 7561 break; 7562 } 7563 return; 7564 } 7565 /***************************************************************************** 7566 *! \brief satRequestSenseCB 7567 * 7568 * This routine is a callback function called from ossaSATACompleted(). 7569 * This CB routine deals with Request Sense completion. 7570 * 7571 * \param agRoot: Handles for this instance of SAS/SATA hardware 7572 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 7573 * \param agIOStatus: Status of completed I/O. 7574 * \param agFirstDword:Pointer to the four bytes of FIS. 7575 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 7576 * length. 7577 * \param agParam: Additional info based on status. 7578 * \param ioContext: Pointer to satIOContext_t. 7579 * 7580 * \return: none 7581 * 7582 *****************************************************************************/ 7583 /* 7584 CB for internnaly generated SMART_RETURN_STATUS and SAT_CHECK_POWER_MODE 7585 in the process of RequestSense 7586 7587 */ 7588 void satRequestSenseCB( 7589 agsaRoot_t *agRoot, 7590 agsaIORequest_t *agIORequest, 7591 bit32 agIOStatus, 7592 agsaFisHeader_t *agFirstDword, 7593 bit32 agIOInfoLen, 7594 void *agParam, 7595 void *ioContext 7596 ) 7597 { 7598 /* ATA Vol 1, p299 SAT_SMART_RETURN_STATUS */ 7599 /* 7600 if threshold exceeds, return SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE 7601 else call satRequestSense_1 to send CHECK_POWER_MODE 7602 */ 7603 7604 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 7605 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 7606 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 7607 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 7608 tdIORequestBody_t *tdIORequestBody; 7609 tdIORequestBody_t *tdOrgIORequestBody; 7610 satIOContext_t *satIOContext; 7611 satIOContext_t *satOrgIOContext; 7612 satIOContext_t *satNewIOContext; 7613 satInternalIo_t *satIntIo; 7614 satInternalIo_t *satNewIntIo = agNULL; 7615 satDeviceData_t *satDevData; 7616 scsiRspSense_t *pSense; 7617 tiIORequest_t *tiOrgIORequest; 7618 tiIniScsiCmnd_t *scsiCmnd; 7619 7620 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 7621 bit32 ataStatus = 0; 7622 bit32 status; 7623 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 7624 agsaFisRegD2HData_t statDevToHostFisData; 7625 bit32 lenReceived = 0; 7626 bit32 dataLength; 7627 7628 TI_DBG4(("satRequestSenseCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 7629 7630 /* internally generate tiIOContext */ 7631 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 7632 satIOContext = (satIOContext_t *) ioContext; 7633 satIntIo = satIOContext->satIntIoContext; 7634 satDevData = satIOContext->pSatDevData; 7635 hostToDevFis = satIOContext->pFis; 7636 7637 /*ttttttthe one */ 7638 if (satIntIo == agNULL) 7639 { 7640 TI_DBG4(("satRequestSenseCB: External satInternalIo_t satIntIoContext\n")); 7641 satOrgIOContext = satIOContext; 7642 tiOrgIORequest = tdIORequestBody->tiIORequest; 7643 if (satOrgIOContext->superIOFlag) 7644 { 7645 pSense = (scsiRspSense_t *)(((tiSuperScsiInitiatorRequest_t *)satOrgIOContext->tiScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense; 7646 } 7647 else 7648 { 7649 pSense = (scsiRspSense_t *)(((tiScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense; 7650 } 7651 scsiCmnd = satOrgIOContext->pScsiCmnd; 7652 } 7653 else 7654 { 7655 TI_DBG4(("satRequestSenseCB: Internal satInternalIo_t satIntIoContext\n")); 7656 satOrgIOContext = satIOContext->satOrgIOContext; 7657 if (satOrgIOContext == agNULL) 7658 { 7659 TI_DBG4(("satRequestSenseCB: satOrgIOContext is NULL, wrong\n")); 7660 return; 7661 } 7662 else 7663 { 7664 TI_DBG4(("satRequestSenseCB: satOrgIOContext is NOT NULL\n")); 7665 } 7666 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 7667 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 7668 7669 if (satOrgIOContext->superIOFlag) 7670 { 7671 pSense = (scsiRspSense_t *)(((tiSuperScsiInitiatorRequest_t *)satOrgIOContext->tiScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense; 7672 } 7673 else 7674 { 7675 pSense = (scsiRspSense_t *)(((tiScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->sglVirtualAddr);//satOrgIOContext->pSense; 7676 } 7677 scsiCmnd = satOrgIOContext->pScsiCmnd; 7678 } 7679 7680 tdIORequestBody->ioCompleted = agTRUE; 7681 tdIORequestBody->ioStarted = agFALSE; 7682 7683 TI_DBG4(("satRequestSenseCB: fis command 0x%x\n", hostToDevFis->h.command)); 7684 7685 lenReceived = scsiCmnd->cdb[4]; 7686 TI_DBG1(("satRequestSenseCB: lenReceived in CDB %d 0x%x\n", lenReceived,lenReceived)); 7687 7688 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 7689 { 7690 TI_DBG1(("satRequestSenseCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 7691 ostiInitiatorIOCompleted ( 7692 tiRoot, 7693 tiOrgIORequest, 7694 tiIOFailed, 7695 tiDetailOtherError, 7696 agNULL, 7697 satOrgIOContext->interruptContext 7698 ); 7699 7700 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7701 7702 satFreeIntIoResource( tiRoot, 7703 satDevData, 7704 satIntIo); 7705 7706 return; 7707 } 7708 7709 /* 7710 checking IO status, FIS type and error status 7711 */ 7712 if (agIOStatus != OSSA_IO_SUCCESS) 7713 { 7714 /* only agsaFisRegDeviceToHost_t is expected */ 7715 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 7716 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 7717 7718 /* for debugging */ 7719 if( statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 7720 { 7721 if (hostToDevFis->h.command == SAT_SMART_RETURN_STATUS) 7722 { 7723 TI_DBG1(("satRequestSenseCB: FAILED, Wrong FIS type 0x%x and SAT_SMART_RETURN_STATU\n", statDevToHostFisHeader->fisType)); 7724 } 7725 else 7726 { 7727 TI_DBG1(("satRequestSenseCB: FAILED, Wrong FIS type 0x%x and SAT_CHECK_POWER_MODE\n",statDevToHostFisHeader->fisType)); 7728 } 7729 } 7730 7731 /* for debugging */ 7732 if ( (ataStatus & ERR_ATA_STATUS_MASK) || 7733 (ataStatus & DF_ATA_STATUS_MASK) 7734 ) 7735 { 7736 if (hostToDevFis->h.command == SAT_SMART_RETURN_STATUS) 7737 { 7738 TI_DBG1(("satRequestSenseCB: FAILED, error status and SAT_SMART_RETURN_STATU\n")); 7739 } 7740 else 7741 { 7742 TI_DBG1(("satRequestSenseCB: FAILED, error status and SAT_CHECK_POWER_MODE\n")); 7743 } 7744 } 7745 7746 /* Process abort case */ 7747 if (agIOStatus == OSSA_IO_ABORTED) 7748 { 7749 satProcessAbort(tiRoot, 7750 tiOrgIORequest, 7751 satOrgIOContext 7752 ); 7753 7754 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7755 7756 satFreeIntIoResource( tiRoot, 7757 satDevData, 7758 satIntIo); 7759 return; 7760 } 7761 7762 if (hostToDevFis->h.command == SAT_SMART_RETURN_STATUS) 7763 { 7764 /* report using the original tiIOrequst */ 7765 /* failed during sending SMART RETURN STATUS */ 7766 satSetSensePayload( pSense, 7767 SCSI_SNSKEY_NO_SENSE, 7768 0, 7769 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE, 7770 satOrgIOContext); 7771 7772 if (SENSE_DATA_LENGTH < lenReceived) 7773 { 7774 /* underrun */ 7775 ostiInitiatorIOCompleted( tiRoot, 7776 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 7777 tiIOUnderRun, 7778 lenReceived - SENSE_DATA_LENGTH, 7779 agNULL, 7780 satOrgIOContext->interruptContext ); 7781 } 7782 else 7783 { 7784 ostiInitiatorIOCompleted( tiRoot, 7785 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 7786 tiIOSuccess, 7787 SCSI_STAT_GOOD, 7788 agNULL, 7789 satOrgIOContext->interruptContext ); 7790 } 7791 } 7792 else 7793 { 7794 /* report using the original tiIOrequst */ 7795 /* failed during sending SAT_CHECK_POWER_MODE */ 7796 satSetSensePayload( pSense, 7797 SCSI_SNSKEY_NO_SENSE, 7798 0, 7799 SCSI_SNSCODE_LOW_POWER_CONDITION_ON, 7800 satOrgIOContext); 7801 7802 if (SENSE_DATA_LENGTH < lenReceived) 7803 { 7804 /* underrun */ 7805 ostiInitiatorIOCompleted( tiRoot, 7806 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 7807 tiIOUnderRun, 7808 lenReceived - SENSE_DATA_LENGTH, 7809 agNULL, 7810 satOrgIOContext->interruptContext ); 7811 } 7812 else 7813 { 7814 ostiInitiatorIOCompleted( tiRoot, 7815 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 7816 tiIOSuccess, 7817 SCSI_STAT_GOOD, 7818 agNULL, 7819 satOrgIOContext->interruptContext ); 7820 } 7821 } 7822 7823 7824 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7825 7826 satFreeIntIoResource( tiRoot, 7827 satDevData, 7828 satIntIo); 7829 return; 7830 } 7831 7832 saFrameReadBlock(agRoot, agParam, 0, &statDevToHostFisData, sizeof(agsaFisRegD2HData_t)); 7833 7834 switch (hostToDevFis->h.command) 7835 { 7836 case SAT_SMART_RETURN_STATUS: 7837 TI_DBG4(("satRequestSenseCB: SAT_SMART_RETURN_STATUS case\n")); 7838 if (statDevToHostFisData.lbaMid == 0xF4 || statDevToHostFisData.lbaHigh == 0x2C) 7839 { 7840 /* threshold exceeds */ 7841 TI_DBG1(("satRequestSenseCB: threshold exceeds\n")); 7842 7843 7844 /* report using the original tiIOrequst */ 7845 /* failed during sending SMART RETURN STATUS */ 7846 satSetSensePayload( pSense, 7847 SCSI_SNSKEY_NO_SENSE, 7848 0, 7849 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE, 7850 satOrgIOContext); 7851 7852 if (SENSE_DATA_LENGTH < lenReceived) 7853 { 7854 /* underrun */ 7855 ostiInitiatorIOCompleted( tiRoot, 7856 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 7857 tiIOUnderRun, 7858 lenReceived - SENSE_DATA_LENGTH, 7859 agNULL, 7860 satOrgIOContext->interruptContext ); } 7861 else 7862 { 7863 ostiInitiatorIOCompleted( tiRoot, 7864 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 7865 tiIOSuccess, 7866 SCSI_STAT_GOOD, 7867 agNULL, 7868 satOrgIOContext->interruptContext ); } 7869 7870 7871 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7872 7873 satFreeIntIoResource( tiRoot, 7874 satDevData, 7875 satIntIo); 7876 return; 7877 } 7878 7879 7880 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 7881 7882 /* done with internally genereated SAT_SMART_RETURN_STATUS */ 7883 satFreeIntIoResource( tiRoot, 7884 satDevData, 7885 satIntIo); 7886 7887 /* at this point, successful SMART_RETURN_STATUS 7888 xmit SAT_CHECK_POWER_MODE 7889 */ 7890 if (satOrgIOContext->superIOFlag) 7891 { 7892 dataLength = ((tiSuperScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->scsiCmnd.expDataLength; 7893 } 7894 else 7895 { 7896 dataLength = ((tiScsiInitiatorRequest_t *) satOrgIOContext->tiScsiXchg)->scsiCmnd.expDataLength; 7897 } 7898 7899 satNewIntIo = satAllocIntIoResource( tiRoot, 7900 tiOrgIORequest, 7901 satDevData, 7902 dataLength, 7903 satNewIntIo); 7904 if (satNewIntIo == agNULL) 7905 { 7906 /* memory allocation failure */ 7907 satFreeIntIoResource( tiRoot, 7908 satDevData, 7909 satNewIntIo); 7910 7911 /* failed as a part of sending SMART RETURN STATUS */ 7912 satSetSensePayload( pSense, 7913 SCSI_SNSKEY_NO_SENSE, 7914 0, 7915 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE, 7916 satOrgIOContext); 7917 7918 if (SENSE_DATA_LENGTH < lenReceived) 7919 { 7920 /* underrun */ 7921 ostiInitiatorIOCompleted( tiRoot, 7922 tiOrgIORequest, 7923 tiIOUnderRun, 7924 lenReceived - SENSE_DATA_LENGTH, 7925 agNULL, 7926 satOrgIOContext->interruptContext ); 7927 } 7928 else 7929 { 7930 ostiInitiatorIOCompleted( tiRoot, 7931 tiOrgIORequest, 7932 tiIOSuccess, 7933 SCSI_STAT_GOOD, 7934 agNULL, 7935 satOrgIOContext->interruptContext ); 7936 } 7937 7938 TI_DBG1(("satRequestSenseCB: momory allocation fails\n")); 7939 return; 7940 } /* end of memory allocation failure */ 7941 7942 7943 /* 7944 * Need to initialize all the fields within satIOContext 7945 */ 7946 7947 satNewIOContext = satPrepareNewIO( 7948 satNewIntIo, 7949 tiOrgIORequest, 7950 satDevData, 7951 scsiCmnd, 7952 satOrgIOContext 7953 ); 7954 7955 /* sending SAT_CHECK_POWER_MODE */ 7956 status = satRequestSense_1( tiRoot, 7957 &satNewIntIo->satIntTiIORequest, 7958 satNewIOContext->ptiDeviceHandle, 7959 &satNewIntIo->satIntTiScsiXchg, 7960 satNewIOContext); 7961 7962 if (status != tiSuccess) 7963 { 7964 /* sending SAT_CHECK_POWER_MODE fails */ 7965 satFreeIntIoResource( tiRoot, 7966 satDevData, 7967 satNewIntIo); 7968 7969 /* failed during sending SAT_CHECK_POWER_MODE */ 7970 satSetSensePayload( pSense, 7971 SCSI_SNSKEY_NO_SENSE, 7972 0, 7973 SCSI_SNSCODE_LOW_POWER_CONDITION_ON, 7974 satOrgIOContext); 7975 7976 if (SENSE_DATA_LENGTH < lenReceived) 7977 { 7978 /* underrun */ 7979 ostiInitiatorIOCompleted( tiRoot, 7980 tiOrgIORequest, 7981 tiIOUnderRun, 7982 lenReceived - SENSE_DATA_LENGTH, 7983 agNULL, 7984 satOrgIOContext->interruptContext ); 7985 } 7986 else 7987 { 7988 ostiInitiatorIOCompleted( tiRoot, 7989 tiOrgIORequest, 7990 tiIOSuccess, 7991 SCSI_STAT_GOOD, 7992 agNULL, 7993 satOrgIOContext->interruptContext ); 7994 } 7995 7996 TI_DBG1(("satRequestSenseCB: calling satRequestSense_1 fails\n")); 7997 return; 7998 } 7999 8000 break; 8001 case SAT_CHECK_POWER_MODE: 8002 TI_DBG4(("satRequestSenseCB: SAT_CHECK_POWER_MODE case\n")); 8003 8004 /* check ATA STANDBY state */ 8005 if (statDevToHostFisData.sectorCount == 0x00) 8006 { 8007 /* in STANDBY */ 8008 TI_DBG1(("satRequestSenseCB: in standby\n")); 8009 8010 8011 /* report using the original tiIOrequst */ 8012 /* failed during sending SAT_CHECK_POWER_MODE */ 8013 satSetSensePayload( pSense, 8014 SCSI_SNSKEY_NO_SENSE, 8015 0, 8016 SCSI_SNSCODE_LOW_POWER_CONDITION_ON, 8017 satOrgIOContext); 8018 8019 if (SENSE_DATA_LENGTH < lenReceived) 8020 { 8021 /* underrun */ 8022 ostiInitiatorIOCompleted( tiRoot, 8023 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8024 tiIOUnderRun, 8025 lenReceived - SENSE_DATA_LENGTH, 8026 agNULL, 8027 satOrgIOContext->interruptContext ); 8028 } 8029 else 8030 { 8031 ostiInitiatorIOCompleted( tiRoot, 8032 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8033 tiIOSuccess, 8034 SCSI_STAT_GOOD, 8035 agNULL, 8036 satOrgIOContext->interruptContext ); 8037 } 8038 8039 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8040 8041 satFreeIntIoResource( tiRoot, 8042 satDevData, 8043 satIntIo); 8044 return; 8045 } 8046 8047 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8048 8049 /* done with internnaly generated SAT_CHECK_POWER_MODE */ 8050 satFreeIntIoResource( tiRoot, 8051 satDevData, 8052 satIntIo); 8053 8054 if (satDevData->satFormatState == agTRUE) 8055 { 8056 TI_DBG1(("satRequestSenseCB: in format\n")); 8057 8058 8059 /* report using the original tiIOrequst */ 8060 satSetSensePayload( pSense, 8061 SCSI_SNSKEY_NOT_READY, 8062 0, 8063 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_FORMAT_IN_PROGRESS, 8064 satOrgIOContext); 8065 8066 if (SENSE_DATA_LENGTH < lenReceived) 8067 { 8068 /* underrun */ 8069 ostiInitiatorIOCompleted( tiRoot, 8070 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8071 tiIOUnderRun, 8072 lenReceived - SENSE_DATA_LENGTH, 8073 agNULL, 8074 satOrgIOContext->interruptContext ); 8075 } 8076 else 8077 { 8078 ostiInitiatorIOCompleted( tiRoot, 8079 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8080 tiIOSuccess, 8081 SCSI_STAT_GOOD, 8082 agNULL, 8083 satOrgIOContext->interruptContext ); 8084 } 8085 8086 return; 8087 } 8088 8089 /* normal: returns good status for requestsense */ 8090 /* report using the original tiIOrequst */ 8091 satSetSensePayload( pSense, 8092 SCSI_SNSKEY_NO_SENSE, 8093 0, 8094 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8095 satOrgIOContext); 8096 TI_DBG4(("satRequestSenseCB: returning good status for requestsense\n")); 8097 if (SENSE_DATA_LENGTH < lenReceived) 8098 { 8099 /* underrun */ 8100 TI_DBG6(("satRequestSenseCB reporting underrun lenNeeded=0x%x lenReceived=0x%x tiIORequest=%p\n", 8101 SENSE_DATA_LENGTH, lenReceived, tiOrgIORequest)); 8102 ostiInitiatorIOCompleted( tiRoot, 8103 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8104 tiIOUnderRun, 8105 lenReceived - SENSE_DATA_LENGTH, 8106 agNULL, 8107 satOrgIOContext->interruptContext ); 8108 8109 } 8110 else 8111 { 8112 ostiInitiatorIOCompleted( tiRoot, 8113 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8114 tiIOSuccess, 8115 SCSI_STAT_GOOD, 8116 agNULL, 8117 satOrgIOContext->interruptContext ); 8118 } 8119 8120 break; 8121 default: 8122 TI_DBG1(("satRequestSenseCB: success but error default case command 0x%x\n", hostToDevFis->h.command)); 8123 /* pSense here is a part of satOrgIOContext */ 8124 pSense = satOrgIOContext->pTiSenseData->senseData; 8125 satOrgIOContext->pTiSenseData->senseLen = SENSE_DATA_LENGTH; 8126 /* unspecified case, return no sense and no addition info */ 8127 satSetSensePayload( pSense, 8128 SCSI_SNSKEY_NO_SENSE, 8129 0, 8130 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8131 satOrgIOContext); 8132 8133 ostiInitiatorIOCompleted( tiRoot, 8134 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8135 tiIOSuccess, 8136 SCSI_STAT_CHECK_CONDITION, 8137 satOrgIOContext->pTiSenseData, 8138 satOrgIOContext->interruptContext ); 8139 8140 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8141 8142 satFreeIntIoResource( tiRoot, 8143 satDevData, 8144 satIntIo); 8145 break; 8146 } /* switch */ 8147 8148 return; 8149 } 8150 8151 /***************************************************************************** 8152 *! \brief satSynchronizeCache10n16CB 8153 * 8154 * This routine is a callback function for satSynchronizeCache10 and 8155 * satSynchronizeCache1016() 8156 * 8157 * \param agRoot: Handles for this instance of SAS/SATA hardware 8158 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 8159 * \param agIOStatus: Status of completed I/O. 8160 * \param agFirstDword:Pointer to the four bytes of FIS. 8161 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 8162 * length. 8163 * \param agParam: Additional info based on status. 8164 * \param ioContext: Pointer to satIOContext_t. 8165 * 8166 * \return: none 8167 * 8168 *****************************************************************************/ 8169 void satSynchronizeCache10n16CB( 8170 agsaRoot_t *agRoot, 8171 agsaIORequest_t *agIORequest, 8172 bit32 agIOStatus, 8173 agsaFisHeader_t *agFirstDword, 8174 bit32 agIOInfoLen, 8175 void *agParam, 8176 void *ioContext 8177 ) 8178 { 8179 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 8180 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 8181 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 8182 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 8183 tdIORequestBody_t *tdIORequestBody; 8184 tdIORequestBody_t *tdOrgIORequestBody; 8185 satIOContext_t *satIOContext; 8186 satIOContext_t *satOrgIOContext; 8187 satInternalIo_t *satIntIo; 8188 satDeviceData_t *satDevData; 8189 8190 scsiRspSense_t *pSense; 8191 tiIniScsiCmnd_t *scsiCmnd; 8192 tiIORequest_t *tiOrgIORequest; 8193 8194 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 8195 bit32 ataStatus = 0; 8196 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 8197 8198 TI_DBG5(("satSynchronizeCache10n16CB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 8199 8200 /* internally generate tiIOContext */ 8201 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 8202 satIOContext = (satIOContext_t *) ioContext; 8203 satIntIo = satIOContext->satIntIoContext; 8204 satDevData = satIOContext->pSatDevData; 8205 hostToDevFis = satIOContext->pFis; 8206 8207 /* SPC: Self-Test Result Log page */ 8208 8209 if (satIntIo == agNULL) 8210 { 8211 TI_DBG4(("satSynchronizeCache10n16CB: External satInternalIo_t satIntIoContext\n")); 8212 satOrgIOContext = satIOContext; 8213 tiOrgIORequest = tdIORequestBody->tiIORequest; 8214 pSense = satIOContext->pSense; 8215 scsiCmnd = satIOContext->pScsiCmnd; 8216 } 8217 else 8218 { 8219 TI_DBG4(("satSynchronizeCache10n16CB: Internal satInternalIo_t satIntIoContext\n")); 8220 satOrgIOContext = satIOContext->satOrgIOContext; 8221 if (satOrgIOContext == agNULL) 8222 { 8223 TI_DBG4(("satSynchronizeCache10n16CB: satOrgIOContext is NULL, wrong\n")); 8224 return; 8225 } 8226 else 8227 { 8228 TI_DBG4(("satSynchronizeCache10n16CB: satOrgIOContext is NOT NULL\n")); 8229 } 8230 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 8231 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 8232 8233 pSense = satOrgIOContext->pSense; 8234 scsiCmnd = satOrgIOContext->pScsiCmnd; 8235 } 8236 8237 tdIORequestBody->ioCompleted = agTRUE; 8238 tdIORequestBody->ioStarted = agFALSE; 8239 8240 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 8241 { 8242 TI_DBG1(("satSynchronizeCache10n16CB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 8243 8244 ostiInitiatorIOCompleted ( 8245 tiRoot, 8246 tiOrgIORequest, 8247 tiIOFailed, 8248 tiDetailOtherError, 8249 agNULL, 8250 satOrgIOContext->interruptContext 8251 ); 8252 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8253 8254 satFreeIntIoResource( tiRoot, 8255 satDevData, 8256 satIntIo); 8257 return; 8258 } 8259 8260 if( agIOStatus != OSSA_IO_SUCCESS) 8261 { 8262 /* only agsaFisRegDeviceToHost_t is expected */ 8263 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 8264 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 8265 } 8266 8267 if( agIOStatus != OSSA_IO_SUCCESS) 8268 { 8269 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 8270 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 8271 ) 8272 { 8273 /* for debugging */ 8274 if( agIOStatus != OSSA_IO_SUCCESS) 8275 { 8276 TI_DBG1(("satSynchronizeCache10n16CB: FAILED, NOT IO_SUCCESS\n")); 8277 } 8278 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 8279 { 8280 TI_DBG1(("satSynchronizeCache10n16CB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 8281 } 8282 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 8283 (ataStatus & DF_ATA_STATUS_MASK) 8284 ) 8285 { 8286 TI_DBG1(("satSynchronizeCache10n16CB: FAILED, FAILED, error status\n")); 8287 } 8288 8289 8290 /* Process abort case */ 8291 if (agIOStatus == OSSA_IO_ABORTED) 8292 { 8293 satProcessAbort(tiRoot, 8294 tiOrgIORequest, 8295 satOrgIOContext 8296 ); 8297 8298 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8299 8300 satFreeIntIoResource( tiRoot, 8301 satDevData, 8302 satIntIo); 8303 return; 8304 } 8305 8306 switch (hostToDevFis->h.command) 8307 { 8308 case SAT_FLUSH_CACHE: 8309 TI_DBG1(("satSynchronizeCache10n16CB: SAT_FLUSH_CACHE failed\n")); 8310 /* checking IMMED bit */ 8311 if (scsiCmnd->cdb[1] & SCSI_FLUSH_CACHE_IMMED_MASK) 8312 { 8313 satSetDeferredSensePayload( pSense, 8314 SCSI_SNSKEY_NO_SENSE, 8315 0, 8316 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8317 satOrgIOContext); 8318 } 8319 else 8320 { 8321 satSetDeferredSensePayload( pSense, 8322 SCSI_SNSKEY_NO_SENSE, 8323 0, 8324 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8325 satOrgIOContext); 8326 } 8327 8328 8329 ostiInitiatorIOCompleted( tiRoot, 8330 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8331 tiIOSuccess, 8332 SCSI_STAT_CHECK_CONDITION, 8333 satOrgIOContext->pTiSenseData, 8334 satOrgIOContext->interruptContext ); 8335 8336 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8337 8338 satFreeIntIoResource( tiRoot, 8339 satDevData, 8340 satIntIo); 8341 return; 8342 break; 8343 case SAT_FLUSH_CACHE_EXT: 8344 TI_DBG1(("satSynchronizeCache10n16CB: SAT_FLUSH_CACHE_EXT failed\n")); 8345 /* checking IMMED bit */ 8346 if (scsiCmnd->cdb[1] & SCSI_FLUSH_CACHE_IMMED_MASK) 8347 { 8348 satSetDeferredSensePayload( pSense, 8349 SCSI_SNSKEY_NO_SENSE, 8350 0, 8351 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8352 satOrgIOContext); 8353 } 8354 else 8355 { 8356 satSetDeferredSensePayload( pSense, 8357 SCSI_SNSKEY_NO_SENSE, 8358 0, 8359 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8360 satOrgIOContext); 8361 } 8362 8363 8364 ostiInitiatorIOCompleted( tiRoot, 8365 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8366 tiIOSuccess, 8367 SCSI_STAT_CHECK_CONDITION, 8368 satOrgIOContext->pTiSenseData, 8369 satOrgIOContext->interruptContext ); 8370 8371 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8372 8373 satFreeIntIoResource( tiRoot, 8374 satDevData, 8375 satIntIo); 8376 return; 8377 break; 8378 default: 8379 TI_DBG1(("satSynchronizeCache10n16CB: error unknown command 0x%x\n", hostToDevFis->h.command)); 8380 satSetSensePayload( pSense, 8381 SCSI_SNSKEY_NO_SENSE, 8382 0, 8383 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8384 satOrgIOContext); 8385 8386 8387 ostiInitiatorIOCompleted( tiRoot, 8388 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8389 tiIOSuccess, 8390 SCSI_STAT_CHECK_CONDITION, 8391 satOrgIOContext->pTiSenseData, 8392 satOrgIOContext->interruptContext ); 8393 8394 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8395 8396 satFreeIntIoResource( tiRoot, 8397 satDevData, 8398 satIntIo); 8399 return; 8400 break; 8401 } 8402 8403 return; 8404 } /* end of error checking */ 8405 } 8406 8407 /* prcessing the success case */ 8408 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8409 8410 satFreeIntIoResource( tiRoot, 8411 satDevData, 8412 satIntIo); 8413 8414 8415 switch (hostToDevFis->h.command) 8416 { 8417 case SAT_FLUSH_CACHE: 8418 TI_DBG5(("satSynchronizeCache10n16CB: SAT_FLUSH_CACHE success\n")); 8419 8420 /* checking IMMED bit */ 8421 if ( !(scsiCmnd->cdb[1] & SCSI_FLUSH_CACHE_IMMED_MASK)) 8422 { 8423 ostiInitiatorIOCompleted( tiRoot, 8424 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8425 tiIOSuccess, 8426 SCSI_STAT_GOOD, 8427 agNULL, 8428 satOrgIOContext->interruptContext ); 8429 return; 8430 } 8431 8432 8433 break; 8434 case SAT_FLUSH_CACHE_EXT: 8435 TI_DBG5(("satSynchronizeCache10n16CB: SAT_FLUSH_CACHE_EXT success\n")); 8436 8437 /* checking IMMED bit */ 8438 if ( !(scsiCmnd->cdb[1] & SCSI_FLUSH_CACHE_IMMED_MASK)) 8439 { 8440 ostiInitiatorIOCompleted( tiRoot, 8441 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8442 tiIOSuccess, 8443 SCSI_STAT_GOOD, 8444 agNULL, 8445 satOrgIOContext->interruptContext ); 8446 return; 8447 } 8448 8449 break; 8450 default: 8451 TI_DBG5(("satSynchronizeCache10n16CB: error unknown command 0x%x\n", hostToDevFis->h.command)); 8452 satSetSensePayload( pSense, 8453 SCSI_SNSKEY_NO_SENSE, 8454 0, 8455 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8456 satOrgIOContext); 8457 8458 8459 ostiInitiatorIOCompleted( tiRoot, 8460 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8461 tiIOSuccess, 8462 SCSI_STAT_CHECK_CONDITION, 8463 satOrgIOContext->pTiSenseData, 8464 satOrgIOContext->interruptContext ); 8465 8466 return; 8467 break; 8468 } 8469 8470 return; 8471 } 8472 8473 /***************************************************************************** 8474 *! \brief satModeSelect6n10CB 8475 * 8476 * This routine is a callback function for satModeSelect6() and 8477 * satModeSelect10() 8478 * 8479 * \param agRoot: Handles for this instance of SAS/SATA hardware 8480 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 8481 * \param agIOStatus: Status of completed I/O. 8482 * \param agFirstDword:Pointer to the four bytes of FIS. 8483 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 8484 * length. 8485 * \param agParam: Additional info based on status. 8486 * \param ioContext: Pointer to satIOContext_t. 8487 * 8488 * \return: none 8489 * 8490 *****************************************************************************/ 8491 void satModeSelect6n10CB( 8492 agsaRoot_t *agRoot, 8493 agsaIORequest_t *agIORequest, 8494 bit32 agIOStatus, 8495 agsaFisHeader_t *agFirstDword, 8496 bit32 agIOInfoLen, 8497 void *agParam, 8498 void *ioContext 8499 ) 8500 { 8501 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 8502 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 8503 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 8504 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 8505 tdIORequestBody_t *tdIORequestBody; 8506 tdIORequestBody_t *tdOrgIORequestBody; 8507 satIOContext_t *satIOContext; 8508 satIOContext_t *satOrgIOContext; 8509 satIOContext_t *satNewIOContext; 8510 satInternalIo_t *satIntIo; 8511 satInternalIo_t *satNewIntIo = agNULL; 8512 satDeviceData_t *satDevData; 8513 scsiRspSense_t *pSense; 8514 tiIniScsiCmnd_t *scsiCmnd; 8515 tiIORequest_t *tiOrgIORequest; 8516 8517 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 8518 bit32 ataStatus = 0; 8519 bit32 status; 8520 tiScsiInitiatorRequest_t *tiScsiRequest; /* tiScsiXchg */ 8521 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 8522 8523 TI_DBG5(("satModeSelect6n10CB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 8524 8525 /* internally generate tiIOContext */ 8526 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 8527 satIOContext = (satIOContext_t *) ioContext; 8528 satIntIo = satIOContext->satIntIoContext; 8529 satDevData = satIOContext->pSatDevData; 8530 hostToDevFis = satIOContext->pFis; 8531 8532 if (satIntIo == agNULL) 8533 { 8534 TI_DBG4(("satModeSelect6n10CB: External satInternalIo_t satIntIoContext\n")); 8535 satOrgIOContext = satIOContext; 8536 tiOrgIORequest = tdIORequestBody->tiIORequest; 8537 tiScsiRequest = satOrgIOContext->tiScsiXchg; 8538 pSense = satOrgIOContext->pSense; 8539 scsiCmnd = satOrgIOContext->pScsiCmnd; 8540 } 8541 else 8542 { 8543 TI_DBG4(("satModeSelect6n10CB: Internal satInternalIo_t satIntIoContext\n")); 8544 satOrgIOContext = satIOContext->satOrgIOContext; 8545 if (satOrgIOContext == agNULL) 8546 { 8547 TI_DBG4(("satModeSelect6n10CB: satOrgIOContext is NULL, wrong\n")); 8548 return; 8549 } 8550 else 8551 { 8552 TI_DBG4(("satModeSelect6n10CB: satOrgIOContext is NOT NULL\n")); 8553 } 8554 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 8555 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 8556 8557 tiScsiRequest = satOrgIOContext->tiScsiXchg; 8558 pSense = satOrgIOContext->pSense; 8559 scsiCmnd = satOrgIOContext->pScsiCmnd; 8560 } 8561 8562 tdIORequestBody->ioCompleted = agTRUE; 8563 tdIORequestBody->ioStarted = agFALSE; 8564 8565 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 8566 { 8567 TI_DBG1(("satModeSelect6n10CB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 8568 ostiInitiatorIOCompleted ( 8569 tiRoot, 8570 tiOrgIORequest, 8571 tiIOFailed, 8572 tiDetailOtherError, 8573 agNULL, 8574 satOrgIOContext->interruptContext 8575 ); 8576 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8577 8578 satFreeIntIoResource( tiRoot, 8579 satDevData, 8580 satIntIo); 8581 return; 8582 } 8583 8584 if (agIOStatus != OSSA_IO_SUCCESS) 8585 { 8586 /* only agsaFisRegDeviceToHost_t is expected */ 8587 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 8588 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 8589 } 8590 8591 if (agIOStatus != OSSA_IO_SUCCESS) 8592 { 8593 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 8594 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 8595 ) 8596 { 8597 /* for debugging */ 8598 if( agIOStatus != OSSA_IO_SUCCESS) 8599 { 8600 TI_DBG1(("satModeSelect6n10CB FAILED, NOT IO_SUCCESS\n")); 8601 } 8602 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 8603 { 8604 TI_DBG1(("satModeSelect6n10CB FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 8605 } 8606 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 8607 (ataStatus & DF_ATA_STATUS_MASK) 8608 ) 8609 { 8610 TI_DBG1(("satModeSelect6n10CB FAILED, FAILED, error status\n")); 8611 } 8612 8613 /* Process abort case */ 8614 if (agIOStatus == OSSA_IO_ABORTED) 8615 { 8616 satProcessAbort(tiRoot, 8617 tiOrgIORequest, 8618 satOrgIOContext 8619 ); 8620 8621 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8622 8623 satFreeIntIoResource( tiRoot, 8624 satDevData, 8625 satIntIo); 8626 return; 8627 } 8628 8629 /* for debugging */ 8630 if (hostToDevFis->h.command == SAT_SET_FEATURES) 8631 { 8632 if ((hostToDevFis->h.features == 0x82) || (hostToDevFis->h.features == 0x02)) 8633 { 8634 TI_DBG1(("satModeSelect6n10CB 1 SAT_SET_FEATURES failed, feature 0x%x\n", hostToDevFis->h.features)); 8635 } 8636 else if ((hostToDevFis->h.features == 0xAA) || (hostToDevFis->h.features == 0x55)) 8637 { 8638 TI_DBG1(("ssatModeSelect6n10CB 2 SAT_SET_FEATURES failed, feature 0x%x\n", hostToDevFis->h.features)); 8639 } 8640 else 8641 { 8642 TI_DBG1(("satModeSelect6n10CB error unknown command 0x%x feature 0x%x\n", hostToDevFis->h.command, hostToDevFis->h.features)); 8643 } 8644 } 8645 else if (hostToDevFis->h.command == SAT_SMART) 8646 { 8647 if ((hostToDevFis->h.features == SAT_SMART_ENABLE_OPERATIONS) || (hostToDevFis->h.features == SAT_SMART_DISABLE_OPERATIONS)) 8648 { 8649 TI_DBG1(("satModeSelect6n10CB SAT_SMART_ENABLE/DISABLE_OPERATIONS failed, feature 0x%x\n", hostToDevFis->h.features)); 8650 } 8651 else 8652 { 8653 TI_DBG1(("satModeSelect6n10CB error unknown command 0x%x feature 0x%x\n", hostToDevFis->h.command, hostToDevFis->h.features)); 8654 } 8655 } 8656 else 8657 { 8658 TI_DBG1(("satModeSelect6n10CB error default case command 0x%x\n", hostToDevFis->h.command)); 8659 } 8660 8661 8662 satSetSensePayload( pSense, 8663 SCSI_SNSKEY_NO_SENSE, 8664 0, 8665 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8666 satOrgIOContext); 8667 8668 ostiInitiatorIOCompleted( tiRoot, 8669 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8670 tiIOSuccess, 8671 SCSI_STAT_CHECK_CONDITION, 8672 satOrgIOContext->pTiSenseData, 8673 satOrgIOContext->interruptContext ); 8674 8675 8676 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8677 8678 satFreeIntIoResource( tiRoot, 8679 satDevData, 8680 satIntIo); 8681 return; 8682 } /* error checking */ 8683 } 8684 8685 8686 /* prcessing the success case */ 8687 8688 8689 if (hostToDevFis->h.command == SAT_SET_FEATURES) 8690 { 8691 if ((hostToDevFis->h.features == 0x82) || (hostToDevFis->h.features == 0x02)) 8692 { 8693 TI_DBG5(("satModeSelect6n10CB 1 SAT_SET_FEATURES success, feature 0x%x\n", hostToDevFis->h.features)); 8694 8695 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8696 8697 satFreeIntIoResource( tiRoot, 8698 satDevData, 8699 satIntIo); 8700 8701 satNewIntIo = satAllocIntIoResource( tiRoot, 8702 tiOrgIORequest, 8703 satDevData, 8704 0, 8705 satNewIntIo); 8706 if (satNewIntIo == agNULL) 8707 { 8708 /* memory allocation failure */ 8709 satFreeIntIoResource( tiRoot, 8710 satDevData, 8711 satNewIntIo); 8712 8713 satSetSensePayload( pSense, 8714 SCSI_SNSKEY_NO_SENSE, 8715 0, 8716 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8717 satOrgIOContext); 8718 8719 ostiInitiatorIOCompleted( tiRoot, 8720 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8721 tiIOSuccess, 8722 SCSI_STAT_CHECK_CONDITION, 8723 satOrgIOContext->pTiSenseData, 8724 satOrgIOContext->interruptContext ); 8725 TI_DBG1(("satModeSelect6n10CB: momory allocation fails\n")); 8726 return; 8727 } /* end memory allocation */ 8728 8729 satNewIOContext = satPrepareNewIO( 8730 satNewIntIo, 8731 tiOrgIORequest, 8732 satDevData, 8733 scsiCmnd, 8734 satOrgIOContext 8735 ); 8736 /* sends either ATA SET FEATURES based on DRA bit */ 8737 status = satModeSelect6n10_1( tiRoot, 8738 &satNewIntIo->satIntTiIORequest, 8739 satNewIOContext->ptiDeviceHandle, 8740 tiScsiRequest, /* orginal from OS layer */ 8741 satNewIOContext 8742 ); 8743 8744 if (status != tiSuccess) 8745 { 8746 /* sending ATA command fails */ 8747 satFreeIntIoResource( tiRoot, 8748 satDevData, 8749 satNewIntIo); 8750 satSetSensePayload( pSense, 8751 SCSI_SNSKEY_NO_SENSE, 8752 0, 8753 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8754 satOrgIOContext); 8755 8756 ostiInitiatorIOCompleted( tiRoot, 8757 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8758 tiIOSuccess, 8759 SCSI_STAT_CHECK_CONDITION, 8760 satOrgIOContext->pTiSenseData, 8761 satOrgIOContext->interruptContext ); 8762 TI_DBG1(("satModeSelect6n10CB calling satModeSelect6_1 fails\n")); 8763 return; 8764 } /* end send fails */ 8765 return; 8766 } 8767 else if ((hostToDevFis->h.features == 0xAA) || (hostToDevFis->h.features == 0x55)) 8768 { 8769 TI_DBG5(("satModeSelect6n10CB 2 SAT_SET_FEATURES success, feature 0x%x\n", hostToDevFis->h.features)); 8770 8771 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8772 8773 satFreeIntIoResource( tiRoot, 8774 satDevData, 8775 satIntIo); 8776 8777 /* return stat_good */ 8778 ostiInitiatorIOCompleted( tiRoot, 8779 tiOrgIORequest, 8780 tiIOSuccess, 8781 SCSI_STAT_GOOD, 8782 agNULL, 8783 satOrgIOContext->interruptContext ); 8784 return; 8785 } 8786 else 8787 { 8788 TI_DBG1(("satModeSelect6n10CB error unknown command success 0x%x feature 0x%x\n", hostToDevFis->h.command, hostToDevFis->h.features)); 8789 8790 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8791 8792 satFreeIntIoResource( tiRoot, 8793 satDevData, 8794 satIntIo); 8795 satSetSensePayload( pSense, 8796 SCSI_SNSKEY_NO_SENSE, 8797 0, 8798 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8799 satOrgIOContext); 8800 8801 ostiInitiatorIOCompleted( tiRoot, 8802 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8803 tiIOSuccess, 8804 SCSI_STAT_CHECK_CONDITION, 8805 satOrgIOContext->pTiSenseData, 8806 satOrgIOContext->interruptContext ); 8807 return; 8808 } 8809 } 8810 else if (hostToDevFis->h.command == SAT_SMART_ENABLE_OPERATIONS || 8811 hostToDevFis->h.command == SAT_SMART_DISABLE_OPERATIONS 8812 ) 8813 { 8814 if ((hostToDevFis->h.features == 0xD8) || (hostToDevFis->h.features == 0xD9)) 8815 { 8816 TI_DBG5(("satModeSelect6n10CB SAT_SMART_ENABLE/DISABLE_OPERATIONS success, feature 0x%x\n", hostToDevFis->h.features)); 8817 8818 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8819 8820 satFreeIntIoResource( tiRoot, 8821 satDevData, 8822 satIntIo); 8823 /* return stat_good */ 8824 ostiInitiatorIOCompleted( tiRoot, 8825 tiOrgIORequest, 8826 tiIOSuccess, 8827 SCSI_STAT_GOOD, 8828 agNULL, 8829 satOrgIOContext->interruptContext ); 8830 return; 8831 } 8832 else 8833 { 8834 TI_DBG1(("satModeSelect6n10CB error unknown command failed 0x%x feature 0x%x\n", hostToDevFis->h.command, hostToDevFis->h.features)); 8835 8836 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8837 8838 satFreeIntIoResource( tiRoot, 8839 satDevData, 8840 satIntIo); 8841 satSetSensePayload( pSense, 8842 SCSI_SNSKEY_NO_SENSE, 8843 0, 8844 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8845 satOrgIOContext); 8846 8847 ostiInitiatorIOCompleted( tiRoot, 8848 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8849 tiIOSuccess, 8850 SCSI_STAT_CHECK_CONDITION, 8851 satOrgIOContext->pTiSenseData, 8852 satOrgIOContext->interruptContext ); 8853 return; 8854 } 8855 } 8856 8857 else 8858 { 8859 TI_DBG1(("satModeSelect6n10CB error default case command success 0x%x\n", hostToDevFis->h.command)); 8860 8861 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8862 8863 satFreeIntIoResource( tiRoot, 8864 satDevData, 8865 satIntIo); 8866 8867 satSetSensePayload( pSense, 8868 SCSI_SNSKEY_NO_SENSE, 8869 0, 8870 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 8871 satOrgIOContext); 8872 8873 ostiInitiatorIOCompleted( tiRoot, 8874 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 8875 tiIOSuccess, 8876 SCSI_STAT_CHECK_CONDITION, 8877 satOrgIOContext->pTiSenseData, 8878 satOrgIOContext->interruptContext ); 8879 return; 8880 } 8881 8882 return; 8883 } 8884 8885 /***************************************************************************** 8886 *! \brief satSMARTEnableCB 8887 * 8888 * This routine is a callback function for satSMARTEnable() 8889 * 8890 * \param agRoot: Handles for this instance of SAS/SATA hardware 8891 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 8892 * \param agIOStatus: Status of completed I/O. 8893 * \param agFirstDword:Pointer to the four bytes of FIS. 8894 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 8895 * length. 8896 * \param agParam: Additional info based on status. 8897 * \param ioContext: Pointer to satIOContext_t. 8898 * 8899 * \return: none 8900 * 8901 *****************************************************************************/ 8902 void satSMARTEnableCB( 8903 agsaRoot_t *agRoot, 8904 agsaIORequest_t *agIORequest, 8905 bit32 agIOStatus, 8906 agsaFisHeader_t *agFirstDword, 8907 bit32 agIOInfoLen, 8908 void *agParam, 8909 void *ioContext 8910 ) 8911 { 8912 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 8913 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 8914 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 8915 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 8916 tdIORequestBody_t *tdIORequestBody; 8917 tdIORequestBody_t *tdOrgIORequestBody; 8918 satIOContext_t *satIOContext; 8919 satIOContext_t *satOrgIOContext; 8920 satIOContext_t *satNewIOContext; 8921 satInternalIo_t *satIntIo; 8922 satInternalIo_t *satNewIntIo = agNULL; 8923 satDeviceData_t *satDevData; 8924 tiIORequest_t *tiOrgIORequest; 8925 tiIniScsiCmnd_t *scsiCmnd; 8926 bit32 status; 8927 8928 TI_DBG4(("satSMARTEnableCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 8929 8930 /* internally generate tiIOContext */ 8931 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 8932 satIOContext = (satIOContext_t *) ioContext; 8933 satIntIo = satIOContext->satIntIoContext; 8934 satDevData = satIOContext->pSatDevData; 8935 8936 /*ttttttthe one */ 8937 if (satIntIo == agNULL) 8938 { 8939 TI_DBG4(("satSMARTEnableCB: External satInternalIo_t satIntIoContext\n")); 8940 satOrgIOContext = satIOContext; 8941 tiOrgIORequest = tdIORequestBody->tiIORequest; 8942 scsiCmnd = satOrgIOContext->pScsiCmnd; 8943 } 8944 else 8945 { 8946 TI_DBG4(("satSMARTEnableCB: Internal satInternalIo_t satIntIoContext\n")); 8947 satOrgIOContext = satIOContext->satOrgIOContext; 8948 if (satOrgIOContext == agNULL) 8949 { 8950 TI_DBG4(("satSMARTEnableCB: satOrgIOContext is NULL, wrong\n")); 8951 return; 8952 } 8953 else 8954 { 8955 TI_DBG4(("satSMARTEnableCB: satOrgIOContext is NOT NULL\n")); 8956 } 8957 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 8958 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 8959 8960 scsiCmnd = satOrgIOContext->pScsiCmnd; 8961 } 8962 8963 tdIORequestBody->ioCompleted = agTRUE; 8964 tdIORequestBody->ioStarted = agFALSE; 8965 8966 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 8967 { 8968 TI_DBG1(("satSMARTEnableCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 8969 ostiInitiatorIOCompleted ( 8970 tiRoot, 8971 tiOrgIORequest, 8972 tiIOFailed, 8973 tiDetailOtherError, 8974 agNULL, 8975 satOrgIOContext->interruptContext 8976 ); 8977 8978 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 8979 8980 satFreeIntIoResource( tiRoot, 8981 satDevData, 8982 satIntIo); 8983 8984 return; 8985 } 8986 8987 /* 8988 checking IO status, FIS type and error status 8989 */ 8990 if (agIOStatus != OSSA_IO_SUCCESS) 8991 { 8992 TI_DBG1(("satSMARTEnableCB: not success status, status %d\n", agIOStatus)); 8993 ostiInitiatorIOCompleted ( 8994 tiRoot, 8995 tiOrgIORequest, 8996 tiIOFailed, 8997 tiDetailOtherError, 8998 agNULL, 8999 satOrgIOContext->interruptContext 9000 ); 9001 9002 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9003 9004 satFreeIntIoResource( tiRoot, 9005 satDevData, 9006 satIntIo); 9007 9008 return; 9009 } 9010 9011 /* process success case */ 9012 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9013 9014 satFreeIntIoResource( tiRoot, 9015 satDevData, 9016 satIntIo); 9017 9018 satNewIntIo = satAllocIntIoResource( tiRoot, 9019 tiOrgIORequest, 9020 satDevData, 9021 512, 9022 satNewIntIo); 9023 9024 if (satNewIntIo == agNULL) 9025 { 9026 /* memory allocation failure */ 9027 satFreeIntIoResource( tiRoot, 9028 satDevData, 9029 satNewIntIo); 9030 9031 ostiInitiatorIOCompleted ( 9032 tiRoot, 9033 tiOrgIORequest, 9034 tiIOFailed, 9035 tiDetailOtherError, 9036 agNULL, 9037 satOrgIOContext->interruptContext 9038 ); 9039 return; 9040 } 9041 9042 satNewIOContext = satPrepareNewIO( 9043 satNewIntIo, 9044 tiOrgIORequest, 9045 satDevData, 9046 scsiCmnd, 9047 satOrgIOContext 9048 ); 9049 9050 status = satLogSense_1(tiRoot, 9051 &satNewIntIo->satIntTiIORequest, 9052 satNewIOContext->ptiDeviceHandle, 9053 &satNewIntIo->satIntTiScsiXchg, 9054 satNewIOContext); 9055 9056 if (status != tiSuccess) 9057 { 9058 /* sending SAT_CHECK_POWER_MODE fails */ 9059 satFreeIntIoResource( tiRoot, 9060 satDevData, 9061 satNewIntIo); 9062 9063 ostiInitiatorIOCompleted ( 9064 tiRoot, 9065 tiOrgIORequest, 9066 tiIOFailed, 9067 tiDetailOtherError, 9068 agNULL, 9069 satOrgIOContext->interruptContext 9070 ); 9071 9072 return; 9073 } 9074 9075 return; 9076 } 9077 9078 9079 /***************************************************************************** 9080 *! \brief satLogSenseCB 9081 * 9082 * This routine is a callback function for satLogSense() 9083 * 9084 * \param agRoot: Handles for this instance of SAS/SATA hardware 9085 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 9086 * \param agIOStatus: Status of completed I/O. 9087 * \param agFirstDword:Pointer to the four bytes of FIS. 9088 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 9089 * length. 9090 * \param agParam: Additional info based on status. 9091 * \param ioContext: Pointer to satIOContext_t. 9092 * 9093 * \return: none 9094 * 9095 *****************************************************************************/ 9096 void satLogSenseCB( 9097 agsaRoot_t *agRoot, 9098 agsaIORequest_t *agIORequest, 9099 bit32 agIOStatus, 9100 agsaFisHeader_t *agFirstDword, 9101 bit32 agIOInfoLen, 9102 void *agParam, 9103 void *ioContext 9104 ) 9105 { 9106 9107 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 9108 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 9109 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 9110 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 9111 tdIORequestBody_t *tdIORequestBody; 9112 tdIORequestBody_t *tdOrgIORequestBody; 9113 satIOContext_t *satIOContext; 9114 satIOContext_t *satOrgIOContext; 9115 satInternalIo_t *satIntIo; 9116 satDeviceData_t *satDevData; 9117 9118 scsiRspSense_t *pSense; 9119 tiIORequest_t *tiOrgIORequest; 9120 9121 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 9122 bit32 ataStatus = 0; 9123 tiScsiInitiatorRequest_t *tiScsiRequest; /* tiScsiXchg */ 9124 tiScsiInitiatorRequest_t *tiOrgScsiRequest; /* tiScsiXchg */ 9125 satReadLogExtSelfTest_t *virtAddr1; 9126 satSmartReadLogSelfTest_t *virtAddr2; 9127 bit8 *pLogPage; 9128 bit8 SelfTestExecutionStatus = 0; 9129 bit32 i = 0; 9130 9131 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 9132 agsaFisRegD2HData_t statDevToHostFisData; 9133 tiIniScsiCmnd_t *scsiCmnd; 9134 bit32 lenReceived = 0; 9135 9136 TI_DBG5(("satLogSenseCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 9137 9138 /* internally generate tiIOContext */ 9139 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 9140 satIOContext = (satIOContext_t *) ioContext; 9141 if (satIOContext == agNULL) 9142 { 9143 TI_DBG1(("satLogSenseCB: satIOContext is NULL\n")); 9144 return; 9145 } 9146 satIntIo = satIOContext->satIntIoContext; 9147 satDevData = satIOContext->pSatDevData; 9148 hostToDevFis = satIOContext->pFis; 9149 9150 if (satIntIo == agNULL) 9151 { 9152 TI_DBG4(("satLogSenseCB: External satInternalIo_t satIntIoContext\n")); 9153 satOrgIOContext = satIOContext; 9154 tiOrgIORequest = tdIORequestBody->tiIORequest; 9155 pSense = satOrgIOContext->pSense; 9156 tiOrgScsiRequest = satOrgIOContext->tiScsiXchg; 9157 /* SCSI command response payload to OS layer */ 9158 pLogPage = (bit8 *) tiOrgScsiRequest->sglVirtualAddr; 9159 /* ATA command response payload */ 9160 tiScsiRequest = satOrgIOContext->tiScsiXchg; 9161 scsiCmnd = satOrgIOContext->pScsiCmnd; 9162 } 9163 else 9164 { 9165 TI_DBG4(("satLogSenseCB: Internal satInternalIo_t satIntIoContext\n")); 9166 satOrgIOContext = satIOContext->satOrgIOContext; 9167 if (satOrgIOContext == agNULL) 9168 { 9169 TI_DBG4(("satLogSenseCB: satOrgIOContext is NULL\n")); 9170 } 9171 else 9172 { 9173 TI_DBG4(("satLogSenseCB: satOrgIOContext is NOT NULL\n")); 9174 } 9175 9176 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 9177 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 9178 9179 pSense = satOrgIOContext->pSense; 9180 tiOrgScsiRequest = satOrgIOContext->tiScsiXchg; 9181 /* SCSI command response payload to OS layer */ 9182 pLogPage = (bit8 *) tiOrgScsiRequest->sglVirtualAddr; 9183 /* ATA command response payload */ 9184 tiScsiRequest = (tiScsiInitiatorRequest_t *)&(satIntIo->satIntTiScsiXchg); 9185 scsiCmnd = satOrgIOContext->pScsiCmnd; 9186 } 9187 9188 tdIORequestBody->ioCompleted = agTRUE; 9189 tdIORequestBody->ioStarted = agFALSE; 9190 9191 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 9192 { 9193 TI_DBG1(("satLogSenseCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 9194 ostiInitiatorIOCompleted ( 9195 tiRoot, 9196 tiOrgIORequest, 9197 tiIOFailed, 9198 tiDetailOtherError, 9199 agNULL, 9200 satOrgIOContext->interruptContext 9201 ); 9202 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9203 9204 satFreeIntIoResource( tiRoot, 9205 satDevData, 9206 satIntIo); 9207 return; 9208 } 9209 9210 if (agIOStatus != OSSA_IO_SUCCESS) 9211 { 9212 /* non-data and pio read -> device to host and pio setup fis are expected */ 9213 /* 9214 first, assumed to be Reg Device to Host FIS 9215 This is OK to just find fis type 9216 */ 9217 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 9218 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 9219 } 9220 9221 if( agIOStatus != OSSA_IO_SUCCESS) 9222 { 9223 if ( ((statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) && 9224 (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS)) || 9225 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 9226 ) 9227 { 9228 /* for debugging */ 9229 if( agIOStatus != OSSA_IO_SUCCESS) 9230 { 9231 TI_DBG1(("satLogSenseCB: FAILED, NOT IO_SUCCESS\n")); 9232 } 9233 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 9234 { 9235 TI_DBG1(("satLogSenseCB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 9236 } 9237 else if (statDevToHostFisHeader->fisType != PIO_SETUP_DEV_TO_HOST_FIS) 9238 { 9239 TI_DBG1(("satLogSenseCB: FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 9240 } 9241 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 9242 (ataStatus & DF_ATA_STATUS_MASK) 9243 ) 9244 { 9245 TI_DBG1(("satLogSenseCB: FAILED, FAILED, error status\n")); 9246 } 9247 9248 /* Process abort case */ 9249 if (agIOStatus == OSSA_IO_ABORTED) 9250 { 9251 satProcessAbort(tiRoot, 9252 tiOrgIORequest, 9253 satOrgIOContext 9254 ); 9255 9256 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9257 9258 satFreeIntIoResource( tiRoot, 9259 satDevData, 9260 satIntIo); 9261 return; 9262 } 9263 9264 /* for debugging */ 9265 if (hostToDevFis->h.command == SAT_READ_LOG_EXT) 9266 { 9267 TI_DBG1(("satLogSenseCB: SAT_READ_LOG_EXT failed\n")); 9268 } 9269 else if (hostToDevFis->h.command == SAT_SMART) 9270 { 9271 if (hostToDevFis->h.features == SAT_SMART_READ_LOG) 9272 { 9273 TI_DBG1(("satLogSenseCB: SAT_SMART_READ_LOG failed\n")); 9274 } 9275 else if (hostToDevFis->h.features == SAT_SMART_RETURN_STATUS) 9276 { 9277 TI_DBG1(("satLogSenseCB: SAT_SMART_RETURN_STATUS failed\n")); 9278 } 9279 else 9280 { 9281 TI_DBG1(("satLogSenseCB: error unknown command 0x%x feature 0x%x\n", hostToDevFis->h.command, hostToDevFis->h.features)); 9282 } 9283 } 9284 else 9285 { 9286 TI_DBG1(("satLogSenseCB: error default case command 0x%x\n", hostToDevFis->h.command)); 9287 } 9288 9289 satSetSensePayload( pSense, 9290 SCSI_SNSKEY_NO_SENSE, 9291 0, 9292 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 9293 satOrgIOContext); 9294 9295 ostiInitiatorIOCompleted( tiRoot, 9296 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 9297 tiIOSuccess, 9298 SCSI_STAT_CHECK_CONDITION, 9299 satOrgIOContext->pTiSenseData, 9300 satOrgIOContext->interruptContext ); 9301 9302 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9303 9304 satFreeIntIoResource( tiRoot, 9305 satDevData, 9306 satIntIo); 9307 return; 9308 9309 } /* error checking */ 9310 } 9311 9312 /* prcessing the success case */ 9313 saFrameReadBlock(agRoot, agParam, 0, &statDevToHostFisData, sizeof(agsaFisRegD2HData_t)); 9314 9315 lenReceived = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 9316 TI_DBG5(("satLogSenseCB: lenReceived in CDB %d 0x%x\n", lenReceived,lenReceived)); 9317 9318 9319 if (hostToDevFis->h.command == SAT_READ_LOG_EXT) 9320 { 9321 TI_DBG5(("satLogSenseCB: SAT_READ_LOG_EXT success\n")); 9322 9323 /* process log data and sends it to upper */ 9324 9325 /* ATA: Extended Self-Test Log */ 9326 virtAddr1 = (satReadLogExtSelfTest_t *)(tiScsiRequest->sglVirtualAddr); 9327 /* 9328 ATA/ATAPI VOLII, p197, 287 9329 self-test execution status (4 bits); ((virtAddr1->byte[5] & 0xF0) >> 4) 9330 */ 9331 SelfTestExecutionStatus = (bit8)(((virtAddr1->byte[5] & 0xF0) >> 4)); 9332 9333 /* fills in the log page from ATA log page */ 9334 /* SPC-4, 7.2.10, Table 216, 217, p 259 - 260 */ 9335 pLogPage[0] = 0x10; /* page code */ 9336 pLogPage[1] = 0; 9337 pLogPage[2] = 0x01; /* 0x190, page length */ 9338 pLogPage[3] = 0x90; 9339 9340 /* SPC-4, Table 217 */ 9341 pLogPage[4] = 0; /* Parameter Code */ 9342 pLogPage[5] = 0x01; /* Parameter Code, unspecfied but ... */ 9343 pLogPage[6] = 3; /* unspecified but ... */ 9344 pLogPage[7] = 0x10; /* Parameter Length */ 9345 pLogPage[8] = (bit8)(0 | ((virtAddr1->byte[5] & 0xF0) >> 4)); /* Self Test Code and Self-Test Result */ 9346 pLogPage[9] = 0; /* self test number */ 9347 pLogPage[10] = virtAddr1->byte[7]; /* time stamp, MSB */ 9348 pLogPage[11] = virtAddr1->byte[6]; /* time stamp, LSB */ 9349 9350 pLogPage[12] = 0; /* address of first failure MSB*/ 9351 pLogPage[13] = 0; /* address of first failure */ 9352 pLogPage[14] = virtAddr1->byte[14]; /* address of first failure */ 9353 pLogPage[15] = virtAddr1->byte[13]; /* address of first failure */ 9354 pLogPage[16] = virtAddr1->byte[12]; /* address of first failure */ 9355 pLogPage[17] = virtAddr1->byte[11]; /* address of first failure */ 9356 pLogPage[18] = virtAddr1->byte[10]; /* address of first failure */ 9357 pLogPage[19] = virtAddr1->byte[9]; /* address of first failure LSB */ 9358 9359 /* SAT rev8 Table75, p 76 */ 9360 switch (SelfTestExecutionStatus) 9361 { 9362 case 0: 9363 pLogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE; 9364 pLogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF; 9365 pLogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF; 9366 break; 9367 case 1: 9368 pLogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 9369 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9370 pLogPage[22] = 0x81; 9371 break; 9372 case 2: 9373 pLogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 9374 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9375 pLogPage[22] = 0x82; 9376 break; 9377 case 3: 9378 pLogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 9379 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9380 pLogPage[22] = 0x83; 9381 break; 9382 case 4: 9383 pLogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 9384 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9385 pLogPage[22] = 0x84; 9386 break; 9387 case 5: 9388 pLogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 9389 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9390 pLogPage[22] = 0x85; 9391 break; 9392 case 6: 9393 pLogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 9394 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9395 pLogPage[22] = 0x86; 9396 break; 9397 case 7: 9398 pLogPage[20] = 0 | SCSI_SNSKEY_MEDIUM_ERROR; 9399 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9400 pLogPage[22] = 0x87; 9401 break; 9402 case 8: 9403 pLogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 9404 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9405 pLogPage[22] = 0x88; 9406 break; 9407 case 9: /* fall through */ 9408 case 10:/* fall through */ 9409 case 11:/* fall through */ 9410 case 12:/* fall through */ 9411 case 13:/* fall through */ 9412 case 14: 9413 pLogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE; 9414 pLogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF; 9415 pLogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF; 9416 break; 9417 case 15: 9418 pLogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE; 9419 pLogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF; 9420 pLogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF; 9421 break; 9422 default: 9423 TI_DBG1(("satLogSenseCB: Error, incorrect SelfTestExecutionStatus 0x%x\n", SelfTestExecutionStatus)); 9424 9425 satSetSensePayload( pSense, 9426 SCSI_SNSKEY_NO_SENSE, 9427 0, 9428 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 9429 satOrgIOContext); 9430 9431 ostiInitiatorIOCompleted( tiRoot, 9432 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 9433 tiIOSuccess, 9434 SCSI_STAT_CHECK_CONDITION, 9435 satOrgIOContext->pTiSenseData, 9436 satOrgIOContext->interruptContext ); 9437 9438 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9439 9440 satFreeIntIoResource( tiRoot, 9441 satDevData, 9442 satIntIo); 9443 9444 return; 9445 } 9446 9447 pLogPage[23] = 0; /* vendor specific */ 9448 9449 /* the rest of Self-test results log */ 9450 /* 403 is from SPC-4, 7.2.10, Table 216, p 259*/ 9451 for (i=24;i<=403;i++) 9452 { 9453 pLogPage[i] = 0; /* vendor specific */ 9454 } 9455 9456 if (SELFTEST_RESULTS_LOG_PAGE_LENGTH < lenReceived) 9457 { 9458 TI_DBG6(("satLogSenseCB: 1st underrun lenReceived %d len %d \n", lenReceived, SELFTEST_RESULTS_LOG_PAGE_LENGTH)); 9459 9460 /* underrun */ 9461 ostiInitiatorIOCompleted( tiRoot, 9462 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 9463 tiIOUnderRun, 9464 lenReceived - SELFTEST_RESULTS_LOG_PAGE_LENGTH, 9465 agNULL, 9466 satOrgIOContext->interruptContext ); 9467 9468 } 9469 else 9470 { 9471 ostiInitiatorIOCompleted( tiRoot, 9472 tiOrgIORequest, 9473 tiIOSuccess, 9474 SCSI_STAT_GOOD, 9475 agNULL, 9476 satOrgIOContext->interruptContext); 9477 } 9478 9479 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9480 9481 satFreeIntIoResource( tiRoot, 9482 satDevData, 9483 satIntIo); 9484 9485 return; 9486 } 9487 else if (hostToDevFis->h.command == SAT_SMART_READ_LOG 9488 || hostToDevFis->h.command == SAT_SMART_RETURN_STATUS) 9489 { 9490 if (hostToDevFis->h.features == 0xd5) 9491 { 9492 TI_DBG5(("satLogSenseCB: SAT_SMART_READ_LOG success\n")); 9493 /* process log data and sends it to upper */ 9494 9495 /* ATA: Extended Self-Test Log */ 9496 virtAddr2 = (satSmartReadLogSelfTest_t *)(tiScsiRequest->sglVirtualAddr); 9497 /* 9498 SPC-4, p197, 287 9499 self-test execution status (4 bits); ((virtAddr2->byte[3] & 0xF0) >> 4) 9500 */ 9501 SelfTestExecutionStatus = (bit8)(((virtAddr2->byte[3] & 0xF0) >> 4)); 9502 9503 /* fills in the log page from ATA log page */ 9504 /* SPC-4, 7.2.10, Table 216, 217, p 259 - 260 */ 9505 pLogPage[0] = 0x10; /* page code */ 9506 pLogPage[1] = 0; 9507 pLogPage[2] = 0x01; /* 0x190, page length */ 9508 pLogPage[3] = 0x90; /* 0x190, page length */ 9509 9510 /* SPC-4, Table 217 */ 9511 pLogPage[4] = 0; /* Parameter Code */ 9512 pLogPage[5] = 0x01; /* Parameter Code unspecfied but ... */ 9513 pLogPage[6] = 3; /* unspecified but ... */ 9514 pLogPage[7] = 0x10; /* Parameter Length */ 9515 pLogPage[8] = (bit8)(0 | ((virtAddr2->byte[3] & 0xF0) >> 4)); /* Self Test Code and Self-Test Result */ 9516 pLogPage[9] = 0; /* self test number */ 9517 pLogPage[10] = virtAddr2->byte[5]; /* time stamp, MSB */ 9518 pLogPage[11] = virtAddr2->byte[4]; /* time stamp, LSB */ 9519 9520 pLogPage[12] = 0; /* address of first failure MSB*/ 9521 pLogPage[13] = 0; /* address of first failure */ 9522 pLogPage[14] = 0; /* address of first failure */ 9523 pLogPage[15] = 0; /* address of first failure */ 9524 pLogPage[16] = virtAddr2->byte[10]; /* address of first failure */ 9525 pLogPage[17] = virtAddr2->byte[9]; /* address of first failure */ 9526 pLogPage[18] = virtAddr2->byte[8]; /* address of first failure */ 9527 pLogPage[19] = virtAddr2->byte[7]; /* address of first failure LSB */ 9528 9529 /* SAT rev8 Table75, p 76 */ 9530 switch (SelfTestExecutionStatus) 9531 { 9532 case 0: 9533 pLogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE; 9534 pLogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF; 9535 pLogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF; 9536 break; 9537 case 1: 9538 pLogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 9539 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9540 pLogPage[22] = 0x81; 9541 break; 9542 case 2: 9543 pLogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 9544 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9545 pLogPage[22] = 0x82; 9546 break; 9547 case 3: 9548 pLogPage[20] = 0 | SCSI_SNSKEY_ABORTED_COMMAND; 9549 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9550 pLogPage[22] = 0x83; 9551 break; 9552 case 4: 9553 pLogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 9554 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9555 pLogPage[22] = 0x84; 9556 break; 9557 case 5: 9558 pLogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 9559 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9560 pLogPage[22] = 0x85; 9561 break; 9562 case 6: 9563 pLogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 9564 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9565 pLogPage[22] = 0x86; 9566 break; 9567 case 7: 9568 pLogPage[20] = 0 | SCSI_SNSKEY_MEDIUM_ERROR; 9569 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9570 pLogPage[22] = 0x87; 9571 break; 9572 case 8: 9573 pLogPage[20] = 0 | SCSI_SNSKEY_HARDWARE_ERROR; 9574 pLogPage[21] = (SCSI_SNSCODE_DIAGNOSTIC_FAILURE_ON_COMPONENT_NN >> 8) & 0xFF; 9575 pLogPage[22] = 0x88; 9576 break; 9577 case 9: /* fall through */ 9578 case 10:/* fall through */ 9579 case 11:/* fall through */ 9580 case 12:/* fall through */ 9581 case 13:/* fall through */ 9582 case 14: 9583 /* unspecified */ 9584 pLogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE; 9585 pLogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF; 9586 pLogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF; 9587 break; 9588 case 15: 9589 pLogPage[20] = 0 | SCSI_SNSKEY_NO_SENSE; 9590 pLogPage[21] = (SCSI_SNSCODE_NO_ADDITIONAL_INFO >> 8) & 0xFF; 9591 pLogPage[22] = SCSI_SNSCODE_NO_ADDITIONAL_INFO & 0xFF; 9592 break; 9593 default: 9594 TI_DBG1(("satLogSenseCB: Error, incorrect SelfTestExecutionStatus 0x%x\n", SelfTestExecutionStatus)); 9595 9596 satSetSensePayload( pSense, 9597 SCSI_SNSKEY_NO_SENSE, 9598 0, 9599 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 9600 satOrgIOContext); 9601 9602 ostiInitiatorIOCompleted( tiRoot, 9603 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 9604 tiIOSuccess, 9605 SCSI_STAT_CHECK_CONDITION, 9606 satOrgIOContext->pTiSenseData, 9607 satOrgIOContext->interruptContext ); 9608 9609 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9610 9611 satFreeIntIoResource( tiRoot, 9612 satDevData, 9613 satIntIo); 9614 9615 return; 9616 } 9617 9618 pLogPage[23] = 0; /* vendor specific */ 9619 9620 /* the rest of Self-test results log */ 9621 /* 403 is from SPC-4, 7.2.10, Table 216, p 259*/ 9622 for (i=24;i<=403;i++) 9623 { 9624 pLogPage[i] = 0; /* vendor specific */ 9625 } 9626 9627 if (SELFTEST_RESULTS_LOG_PAGE_LENGTH < lenReceived) 9628 { 9629 TI_DBG6(("satLogSenseCB: 2nd underrun lenReceived %d len %d \n", lenReceived, SELFTEST_RESULTS_LOG_PAGE_LENGTH)); 9630 9631 /* underrun */ 9632 ostiInitiatorIOCompleted( tiRoot, 9633 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 9634 tiIOUnderRun, 9635 lenReceived - SELFTEST_RESULTS_LOG_PAGE_LENGTH, 9636 agNULL, 9637 satOrgIOContext->interruptContext ); 9638 9639 } 9640 else 9641 { 9642 ostiInitiatorIOCompleted( tiRoot, 9643 tiOrgIORequest, 9644 tiIOSuccess, 9645 SCSI_STAT_GOOD, 9646 agNULL, 9647 satOrgIOContext->interruptContext); 9648 } 9649 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9650 9651 satFreeIntIoResource( tiRoot, 9652 satDevData, 9653 satIntIo); 9654 9655 return; 9656 } 9657 else if (hostToDevFis->h.features == 0xda) 9658 { 9659 TI_DBG5(("satLogSenseCB: SAT_SMART_RETURN_STATUS success\n")); 9660 9661 /* fills in the log page from ATA output */ 9662 /* SPC-4, 7.2.5, Table 209, 211, p 255 */ 9663 pLogPage[0] = 0x2F; /* page code unspecified */ 9664 pLogPage[1] = 0; /* reserved */ 9665 pLogPage[2] = 0; /* page length */ 9666 pLogPage[3] = 0x07; /* page length */ 9667 9668 /* 9669 SPC-4, 7.2.5, Table 211, p 255 9670 no vendor specific field 9671 */ 9672 pLogPage[4] = 0; /* Parameter Code */ 9673 pLogPage[5] = 0; /* Parameter Code unspecfied but to do: */ 9674 pLogPage[6] = 0; /* unspecified */ 9675 pLogPage[7] = 0x03; /* Parameter length, unspecified */ 9676 9677 /* SAT rev8, 10.2.3.1 Table 72, p 73 */ 9678 if (statDevToHostFisData.lbaMid == 0x4F || statDevToHostFisData.lbaHigh == 0xC2) 9679 { 9680 pLogPage[8] = 0; /* Sense code */ 9681 pLogPage[9] = 0; /* Sense code qualifier */ 9682 } 9683 else if (statDevToHostFisData.lbaMid == 0xF4 || statDevToHostFisData.lbaHigh == 0x2C) 9684 { 9685 pLogPage[8] = 0x5D; /* Sense code */ 9686 pLogPage[9] = 0x10; /* Sense code qualifier */ 9687 } 9688 9689 /* Assumption: No support for SCT */ 9690 pLogPage[10] = 0xFF; /* Most Recent Temperature Reading */ 9691 9692 if (INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH < lenReceived) 9693 { 9694 TI_DBG6(("satLogSenseCB: 3rd underrun lenReceived %d len %d \n", lenReceived, INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH)); 9695 9696 /* underrun */ 9697 ostiInitiatorIOCompleted( tiRoot, 9698 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 9699 tiIOUnderRun, 9700 lenReceived - INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH, 9701 agNULL, 9702 satOrgIOContext->interruptContext ); 9703 9704 } 9705 else 9706 { 9707 ostiInitiatorIOCompleted( tiRoot, 9708 tiOrgIORequest, 9709 tiIOSuccess, 9710 SCSI_STAT_GOOD, 9711 agNULL, 9712 satOrgIOContext->interruptContext); 9713 } 9714 9715 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9716 9717 satFreeIntIoResource( tiRoot, 9718 satDevData, 9719 satIntIo); 9720 9721 9722 return; 9723 } 9724 else 9725 { 9726 TI_DBG1(("satLogSenseCB: error unknown command success 0x%x feature 0x%x\n", hostToDevFis->h.command, hostToDevFis->h.features)); 9727 satSetSensePayload( pSense, 9728 SCSI_SNSKEY_NO_SENSE, 9729 0, 9730 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 9731 satOrgIOContext); 9732 9733 ostiInitiatorIOCompleted( tiRoot, 9734 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 9735 tiIOSuccess, 9736 SCSI_STAT_CHECK_CONDITION, 9737 satOrgIOContext->pTiSenseData, 9738 satOrgIOContext->interruptContext ); 9739 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9740 9741 satFreeIntIoResource( tiRoot, 9742 satDevData, 9743 satIntIo); 9744 9745 return; 9746 } 9747 } 9748 else 9749 { 9750 TI_DBG1(("satLogSenseCB: error unknown command success 0x%x\n", hostToDevFis->h.command)); 9751 satSetSensePayload( pSense, 9752 SCSI_SNSKEY_NO_SENSE, 9753 0, 9754 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 9755 satOrgIOContext); 9756 9757 ostiInitiatorIOCompleted( tiRoot, 9758 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 9759 tiIOSuccess, 9760 SCSI_STAT_CHECK_CONDITION, 9761 satOrgIOContext->pTiSenseData, 9762 satOrgIOContext->interruptContext ); 9763 9764 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9765 9766 satFreeIntIoResource( tiRoot, 9767 satDevData, 9768 satIntIo); 9769 9770 return; 9771 } 9772 9773 return; 9774 } 9775 9776 /***************************************************************************** 9777 *! \brief satReadMediaSerialNumberCB 9778 * 9779 * This routine is a callback function called from ossaSATACompleted(). 9780 * This CB routine deals with Read Media Serial Number completion. 9781 * 9782 * \param agRoot: Handles for this instance of SAS/SATA hardware 9783 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 9784 * \param agIOStatus: Status of completed I/O. 9785 * \param agSATAParm1: Additional info based on status. 9786 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 9787 * length. 9788 * \param ioContext: Pointer to satIOContext_t. 9789 * 9790 * \return: none 9791 * 9792 *****************************************************************************/ 9793 void satReadMediaSerialNumberCB( 9794 agsaRoot_t *agRoot, 9795 agsaIORequest_t *agIORequest, 9796 bit32 agIOStatus, 9797 agsaFisHeader_t *agFirstDword, 9798 bit32 agIOInfoLen, 9799 agsaFrameHandle_t agFrameHandle, 9800 void *ioContext 9801 ) 9802 { 9803 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 9804 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 9805 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 9806 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 9807 tdIORequestBody_t *tdIORequestBody; 9808 tdIORequestBody_t *tdOrgIORequestBody; 9809 satIOContext_t *satIOContext; 9810 satIOContext_t *satOrgIOContext; 9811 satInternalIo_t *satIntIo; 9812 satDeviceData_t *satDevData; 9813 9814 scsiRspSense_t *pSense; 9815 tiIORequest_t *tiOrgIORequest; 9816 9817 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 9818 tiScsiInitiatorRequest_t *tiOrgScsiRequest; /* tiScsiXchg */ 9819 bit8 *pMediaSerialNumber; 9820 9821 tiIniScsiCmnd_t *scsiCmnd; 9822 bit32 lenReceived = 0; 9823 9824 TI_DBG4(("satReadMediaSerialNumberCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 9825 9826 /* internally generate tiIOContext */ 9827 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 9828 satIOContext = (satIOContext_t *) ioContext; 9829 satIntIo = satIOContext->satIntIoContext; 9830 satDevData = satIOContext->pSatDevData; 9831 hostToDevFis = satIOContext->pFis; 9832 9833 if (satIntIo == agNULL) 9834 { 9835 TI_DBG4(("satReadMediaSerialNumberCB: External satInternalIo_t satIntIoContext\n")); 9836 satOrgIOContext = satIOContext; 9837 tiOrgIORequest = tdIORequestBody->tiIORequest; 9838 pSense = satOrgIOContext->pSense; 9839 tiOrgScsiRequest = satOrgIOContext->tiScsiXchg; 9840 /* SCSI command response payload to OS layer */ 9841 pMediaSerialNumber = (bit8 *) tiOrgScsiRequest->sglVirtualAddr; 9842 /* ATA command response payload */ 9843 scsiCmnd = satOrgIOContext->pScsiCmnd; 9844 9845 9846 } 9847 else 9848 { 9849 TI_DBG4(("satReadMediaSerialNumberCB: Internal satInternalIo_t satIntIoContext\n")); 9850 satOrgIOContext = satIOContext->satOrgIOContext; 9851 if (satOrgIOContext == agNULL) 9852 { 9853 TI_DBG4(("satReadMediaSerialNumberCB: satOrgIOContext is NULL, wrong\n")); 9854 return; 9855 } 9856 else 9857 { 9858 TI_DBG4(("satReadMediaSerialNumberCB: satOrgIOContext is NOT NULL\n")); 9859 } 9860 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 9861 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 9862 9863 pSense = satOrgIOContext->pSense; 9864 tiOrgScsiRequest = satOrgIOContext->tiScsiXchg; 9865 /* SCSI command response payload to OS layer */ 9866 pMediaSerialNumber = (bit8 *) tiOrgScsiRequest->sglVirtualAddr; 9867 /* ATA command response payload */ 9868 scsiCmnd = satOrgIOContext->pScsiCmnd; 9869 } 9870 9871 tdIORequestBody->ioCompleted = agTRUE; 9872 tdIORequestBody->ioStarted = agFALSE; 9873 9874 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 9875 { 9876 TI_DBG1(("satReadMediaSerialNumberCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 9877 ostiInitiatorIOCompleted ( 9878 tiRoot, 9879 tiOrgIORequest, 9880 tiIOFailed, 9881 tiDetailOtherError, 9882 agNULL, 9883 satOrgIOContext->interruptContext 9884 ); 9885 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9886 9887 satFreeIntIoResource( tiRoot, 9888 satDevData, 9889 satIntIo); 9890 return; 9891 } 9892 9893 if( agIOStatus != OSSA_IO_SUCCESS) 9894 { 9895 /* Process abort case */ 9896 if (agIOStatus == OSSA_IO_ABORTED) 9897 { 9898 satProcessAbort(tiRoot, 9899 tiOrgIORequest, 9900 satOrgIOContext 9901 ); 9902 9903 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9904 9905 satFreeIntIoResource( tiRoot, 9906 satDevData, 9907 satIntIo); 9908 return; 9909 } 9910 satSetSensePayload( pSense, 9911 SCSI_SNSKEY_NOT_READY, 9912 0, 9913 SCSI_SNSCODE_MEDIUM_NOT_PRESENT, 9914 satOrgIOContext); 9915 9916 ostiInitiatorIOCompleted( tiRoot, 9917 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 9918 tiIOSuccess, 9919 SCSI_STAT_CHECK_CONDITION, 9920 satOrgIOContext->pTiSenseData, 9921 satOrgIOContext->interruptContext ); 9922 9923 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9924 9925 satFreeIntIoResource( tiRoot, 9926 satDevData, 9927 satIntIo); 9928 return; 9929 } 9930 9931 /* process success case */ 9932 lenReceived = (scsiCmnd->cdb[6] << (8*3)) + (scsiCmnd->cdb[7] << (8*2)) 9933 + (scsiCmnd->cdb[8] << 8) + scsiCmnd->cdb[9]; 9934 TI_DBG5(("satReadMediaSerialNumberCB: lenReceived in CDB %d 0x%x\n", lenReceived,lenReceived)); 9935 9936 if (hostToDevFis->h.command == SAT_READ_SECTORS || 9937 hostToDevFis->h.command == SAT_READ_SECTORS_EXT 9938 ) 9939 { 9940 pMediaSerialNumber[0] = 0; 9941 pMediaSerialNumber[1] = 0; 9942 pMediaSerialNumber[2] = 0; 9943 pMediaSerialNumber[3] = 4; 9944 pMediaSerialNumber[4] = 0; 9945 pMediaSerialNumber[5] = 0; 9946 pMediaSerialNumber[6] = 0; 9947 pMediaSerialNumber[7] = 0; 9948 9949 if (ZERO_MEDIA_SERIAL_NUMBER_LENGTH < lenReceived) 9950 { 9951 TI_DBG1(("satReadMediaSerialNumberCB: 1st underrun lenReceived %d len %d \n", lenReceived, ZERO_MEDIA_SERIAL_NUMBER_LENGTH)); 9952 9953 /* underrun */ 9954 ostiInitiatorIOCompleted( tiRoot, 9955 tiOrgIORequest, /* == satIntIo->satOrgTiIORequest */ 9956 tiIOUnderRun, 9957 lenReceived - ZERO_MEDIA_SERIAL_NUMBER_LENGTH, 9958 agNULL, 9959 satOrgIOContext->interruptContext ); 9960 9961 } 9962 else 9963 { 9964 ostiInitiatorIOCompleted( tiRoot, 9965 tiOrgIORequest, 9966 tiIOSuccess, 9967 SCSI_STAT_GOOD, 9968 agNULL, 9969 satOrgIOContext->interruptContext); 9970 } 9971 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9972 9973 satFreeIntIoResource( tiRoot, 9974 satDevData, 9975 satIntIo); 9976 return; 9977 } 9978 else 9979 { 9980 TI_DBG1(("satReadMediaSerialNumberCB: error unknown command success 0x%x\n", hostToDevFis->h.command)); 9981 satSetSensePayload( pSense, 9982 SCSI_SNSKEY_NO_SENSE, 9983 0, 9984 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 9985 satOrgIOContext); 9986 9987 ostiInitiatorIOCompleted( tiRoot, 9988 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 9989 tiIOSuccess, 9990 SCSI_STAT_CHECK_CONDITION, 9991 satOrgIOContext->pTiSenseData, 9992 satOrgIOContext->interruptContext ); 9993 9994 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 9995 9996 satFreeIntIoResource( tiRoot, 9997 satDevData, 9998 satIntIo); 9999 10000 return; 10001 } 10002 return; 10003 } 10004 10005 /***************************************************************************** 10006 *! \brief satReadBufferCB 10007 * 10008 * This routine is a callback function called from ossaSATACompleted(). 10009 * This CB routine deals with Read Buffer. 10010 * 10011 * \param agRoot: Handles for this instance of SAS/SATA hardware 10012 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 10013 * \param agIOStatus: Status of completed I/O. 10014 * \param agSATAParm1: Additional info based on status. 10015 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 10016 * length. 10017 * \param ioContext: Pointer to satIOContext_t. 10018 * 10019 * \return: none 10020 * 10021 *****************************************************************************/ 10022 void satReadBufferCB( 10023 agsaRoot_t *agRoot, 10024 agsaIORequest_t *agIORequest, 10025 bit32 agIOStatus, 10026 agsaFisHeader_t *agFirstDword, 10027 bit32 agIOInfoLen, 10028 agsaFrameHandle_t agFrameHandle, 10029 void *ioContext 10030 ) 10031 { 10032 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 10033 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 10034 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 10035 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 10036 tdIORequestBody_t *tdIORequestBody; 10037 tdIORequestBody_t *tdOrgIORequestBody; 10038 satIOContext_t *satIOContext; 10039 satIOContext_t *satOrgIOContext; 10040 satInternalIo_t *satIntIo; 10041 satDeviceData_t *satDevData; 10042 scsiRspSense_t *pSense; 10043 tiIORequest_t *tiOrgIORequest; 10044 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 10045 10046 TI_DBG4(("satReadBufferCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 10047 10048 /* internally generate tiIOContext */ 10049 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 10050 satIOContext = (satIOContext_t *) ioContext; 10051 satIntIo = satIOContext->satIntIoContext; 10052 satDevData = satIOContext->pSatDevData; 10053 hostToDevFis = satIOContext->pFis; 10054 10055 10056 if (satIntIo == agNULL) 10057 { 10058 TI_DBG4(("satReadBufferCB: External satInternalIo_t satIntIoContext\n")); 10059 satOrgIOContext = satIOContext; 10060 tiOrgIORequest = tdIORequestBody->tiIORequest; 10061 pSense = satOrgIOContext->pSense; 10062 10063 /* SCSI command response payload to OS layer */ 10064 10065 /* ATA command response payload */ 10066 10067 } 10068 else 10069 { 10070 TI_DBG4(("satReadBufferCB: Internal satInternalIo_t satIntIoContext\n")); 10071 satOrgIOContext = satIOContext->satOrgIOContext; 10072 if (satOrgIOContext == agNULL) 10073 { 10074 TI_DBG4(("satReadBufferCB: satOrgIOContext is NULL, wrong\n")); 10075 return; 10076 } 10077 else 10078 { 10079 TI_DBG4(("satReadBufferCB: satOrgIOContext is NOT NULL\n")); 10080 } 10081 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 10082 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 10083 10084 pSense = satOrgIOContext->pSense; 10085 10086 /* SCSI command response payload to OS layer */ 10087 10088 /* ATA command response payload */ 10089 10090 } 10091 10092 tdIORequestBody->ioCompleted = agTRUE; 10093 tdIORequestBody->ioStarted = agFALSE; 10094 10095 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 10096 { 10097 TI_DBG1(("satReadBufferCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 10098 ostiInitiatorIOCompleted ( 10099 tiRoot, 10100 tiOrgIORequest, 10101 tiIOFailed, 10102 tiDetailOtherError, 10103 agNULL, 10104 satOrgIOContext->interruptContext 10105 ); 10106 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10107 10108 satFreeIntIoResource( tiRoot, 10109 satDevData, 10110 satIntIo); 10111 return; 10112 } 10113 10114 if( agIOStatus != OSSA_IO_SUCCESS) 10115 { 10116 /* Process abort case */ 10117 if (agIOStatus == OSSA_IO_ABORTED) 10118 { 10119 satProcessAbort(tiRoot, 10120 tiOrgIORequest, 10121 satOrgIOContext 10122 ); 10123 10124 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10125 10126 satFreeIntIoResource( tiRoot, 10127 satDevData, 10128 satIntIo); 10129 return; 10130 } 10131 satSetSensePayload( pSense, 10132 SCSI_SNSKEY_NOT_READY, 10133 0, 10134 SCSI_SNSCODE_MEDIUM_NOT_PRESENT, 10135 satOrgIOContext); 10136 10137 ostiInitiatorIOCompleted( tiRoot, 10138 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 10139 tiIOSuccess, 10140 SCSI_STAT_CHECK_CONDITION, 10141 satOrgIOContext->pTiSenseData, 10142 satOrgIOContext->interruptContext ); 10143 10144 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10145 10146 satFreeIntIoResource( tiRoot, 10147 satDevData, 10148 satIntIo); 10149 return; 10150 } 10151 10152 /* process success case */ 10153 if (hostToDevFis->h.command == SAT_READ_BUFFER ) 10154 { 10155 10156 ostiInitiatorIOCompleted( tiRoot, 10157 tiOrgIORequest, 10158 tiIOSuccess, 10159 SCSI_STAT_GOOD, 10160 agNULL, 10161 satOrgIOContext->interruptContext); 10162 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10163 10164 satFreeIntIoResource( tiRoot, 10165 satDevData, 10166 satIntIo); 10167 return; 10168 } 10169 else 10170 { 10171 TI_DBG1(("satReadBufferCB: error unknown command success 0x%x\n", hostToDevFis->h.command)); 10172 satSetSensePayload( pSense, 10173 SCSI_SNSKEY_NO_SENSE, 10174 0, 10175 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 10176 satOrgIOContext); 10177 10178 ostiInitiatorIOCompleted( tiRoot, 10179 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 10180 tiIOSuccess, 10181 SCSI_STAT_CHECK_CONDITION, 10182 satOrgIOContext->pTiSenseData, 10183 satOrgIOContext->interruptContext ); 10184 10185 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10186 10187 satFreeIntIoResource( tiRoot, 10188 satDevData, 10189 satIntIo); 10190 10191 return; 10192 } 10193 10194 return; 10195 } 10196 10197 /***************************************************************************** 10198 *! \brief satWriteBufferCB 10199 * 10200 * This routine is a callback function called from ossaSATACompleted(). 10201 * This CB routine deals with Write Buffer. 10202 * 10203 * \param agRoot: Handles for this instance of SAS/SATA hardware 10204 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 10205 * \param agIOStatus: Status of completed I/O. 10206 * \param agSATAParm1: Additional info based on status. 10207 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 10208 * length. 10209 * \param ioContext: Pointer to satIOContext_t. 10210 * 10211 * \return: none 10212 * 10213 *****************************************************************************/ 10214 void satWriteBufferCB( 10215 agsaRoot_t *agRoot, 10216 agsaIORequest_t *agIORequest, 10217 bit32 agIOStatus, 10218 agsaFisHeader_t *agFirstDword, 10219 bit32 agIOInfoLen, 10220 agsaFrameHandle_t agFrameHandle, 10221 void *ioContext 10222 ) 10223 { 10224 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 10225 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 10226 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 10227 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 10228 tdIORequestBody_t *tdIORequestBody; 10229 tdIORequestBody_t *tdOrgIORequestBody; 10230 satIOContext_t *satIOContext; 10231 satIOContext_t *satOrgIOContext; 10232 satInternalIo_t *satIntIo; 10233 satDeviceData_t *satDevData; 10234 scsiRspSense_t *pSense; 10235 tiIORequest_t *tiOrgIORequest; 10236 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 10237 10238 TI_DBG4(("satWriteBufferCB:agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 10239 10240 /* internally generate tiIOContext */ 10241 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 10242 satIOContext = (satIOContext_t *) ioContext; 10243 satIntIo = satIOContext->satIntIoContext; 10244 satDevData = satIOContext->pSatDevData; 10245 hostToDevFis = satIOContext->pFis; 10246 10247 10248 if (satIntIo == agNULL) 10249 { 10250 TI_DBG4(("satWriteBufferCB: External satInternalIo_t satIntIoContext\n")); 10251 satOrgIOContext = satIOContext; 10252 tiOrgIORequest = tdIORequestBody->tiIORequest; 10253 pSense = satOrgIOContext->pSense; 10254 /* SCSI command response payload to OS layer */ 10255 10256 /* ATA command response payload */ 10257 10258 } 10259 else 10260 { 10261 TI_DBG4(("satWriteBufferCB: Internal satInternalIo_t satIntIoContext\n")); 10262 satOrgIOContext = satIOContext->satOrgIOContext; 10263 if (satOrgIOContext == agNULL) 10264 { 10265 TI_DBG4(("satWriteBufferCB: satOrgIOContext is NULL, wrong\n")); 10266 return; 10267 } 10268 else 10269 { 10270 TI_DBG4(("satWriteBufferCB: satOrgIOContext is NOT NULL\n")); 10271 } 10272 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 10273 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 10274 10275 pSense = satOrgIOContext->pSense; 10276 /* SCSI command response payload to OS layer */ 10277 10278 /* ATA command response payload */ 10279 10280 } 10281 10282 tdIORequestBody->ioCompleted = agTRUE; 10283 tdIORequestBody->ioStarted = agFALSE; 10284 10285 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 10286 { 10287 TI_DBG1(("satWriteBufferCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 10288 ostiInitiatorIOCompleted ( 10289 tiRoot, 10290 tiOrgIORequest, 10291 tiIOFailed, 10292 tiDetailOtherError, 10293 agNULL, 10294 satOrgIOContext->interruptContext 10295 ); 10296 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10297 10298 satFreeIntIoResource( tiRoot, 10299 satDevData, 10300 satIntIo); 10301 return; 10302 } 10303 10304 if( agIOStatus != OSSA_IO_SUCCESS) 10305 { 10306 /* Process abort case */ 10307 if (agIOStatus == OSSA_IO_ABORTED) 10308 { 10309 satProcessAbort(tiRoot, 10310 tiOrgIORequest, 10311 satOrgIOContext 10312 ); 10313 10314 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10315 10316 satFreeIntIoResource( tiRoot, 10317 satDevData, 10318 satIntIo); 10319 return; 10320 } 10321 satSetSensePayload( pSense, 10322 SCSI_SNSKEY_NOT_READY, 10323 0, 10324 SCSI_SNSCODE_MEDIUM_NOT_PRESENT, 10325 satOrgIOContext); 10326 10327 ostiInitiatorIOCompleted( tiRoot, 10328 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 10329 tiIOSuccess, 10330 SCSI_STAT_CHECK_CONDITION, 10331 satOrgIOContext->pTiSenseData, 10332 satOrgIOContext->interruptContext ); 10333 10334 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10335 10336 satFreeIntIoResource( tiRoot, 10337 satDevData, 10338 satIntIo); 10339 return; 10340 } 10341 /* process success case */ 10342 if (hostToDevFis->h.command == SAT_WRITE_BUFFER ) 10343 { 10344 10345 ostiInitiatorIOCompleted( tiRoot, 10346 tiOrgIORequest, 10347 tiIOSuccess, 10348 SCSI_STAT_GOOD, 10349 agNULL, 10350 satOrgIOContext->interruptContext); 10351 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10352 10353 satFreeIntIoResource( tiRoot, 10354 satDevData, 10355 satIntIo); 10356 return; 10357 } 10358 else 10359 { 10360 TI_DBG1(("satWriteBufferCB: error unknown command success 0x%x\n", hostToDevFis->h.command)); 10361 satSetSensePayload( pSense, 10362 SCSI_SNSKEY_NO_SENSE, 10363 0, 10364 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 10365 satOrgIOContext); 10366 10367 ostiInitiatorIOCompleted( tiRoot, 10368 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 10369 tiIOSuccess, 10370 SCSI_STAT_CHECK_CONDITION, 10371 satOrgIOContext->pTiSenseData, 10372 satOrgIOContext->interruptContext ); 10373 10374 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10375 10376 satFreeIntIoResource( tiRoot, 10377 satDevData, 10378 satIntIo); 10379 10380 return; 10381 } 10382 10383 return; 10384 } 10385 10386 /***************************************************************************** 10387 *! \brief satReassignBlocksCB 10388 * 10389 * This routine is a callback function called from ossaSATACompleted(). 10390 * This CB routine deals with Reassign Blocks. 10391 * 10392 * \param agRoot: Handles for this instance of SAS/SATA hardware 10393 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 10394 * \param agIOStatus: Status of completed I/O. 10395 * \param agSATAParm1: Additional info based on status. 10396 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 10397 * length. 10398 * \param ioContext: Pointer to satIOContext_t. 10399 * 10400 * \return: none 10401 * 10402 *****************************************************************************/ 10403 void satReassignBlocksCB( 10404 agsaRoot_t *agRoot, 10405 agsaIORequest_t *agIORequest, 10406 bit32 agIOStatus, 10407 agsaFisHeader_t *agFirstDword, 10408 bit32 agIOInfoLen, 10409 agsaFrameHandle_t agFrameHandle, 10410 void *ioContext 10411 ) 10412 { 10413 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 10414 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 10415 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 10416 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 10417 tdIORequestBody_t *tdIORequestBody; 10418 tdIORequestBody_t *tdOrgIORequestBody; 10419 satIOContext_t *satIOContext; 10420 satIOContext_t *satOrgIOContext; 10421 satIOContext_t *satNewIOContext; 10422 satInternalIo_t *satIntIo; 10423 satInternalIo_t *satNewIntIo = agNULL; 10424 satDeviceData_t *satDevData; 10425 10426 scsiRspSense_t *pSense; 10427 tiIniScsiCmnd_t *scsiCmnd; 10428 tiIORequest_t *tiOrgIORequest; 10429 10430 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 10431 bit32 ataStatus = 0; 10432 bit32 status; 10433 tiScsiInitiatorRequest_t *tiScsiRequest; /* tiScsiXchg */ 10434 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 10435 10436 TI_DBG5(("satReassignBlocksCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 10437 10438 /* internally generate tiIOContext */ 10439 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 10440 satIOContext = (satIOContext_t *) ioContext; 10441 satIntIo = satIOContext->satIntIoContext; 10442 satDevData = satIOContext->pSatDevData; 10443 hostToDevFis = satIOContext->pFis; 10444 10445 if (satIntIo == agNULL) 10446 { 10447 TI_DBG4(("satReassignBlocksCB: External satInternalIo_t satIntIoContext\n")); 10448 satOrgIOContext = satIOContext; 10449 tiOrgIORequest = tdIORequestBody->tiIORequest; 10450 tiScsiRequest = satOrgIOContext->tiScsiXchg; 10451 pSense = satOrgIOContext->pSense; 10452 scsiCmnd = satOrgIOContext->pScsiCmnd; 10453 } 10454 else 10455 { 10456 TI_DBG4(("satReassignBlocksCB: Internal satInternalIo_t satIntIoContext\n")); 10457 satOrgIOContext = satIOContext->satOrgIOContext; 10458 if (satOrgIOContext == agNULL) 10459 { 10460 TI_DBG4(("satReassignBlocksCB: satOrgIOContext is NULL, Wrong\n")); 10461 return; 10462 } 10463 else 10464 { 10465 TI_DBG4(("satReassignBlocksCB: satOrgIOContext is NOT NULL, Wrong\n")); 10466 } 10467 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 10468 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 10469 10470 tiScsiRequest = satOrgIOContext->tiScsiXchg; 10471 pSense = satOrgIOContext->pSense; 10472 scsiCmnd = satOrgIOContext->pScsiCmnd; 10473 } 10474 10475 tdIORequestBody->ioCompleted = agTRUE; 10476 tdIORequestBody->ioStarted = agFALSE; 10477 10478 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 10479 { 10480 TI_DBG1(("satReassignBlocksCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 10481 ostiInitiatorIOCompleted ( 10482 tiRoot, 10483 tiOrgIORequest, 10484 tiIOFailed, 10485 tiDetailOtherError, 10486 agNULL, 10487 satOrgIOContext->interruptContext 10488 ); 10489 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10490 10491 satFreeIntIoResource( tiRoot, 10492 satDevData, 10493 satIntIo); 10494 return; 10495 } 10496 10497 if (agIOStatus != OSSA_IO_SUCCESS) 10498 { 10499 /* only agsaFisRegDeviceToHost_t is expected */ 10500 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 10501 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 10502 } 10503 10504 if (agIOStatus != OSSA_IO_SUCCESS) 10505 { 10506 if ( (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) || 10507 ((ataStatus & ERR_ATA_STATUS_MASK) || (ataStatus & DF_ATA_STATUS_MASK)) 10508 ) 10509 { 10510 /* for debugging */ 10511 if( agIOStatus != OSSA_IO_SUCCESS) 10512 { 10513 TI_DBG1(("satReassignBlocksCB FAILED, NOT IO_SUCCESS\n")); 10514 } 10515 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 10516 { 10517 TI_DBG1(("satReassignBlocksCB FAILED, Wrong FIS type 0x%x\n",statDevToHostFisHeader->fisType)); 10518 } 10519 else if ( (ataStatus & ERR_ATA_STATUS_MASK) || 10520 (ataStatus & DF_ATA_STATUS_MASK) 10521 ) 10522 { 10523 TI_DBG1(("satReassignBlocksCB FAILED, FAILED, error status\n")); 10524 } 10525 10526 /* Process abort case */ 10527 if (agIOStatus == OSSA_IO_ABORTED) 10528 { 10529 satProcessAbort(tiRoot, 10530 tiOrgIORequest, 10531 satOrgIOContext 10532 ); 10533 10534 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10535 10536 satFreeIntIoResource( tiRoot, 10537 satDevData, 10538 satIntIo); 10539 return; 10540 } 10541 10542 /* for debugging */ 10543 if (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS || 10544 hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT 10545 ) 10546 { 10547 TI_DBG1(("satReassignBlocksCB SAT_READ_VERIFY_SECTORS(_EXT) failed\n")); 10548 /* Verify failed; send Write with same LBA */ 10549 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10550 10551 satFreeIntIoResource( tiRoot, 10552 satDevData, 10553 satIntIo); 10554 10555 satNewIntIo = satAllocIntIoResource( tiRoot, 10556 tiOrgIORequest, 10557 satDevData, 10558 512, /* writing 1 sector */ 10559 satNewIntIo); 10560 if (satNewIntIo == agNULL) 10561 { 10562 /* memory allocation failure */ 10563 satFreeIntIoResource( tiRoot, 10564 satDevData, 10565 satNewIntIo); 10566 10567 satSetSensePayload( pSense, 10568 SCSI_SNSKEY_HARDWARE_ERROR, 10569 0, 10570 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 10571 satOrgIOContext); 10572 10573 ostiInitiatorIOCompleted( tiRoot, 10574 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 10575 tiIOSuccess, 10576 SCSI_STAT_CHECK_CONDITION, 10577 satOrgIOContext->pTiSenseData, 10578 satOrgIOContext->interruptContext ); 10579 TI_DBG1(("satReassignBlocksCB: momory allocation fails\n")); 10580 return; 10581 } /* end memory allocation */ 10582 10583 satNewIOContext = satPrepareNewIO( 10584 satNewIntIo, 10585 tiOrgIORequest, 10586 satDevData, 10587 scsiCmnd, 10588 satOrgIOContext 10589 ); 10590 10591 /* send Write with same LBA */ 10592 status = satReassignBlocks_2( 10593 tiRoot, 10594 &satNewIntIo->satIntTiIORequest, 10595 satNewIOContext->ptiDeviceHandle, 10596 &satNewIntIo->satIntTiScsiXchg, 10597 satNewIOContext, 10598 satOrgIOContext->LBA 10599 ); 10600 10601 if (status != tiSuccess) 10602 { 10603 /* sending ATA command fails */ 10604 satFreeIntIoResource( tiRoot, 10605 satDevData, 10606 satNewIntIo); 10607 satSetSensePayload( pSense, 10608 SCSI_SNSKEY_HARDWARE_ERROR, 10609 0, 10610 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 10611 satOrgIOContext); 10612 10613 ostiInitiatorIOCompleted( tiRoot, 10614 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 10615 tiIOSuccess, 10616 SCSI_STAT_CHECK_CONDITION, 10617 satOrgIOContext->pTiSenseData, 10618 satOrgIOContext->interruptContext ); 10619 TI_DBG1(("satReassignBlocksCB calling fail 1\n")); 10620 return; 10621 } /* end send fails */ 10622 10623 return; 10624 } 10625 else if (hostToDevFis->h.command == SAT_WRITE_DMA || 10626 hostToDevFis->h.command == SAT_WRITE_SECTORS || 10627 hostToDevFis->h.command == SAT_WRITE_DMA_EXT || 10628 hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT || 10629 hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED 10630 ) 10631 { 10632 TI_DBG1(("satReassignBlocksCB SAT_WRITE failed\n")); 10633 /* fall through */ 10634 } 10635 else 10636 { 10637 TI_DBG1(("satReassignBlocksCB error default case unexpected command 0x%x\n", hostToDevFis->h.command)); 10638 } 10639 10640 10641 satSetSensePayload( pSense, 10642 SCSI_SNSKEY_HARDWARE_ERROR, 10643 0, 10644 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 10645 satOrgIOContext); 10646 10647 ostiInitiatorIOCompleted( tiRoot, 10648 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 10649 tiIOSuccess, 10650 SCSI_STAT_CHECK_CONDITION, 10651 satOrgIOContext->pTiSenseData, 10652 satOrgIOContext->interruptContext ); 10653 10654 10655 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10656 10657 satFreeIntIoResource( tiRoot, 10658 satDevData, 10659 satIntIo); 10660 return; 10661 } /* error checking */ 10662 } 10663 10664 10665 /* prcessing the success case */ 10666 if (hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS || 10667 hostToDevFis->h.command == SAT_READ_VERIFY_SECTORS_EXT || 10668 hostToDevFis->h.command == SAT_WRITE_DMA || 10669 hostToDevFis->h.command == SAT_WRITE_SECTORS || 10670 hostToDevFis->h.command == SAT_WRITE_DMA_EXT || 10671 hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT || 10672 hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED 10673 ) 10674 { 10675 /* next LBA; verify */ 10676 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10677 10678 satFreeIntIoResource( tiRoot, 10679 satDevData, 10680 satIntIo); 10681 10682 if (satOrgIOContext->ParmIndex >= satOrgIOContext->ParmLen) 10683 { 10684 TI_DBG5(("satReassignBlocksCB: GOOD status\n")); 10685 /* return stat_good */ 10686 ostiInitiatorIOCompleted( tiRoot, 10687 tiOrgIORequest, 10688 tiIOSuccess, 10689 SCSI_STAT_GOOD, 10690 agNULL, 10691 satOrgIOContext->interruptContext ); 10692 return; 10693 } 10694 else 10695 { 10696 TI_DBG5(("satReassignBlocksCB: processing next LBA\n")); 10697 satNewIntIo = satAllocIntIoResource( tiRoot, 10698 tiOrgIORequest, 10699 satDevData, 10700 0, 10701 satNewIntIo); 10702 if (satNewIntIo == agNULL) 10703 { 10704 /* memory allocation failure */ 10705 satFreeIntIoResource( tiRoot, 10706 satDevData, 10707 satNewIntIo); 10708 10709 satSetSensePayload( pSense, 10710 SCSI_SNSKEY_HARDWARE_ERROR, 10711 0, 10712 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 10713 satOrgIOContext); 10714 10715 ostiInitiatorIOCompleted( tiRoot, 10716 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 10717 tiIOSuccess, 10718 SCSI_STAT_CHECK_CONDITION, 10719 satOrgIOContext->pTiSenseData, 10720 satOrgIOContext->interruptContext ); 10721 TI_DBG1(("satReassignBlocksCB: momory allocation fails\n")); 10722 return; 10723 } /* end memory allocation */ 10724 10725 satNewIOContext = satPrepareNewIO( 10726 satNewIntIo, 10727 tiOrgIORequest, 10728 satDevData, 10729 scsiCmnd, 10730 satOrgIOContext 10731 ); 10732 10733 /* send Verify with the next LBA */ 10734 status = satReassignBlocks_1( 10735 tiRoot, 10736 &satNewIntIo->satIntTiIORequest, 10737 satNewIOContext->ptiDeviceHandle, 10738 tiScsiRequest, /* orginal from OS layer */ 10739 satNewIOContext, 10740 satOrgIOContext 10741 ); 10742 10743 if (status != tiSuccess) 10744 { 10745 /* sending ATA command fails */ 10746 satFreeIntIoResource( tiRoot, 10747 satDevData, 10748 satNewIntIo); 10749 satSetSensePayload( pSense, 10750 SCSI_SNSKEY_HARDWARE_ERROR, 10751 0, 10752 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 10753 satOrgIOContext); 10754 10755 ostiInitiatorIOCompleted( tiRoot, 10756 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 10757 tiIOSuccess, 10758 SCSI_STAT_CHECK_CONDITION, 10759 satOrgIOContext->pTiSenseData, 10760 satOrgIOContext->interruptContext ); 10761 TI_DBG1(("satReassignBlocksCB calling satModeSelect6_1 fails\n")); 10762 return; 10763 } /* end send fails */ 10764 } /* else */ 10765 return; 10766 10767 } 10768 else if (hostToDevFis->h.command == SAT_WRITE_DMA || 10769 hostToDevFis->h.command == SAT_WRITE_SECTORS || 10770 hostToDevFis->h.command == SAT_WRITE_DMA_EXT || 10771 hostToDevFis->h.command == SAT_WRITE_SECTORS_EXT || 10772 hostToDevFis->h.command == SAT_WRITE_FPDMA_QUEUED 10773 ) 10774 { 10775 /* next LBA; verify */ 10776 } 10777 else 10778 { 10779 TI_DBG1(("satReassignBlocksCB error unknown command success 0x%x \n", hostToDevFis->h.command)); 10780 10781 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 10782 10783 satFreeIntIoResource( tiRoot, 10784 satDevData, 10785 satIntIo); 10786 satSetSensePayload( pSense, 10787 SCSI_SNSKEY_HARDWARE_ERROR, 10788 0, 10789 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 10790 satOrgIOContext); 10791 10792 ostiInitiatorIOCompleted( tiRoot, 10793 tiOrgIORequest, /* == &satIntIo->satOrgTiIORequest */ 10794 tiIOSuccess, 10795 SCSI_STAT_CHECK_CONDITION, 10796 satOrgIOContext->pTiSenseData, 10797 satOrgIOContext->interruptContext ); 10798 return; 10799 } 10800 return; 10801 } 10802 /***************************************************************************** 10803 *! \brief satReadLogExtCB 10804 * 10805 * This routine is a callback function called from ossaSATACompleted(). 10806 * This CB routine deals READ LOG EXT completion. 10807 * 10808 * \param agRoot: Handles for this instance of SAS/SATA hardware 10809 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 10810 * \param agIOStatus: Status of completed I/O. 10811 * \param agFirstDword:Pointer to the four bytes of FIS. 10812 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 10813 * length. 10814 * \param agParam: Additional info based on status. 10815 * \param ioContext: Pointer to satIOContext_t. 10816 * 10817 * \return: none 10818 * 10819 *****************************************************************************/ 10820 /* 10821 SATAII spec p42 10822 10823 */ 10824 void satReadLogExtCB( 10825 agsaRoot_t *agRoot, 10826 agsaIORequest_t *agIORequest, 10827 bit32 agIOStatus, 10828 agsaFisHeader_t *agFirstDword, 10829 bit32 agIOInfoLen, 10830 void *agParam, 10831 void *ioContext 10832 ) 10833 10834 { 10835 10836 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 10837 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 10838 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 10839 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 10840 tdIORequestBody_t *tdIORequestBody; 10841 satIOContext_t *satReadLogExtIOContext; 10842 satInternalIo_t *satIntIo; 10843 satDeviceData_t *satDevData; 10844 tdsaDeviceData_t *tdsaDeviceData; 10845 agsaIORequest_t *agAbortIORequest; 10846 tdIORequestBody_t *tdAbortIORequestBody; 10847 bit32 PhysUpper32; 10848 bit32 PhysLower32; 10849 bit32 memAllocStatus; 10850 void *osMemHandle; 10851 10852 TI_DBG1(("satReadLogExtCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", 10853 agIORequest, agIOStatus, agIOInfoLen)); 10854 10855 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 10856 satReadLogExtIOContext = (satIOContext_t *) ioContext; 10857 satIntIo = satReadLogExtIOContext->satIntIoContext; 10858 satDevData = satReadLogExtIOContext->pSatDevData; 10859 tdsaDeviceData = (tdsaDeviceData_t *)satDevData->satSaDeviceData; 10860 10861 TI_DBG1(("satReadLogExtCB: did %d\n", tdsaDeviceData->id)); 10862 satDecrementPendingIO(tiRoot, tdsaAllShared, satReadLogExtIOContext); 10863 10864 10865 tdIORequestBody->ioCompleted = agTRUE; 10866 tdIORequestBody->ioStarted = agFALSE; 10867 10868 /* 10869 * If READ LOG EXT failed, we issue device reset. 10870 */ 10871 if ( agIOStatus != OSSA_IO_SUCCESS || 10872 (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL && agIOInfoLen != 0) 10873 ) 10874 { 10875 TI_DBG1(("satReadLogExtCB: FAILED.\n")); 10876 10877 satFreeIntIoResource( tiRoot, 10878 satDevData, 10879 satIntIo); 10880 /* Abort I/O after completion of device reset */ 10881 satDevData->satAbortAfterReset = agTRUE; 10882 #ifdef NOT_YET 10883 /* needs to investigate this case */ 10884 /* no report to OS layer */ 10885 satSubTM(tiRoot, 10886 satReadLogExtIOContext->ptiDeviceHandle, 10887 TD_INTERNAL_TM_RESET, 10888 agNULL, 10889 agNULL, 10890 agNULL, 10891 agFALSE); 10892 #endif 10893 return; 10894 } 10895 10896 10897 /*************************************************************************** 10898 * The following steps take place when READ LOG EXT successfully completed. 10899 ***************************************************************************/ 10900 10901 /************************************************************************ 10902 * 10903 * 1. Issue abort to LL layer to all other pending I/Os for the same SATA 10904 * drive. 10905 * 10906 * 2. Free resource allocated for the internally generated READ LOG EXT. 10907 * 10908 * 3. At the completion of abort, in the context of ossaSATACompleted(), 10909 * return the I/O with error status to the OS-App Specific layer. 10910 * When all I/O aborts are completed, clear SATA device flag to 10911 * indicate ready to process new request. 10912 * 10913 ***********************************************************************/ 10914 10915 /* 10916 * Issue abort to LL layer to all other pending I/Os for the same SATA drive 10917 */ 10918 /* 10919 replace the single IO abort with device abort 10920 */ 10921 10922 TI_DBG1(("satReadLogExtCB: issuing saSATAAbort. Device Abort\n")); 10923 /* do not deregister this device */ 10924 tdsaDeviceData->OSAbortAll = agTRUE; 10925 10926 /* allocating agIORequest for abort itself */ 10927 memAllocStatus = ostiAllocMemory( 10928 tiRoot, 10929 &osMemHandle, 10930 (void **)&tdAbortIORequestBody, 10931 &PhysUpper32, 10932 &PhysLower32, 10933 8, 10934 sizeof(tdIORequestBody_t), 10935 agTRUE 10936 ); 10937 10938 if (memAllocStatus != tiSuccess) 10939 { 10940 /* let os process IO */ 10941 TI_DBG1(("satReadLogExtCB: ostiAllocMemory failed...\n")); 10942 return; 10943 } 10944 10945 if (tdAbortIORequestBody == agNULL) 10946 { 10947 /* let os process IO */ 10948 TI_DBG1(("satReadLogExtCB: ostiAllocMemory returned NULL tdAbortIORequestBody\n")); 10949 return; 10950 } 10951 10952 /* setup task management structure */ 10953 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 10954 tdAbortIORequestBody->tiDevHandle = (tiDeviceHandle_t *)&(tdsaDeviceData->tiDeviceHandle); 10955 /* initialize agIORequest */ 10956 agAbortIORequest = &(tdAbortIORequestBody->agIORequest); 10957 agAbortIORequest->osData = (void *) tdAbortIORequestBody; 10958 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */ 10959 10960 /* 10961 * Issue abort 10962 */ 10963 saSATAAbort( agRoot, agAbortIORequest, 0, tdsaDeviceData->agDevHandle, 1, agNULL, agNULL); 10964 10965 10966 /* 10967 * Free resource allocated for the internally generated READ LOG EXT. 10968 */ 10969 satFreeIntIoResource( tiRoot, 10970 satDevData, 10971 satIntIo); 10972 10973 /* 10974 * Sequence of recovery continue at some other context: 10975 * At the completion of abort, in the context of ossaSATACompleted(), 10976 * return the I/O with error status to the OS-App Specific layer. 10977 * When all I/O aborts are completed, clear SATA device flag to 10978 * indicate ready to process new request. 10979 */ 10980 10981 satDevData->satDriveState = SAT_DEV_STATE_NORMAL; 10982 10983 TI_DBG1(("satReadLogExtCB: end return\n")); 10984 return; 10985 } 10986 10987 #ifndef FDS_SM 10988 /***************************************************************************** 10989 *! \brief ossaSATAEvent 10990 * 10991 * This routine is called to notify the OS Layer of an event associated with 10992 * SATA port or SATA device 10993 * 10994 * \param agRoot: Handles for this instance of SAS/SATA hardware 10995 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 10996 * \param agPortContext Pointer to the port context of TD and Lower layer 10997 * \param agDevHandle: Pointer to a device handle 10998 * \param event: event type 10999 * 11000 * \return: none 11001 * 11002 *****************************************************************************/ 11003 osGLOBAL void ossaSATAEvent( 11004 agsaRoot_t *agRoot, 11005 agsaIORequest_t *agIORequest, 11006 agsaPortContext_t *agPortContext, 11007 agsaDevHandle_t *agDevHandle, 11008 bit32 event, 11009 bit32 agIOInfoLen, 11010 void *agParam 11011 ) 11012 { 11013 11014 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 11015 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 11016 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 11017 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 11018 bit32 interruptContext = osData->IntContext; 11019 tdsaDeviceData_t *pDeviceData; 11020 satDeviceData_t *pSatDevData; 11021 satInternalIo_t *satIntIo = agNULL; 11022 bit32 status; 11023 satIOContext_t *satIOContext2; 11024 tdIORequestBody_t *tdIORequestBody; 11025 tiDeviceHandle_t *tiDeviceHandle; 11026 tiIORequest_t tiIORequestTMP; 11027 agsaDifDetails_t agDifDetails; 11028 bit8 framePayload[256]; 11029 bit16 frameOffset = 0; 11030 bit16 frameLen = 0; 11031 11032 /* new */ 11033 tdsaDeviceData_t *tdsaDeviceData = agNULL; 11034 satIOContext_t *satIOContext; 11035 tdsaPortContext_t *onePortContext; 11036 11037 if (event == OSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE) 11038 { 11039 11040 /************************************************************************** 11041 * 11042 * !!!! See Section 13.5.2.4 of SATA 2.5 specs. !!!! 11043 * !!!! If the NCQ error ends up here, it means that the device sent !!!! 11044 * !!!! Register Device To Host FIS (which does not have SActive !!!! 11045 * !!!! register) instead of Set Device Bit FIS (which has SActive !!!! 11046 * !!!! register). The routine osSatIOCompleted() deals with the case !!!! 11047 * !!!! where Set Device Bit FIS was sent by the device. !!!! 11048 * 11049 * For NCQ we need to issue READ LOG EXT command with log page 10h 11050 * to get the error and to allow other I/Os to continue. 11051 * 11052 * Here is the basic flow or sequence of error recovery, this sequence is 11053 * similar to the one described in SATA 2.5: 11054 * 11055 * 1. Set SATA device flag to indicate error condition and returning busy 11056 * for all new request. 11057 * 11058 * 2. Prepare READ LOG EXT page 10h command. Set flag to indicate that 11059 * the failed I/O has NOT been returned to the OS Layer. Send command. 11060 * 11061 * 3. When the device receives READ LOG EXT page 10h request all other 11062 * pending I/O are implicitly aborted. No completion (aborted) status 11063 * will be sent to the host for these aborted commands. 11064 * 11065 * 4. SATL receives the completion for READ LOG EXT command in 11066 * satReadLogExtCB(). Steps 5,6,7,8 below are the step 1,2,3,4 in 11067 * satReadLogExtCB(). 11068 * 11069 * 5. Check flag that indicates whether the failed I/O has been returned 11070 * to the OS Layer. If not, search the I/O context in device data 11071 * looking for a matched tag. Then return the completion of the failed 11072 * NCQ command with the appopriate/trasnlated SCSI status. 11073 * 11074 * 6. Issue abort to LL layer to all other pending I/Os for the same SATA 11075 * drive. 11076 * 11077 * 7. Free resource allocated for the internally generated READ LOG EXT. 11078 * 11079 * 8. At the completion of abort, in the context of ossaSATACompleted(), 11080 * return the I/O with error status to the OS-App Specific layer. 11081 * When all I/O aborts are completed, clear SATA device flag to 11082 * indicate ready to process new request. 11083 * 11084 *************************************************************************/ 11085 11086 pDeviceData = (tdsaDeviceData_t *) agDevHandle->osData; 11087 pSatDevData = &pDeviceData->satDevData; 11088 tiDeviceHandle = &((tdsaDeviceData_t *)(pSatDevData->satSaDeviceData))->tiDeviceHandle; 11089 11090 TI_DBG1(("ossaSATAEvent: did %d\n", pDeviceData->id)); 11091 11092 if (pSatDevData->satDriveState == SAT_DEV_STATE_NORMAL) 11093 { 11094 TI_DBG1(("ossaSATAEvent: NCQ ERROR agDevHandle=%p.\n", agDevHandle )); 11095 11096 /* Set flag to indicate we are in recovery */ 11097 pSatDevData->satDriveState = SAT_DEV_STATE_IN_RECOVERY; 11098 11099 /* 11100 * Allocate resource for READ LOG EXIT page 10h 11101 */ 11102 satIntIo = satAllocIntIoResource( tiRoot, 11103 &(tiIORequestTMP), /* anything but NULL */ 11104 pSatDevData, 11105 sizeof (satReadLogExtPage10h_t), 11106 satIntIo); 11107 11108 /* 11109 * If we cannot allocate resource to do the normal NCQ recovery, we 11110 * will do SATA device reset. 11111 */ 11112 if (satIntIo == agNULL) 11113 { 11114 /* Abort I/O after completion of device reset */ 11115 pSatDevData->satAbortAfterReset = agTRUE; 11116 TI_DBG1(("ossaSATAEvent: can't send RLE due to resource lack\n")); 11117 11118 #ifdef NOT_YET 11119 /* needs to investigate this case */ 11120 /* no report to OS layer */ 11121 satSubTM(tiRoot, 11122 tiDeviceHandle, 11123 TD_INTERNAL_TM_RESET, 11124 agNULL, 11125 agNULL, 11126 agNULL, 11127 agFALSE); 11128 #endif 11129 11130 return; 11131 } 11132 11133 11134 /* 11135 * Clear flag to indicate that the failed I/O has NOT been returned to the 11136 * OS-App specific Layer. 11137 */ 11138 satIntIo->satIntFlag = 0; 11139 11140 /* compare to satPrepareNewIO() */ 11141 /* Send READ LOG EXIT page 10h command */ 11142 11143 /* 11144 * Need to initialize all the fields within satIOContext except 11145 * reqType and satCompleteCB which will be set depending on cmd. 11146 */ 11147 11148 tdIORequestBody = (tdIORequestBody_t *)satIntIo->satIntRequestBody; 11149 satIOContext2 = &(tdIORequestBody->transport.SATA.satIOContext); 11150 11151 satIOContext2->pSatDevData = pSatDevData; 11152 satIOContext2->pFis = &(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 11153 satIOContext2->pScsiCmnd = &(satIntIo->satIntTiScsiXchg.scsiCmnd); 11154 satIOContext2->pSense = &(tdIORequestBody->transport.SATA.sensePayload); 11155 satIOContext2->pTiSenseData = &(tdIORequestBody->transport.SATA.tiSenseData); 11156 satIOContext2->pTiSenseData->senseData = satIOContext2->pSense; 11157 11158 satIOContext2->tiRequestBody = satIntIo->satIntRequestBody; 11159 satIOContext2->interruptContext = interruptContext; 11160 satIOContext2->satIntIoContext = satIntIo; 11161 11162 satIOContext2->ptiDeviceHandle = tiDeviceHandle; 11163 satIOContext2->satOrgIOContext = agNULL; 11164 satIOContext2->tiScsiXchg = agNULL; 11165 11166 status = satSendReadLogExt( tiRoot, 11167 &satIntIo->satIntTiIORequest, 11168 tiDeviceHandle, 11169 &satIntIo->satIntTiScsiXchg, 11170 satIOContext2); 11171 11172 if (status !=tiSuccess) 11173 { 11174 TI_DBG1(("ossaSATAEvent: can't send RLE due to LL api failure\n")); 11175 satFreeIntIoResource( tiRoot, 11176 pSatDevData, 11177 satIntIo); 11178 /* Abort I/O after completion of device reset */ 11179 pSatDevData->satAbortAfterReset = agTRUE; 11180 #ifdef NOT_YET 11181 /* needs to investigate this case */ 11182 /* no report to OS layer */ 11183 satSubTM(tiRoot, 11184 tiDeviceHandle, 11185 TD_INTERNAL_TM_RESET, 11186 agNULL, 11187 agNULL, 11188 agNULL, 11189 agFALSE); 11190 #endif 11191 11192 return; 11193 } 11194 } 11195 else 11196 { 11197 TI_DBG1(("ossaSATAEvent: NCQ ERROR but recovery in progress\n")); 11198 } 11199 11200 } 11201 else if (event == OSSA_IO_XFER_CMD_FRAME_ISSUED) 11202 { 11203 TI_DBG1(("ossaSATAEvent: OSSA_IO_XFER_CMD_FRAME_ISSUED\n")); 11204 } 11205 else if (event == OSSA_IO_XFER_PIO_SETUP_ERROR) 11206 { 11207 TI_DBG1(("ossaSATAEvent: OSSA_IO_XFER_PIO_SETUP_ERROR\n")); 11208 11209 } 11210 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED) 11211 { 11212 TI_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED\n")); 11213 } 11214 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO) 11215 { 11216 TI_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO\n")); 11217 } 11218 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST) 11219 { 11220 TI_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST\n")); 11221 } 11222 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE) 11223 { 11224 TI_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE\n")); 11225 } 11226 else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED) 11227 { 11228 TI_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED\n")); 11229 } 11230 else if (event == OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH) 11231 { 11232 TI_DBG1(("ossaSATAEvent: OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH\n")); 11233 } 11234 else if (event == OSSA_IO_XFR_ERROR_DIF_MISMATCH || event == OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH || 11235 event == OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH || event == OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH) 11236 { 11237 TI_DBG1(("ossaSSPEvent: DIF related, event 0x%x\n", event)); 11238 /* process DIF detail information */ 11239 TI_DBG2(("ossaSSPEvent: agIOInfoLen %d\n", agIOInfoLen)); 11240 if (agParam == agNULL) 11241 { 11242 TI_DBG2(("ossaSSPEvent: agParam is NULL!!!\n")); 11243 return; 11244 } 11245 if (agIOInfoLen < sizeof(agsaDifDetails_t)) 11246 { 11247 TI_DBG2(("ossaSSPEvent: wrong agIOInfoLen!!! agIOInfoLen %d sizeof(agsaDifDetails_t) %d\n", agIOInfoLen, sizeof(agsaDifDetails_t))); 11248 return; 11249 } 11250 /* reads agsaDifDetails_t */ 11251 saFrameReadBlock(agRoot, agParam, 0, &agDifDetails, sizeof(agsaDifDetails_t)); 11252 frameOffset = (agDifDetails.ErrBoffsetEDataLen & 0xFFFF); 11253 frameLen = (agDifDetails.ErrBoffsetEDataLen & 0xFFFF0000) >> 16; 11254 11255 TI_DBG2(("ossaSSPEvent: UpperLBA 0x%08x LowerLBA 0x%08x\n", agDifDetails.UpperLBA, agDifDetails.LowerLBA)); 11256 TI_DBG2(("ossaSSPEvent: SASAddrHI 0x%08x SASAddrLO 0x%08x\n", 11257 TD_GET_SAS_ADDRESSHI(agDifDetails.sasAddressHi), TD_GET_SAS_ADDRESSLO(agDifDetails.sasAddressLo))); 11258 TI_DBG2(("ossaSSPEvent: DIF error mask 0x%x Device ID 0x%x\n", 11259 (agDifDetails.DIFErrDevID) & 0xFF, (agDifDetails.DIFErrDevID & 0xFFFF0000) >> 16)); 11260 if (frameLen != 0 && frameLen <= 256) 11261 { 11262 saFrameReadBlock(agRoot, agParam, sizeof(agsaDifDetails_t), framePayload, frameLen); 11263 tdhexdump("ossaSSPEvent frame", framePayload, frameLen); 11264 } 11265 } 11266 else 11267 { 11268 TI_DBG1(("ossaSATAEvent: ERROR event %d agDevHandle=%p.\n", event, agDevHandle )); 11269 11270 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 11271 satIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 11272 pSatDevData = satIOContext->pSatDevData; 11273 tdsaDeviceData = (tdsaDeviceData_t *)pSatDevData->satSaDeviceData; 11274 onePortContext = tdsaDeviceData->tdPortContext; 11275 TI_DBG1(("ossaSATAEvent: did %d\n", tdsaDeviceData->id)); 11276 11277 /* send SMP_PHY_CONTROL_HARD_RESET */ 11278 if (event == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY && tdsaAllShared->FCA) 11279 { 11280 if (pSatDevData->NumOfFCA <= 0) /* does SMP HARD RESET only upto one time */ 11281 { 11282 TI_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; sending HARD_RESET\n")); 11283 pSatDevData->NumOfFCA++; 11284 tdsaPhyControlSend(tiRoot, 11285 tdsaDeviceData, 11286 SMP_PHY_CONTROL_HARD_RESET, 11287 agNULL); 11288 } 11289 else 11290 { 11291 /* given up after one time of SMP HARD RESET; */ 11292 TI_DBG1(("ossaSATAEvent: OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY; NO!!! sending HARD_RESET\n")); 11293 if (tdsaDeviceData->registered == agTRUE && tdsaAllShared->ResetInDiscovery == 0) 11294 { 11295 /* 11296 1. remove this device 11297 2. device removal event 11298 */ 11299 tdsaAbortAll(tiRoot, agRoot, tdsaDeviceData); 11300 tdsaDeviceData->valid = agFALSE; 11301 tdsaDeviceData->valid2 = agFALSE; 11302 tdsaDeviceData->registered = agFALSE; 11303 ostiInitiatorEvent( 11304 tiRoot, 11305 onePortContext->tiPortalContext, 11306 agNULL, 11307 tiIntrEventTypeDeviceChange, 11308 tiDeviceRemoval, 11309 agNULL 11310 ); 11311 } 11312 } 11313 } 11314 11315 } 11316 } 11317 #endif /* FDS_SM */ 11318 11319 /***************************************************************************** 11320 *! \brief itdsatErrorSATAEventHandle 11321 * 11322 * This routine is called to handle SATA error event 11323 * 11324 * \param agRoot: Handles for this instance of SAS/SATA hardware 11325 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 11326 * \param agPortContext Pointer to the port context of TD and Lower layer 11327 * \param agDevHandle: Pointer to a device handle 11328 * \param event: event type 11329 * \param ioContext: Pointer to satIOContext_t 11330 * 11331 * \return: none 11332 * 11333 *****************************************************************************/ 11334 osGLOBAL void itdsatErrorSATAEventHandle( 11335 agsaRoot_t *agRoot, 11336 agsaIORequest_t *agIORequest, 11337 agsaPortContext_t *agPortContext, 11338 agsaDevHandle_t *agDevHandle, 11339 bit32 event, 11340 satIOContext_t *ioContext 11341 ) 11342 { 11343 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 11344 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 11345 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 11346 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 11347 tdIORequestBody_t *tdOrgIORequestBody; 11348 satIOContext_t *satIOContext; 11349 satIOContext_t *satOrgIOContext; 11350 satInternalIo_t *satIntIo; 11351 satDeviceData_t *satDevData; 11352 bit32 interruptContext = osData->IntContext; 11353 11354 TI_DBG1(("itdsatErrorSATAEventHandle: start\n")); 11355 satIOContext = (satIOContext_t *) ioContext; 11356 satIntIo = satIOContext->satIntIoContext; 11357 satDevData = satIOContext->pSatDevData; 11358 11359 11360 TI_DBG1(("itdsatErrorSATAEventHandle: event 0x%x\n", event)); 11361 11362 if (satIntIo == agNULL) 11363 { 11364 TI_DBG1(("itdsatErrorSATAEventHandle: External, OS generated\n")); 11365 satOrgIOContext = satIOContext; 11366 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 11367 11368 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 11369 11370 satFreeIntIoResource( tiRoot, 11371 satDevData, 11372 satIntIo); 11373 11374 if (event == OSSA_IO_OVERFLOW) 11375 { 11376 TI_DBG1(("itdsatErrorSATAEventHandle: tiIOOverRun\n")); 11377 ostiInitiatorIOCompleted( tiRoot, 11378 tdOrgIORequestBody->tiIORequest, 11379 tiIOOverRun, 11380 0, 11381 agNULL, 11382 interruptContext); 11383 } 11384 else 11385 { 11386 TI_DBG1(("itdsatErrorSATAEventHandle: else\n")); 11387 ostiInitiatorIOCompleted( tiRoot, 11388 tdOrgIORequestBody->tiIORequest, 11389 tiIOFailed, 11390 tiDetailOtherError, 11391 agNULL, 11392 interruptContext); 11393 } 11394 } 11395 else 11396 { 11397 TI_DBG1(("itdsatErrorSATAEventHandle: Internal, TD generated\n")); 11398 satOrgIOContext = satIOContext->satOrgIOContext; 11399 if (satOrgIOContext == agNULL) 11400 { 11401 TI_DBG1(("itdsatErrorSATAEventHandle: satOrgIOContext is NULL, wrong\n")); 11402 return; 11403 } 11404 else 11405 { 11406 TI_DBG6(("itdsatErrorSATAEventHandle: satOrgIOContext is NOT NULL\n")); 11407 } 11408 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 11409 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 11410 11411 satFreeIntIoResource( tiRoot, 11412 satDevData, 11413 satIntIo); 11414 11415 /* clean up TD layer's IORequestBody */ 11416 ostiFreeMemory( 11417 tiRoot, 11418 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11419 sizeof(tdIORequestBody_t) 11420 ); 11421 11422 } 11423 return; 11424 } 11425 11426 osGLOBAL void ossaSATAAbortCB( 11427 agsaRoot_t *agRoot, 11428 agsaIORequest_t *agIORequest, 11429 bit32 flag, 11430 bit32 status) 11431 { 11432 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 11433 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 11434 tdIORequestBody_t *tdAbortIORequestBody = agNULL; 11435 tdsaDeviceData_t *oneDeviceData = agNULL; 11436 tiDeviceHandle_t *tiDeviceHandle = agNULL; 11437 tiIORequest_t *taskTag = agNULL; 11438 11439 TI_DBG1(("ossaSATAAbortCB: start\n")); 11440 11441 tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 11442 if (tdAbortIORequestBody == agNULL) 11443 { 11444 TI_DBG1(("ossaSATAAbortCB: tdAbortIORequestBody is NULL warning!!!!\n")); 11445 return; 11446 } 11447 11448 if (flag == 2) 11449 { 11450 /* abort per port */ 11451 TI_DBG1(("ossaSATAAbortCB: abort per port\n")); 11452 } 11453 else if (flag == 1) 11454 { 11455 TI_DBG1(("ossaSATAAbortCB: abort all\n")); 11456 tiDeviceHandle = (tiDeviceHandle_t *)tdAbortIORequestBody->tiDevHandle; 11457 if (tiDeviceHandle == agNULL) 11458 { 11459 TI_DBG1(("ossaSATAAbortCB: tiDeviceHandle is NULL warning!!!!\n")); 11460 ostiFreeMemory( 11461 tiRoot, 11462 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11463 sizeof(tdIORequestBody_t) 11464 ); 11465 return; 11466 } 11467 11468 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 11469 if (oneDeviceData == agNULL) 11470 { 11471 TI_DBG1(("ossaSATAAbortCB: oneDeviceData is NULL warning!!!!\n")); 11472 ostiFreeMemory( 11473 tiRoot, 11474 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11475 sizeof(tdIORequestBody_t) 11476 ); 11477 return; 11478 } 11479 11480 if (status == OSSA_IO_SUCCESS) 11481 { 11482 TI_DBG1(("ossaSATAAbortCB: OSSA_IO_SUCCESS\n")); 11483 /* clean up TD layer's IORequestBody */ 11484 if (oneDeviceData->OSAbortAll == agTRUE) 11485 { 11486 oneDeviceData->OSAbortAll = agFALSE; 11487 ostiInitiatorEvent( tiRoot, 11488 agNULL, 11489 tiDeviceHandle, 11490 tiIntrEventTypeLocalAbort, 11491 tiAbortOK, 11492 agNULL); 11493 } 11494 else 11495 { 11496 TI_DBG1(("ossaSATAAbortCB: calling saDeregisterDeviceHandle did %d\n", oneDeviceData->id)); 11497 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 11498 } 11499 /* callback to OS layer here ??? */ 11500 TI_DBG1(("ossaSATAAbortCB: did %d\n", oneDeviceData->id)); 11501 ostiFreeMemory( 11502 tiRoot, 11503 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11504 sizeof(tdIORequestBody_t) 11505 ); 11506 11507 } 11508 else if (status == OSSA_IO_NOT_VALID) 11509 { 11510 TI_DBG1(("ossaSATAAbortCB: OSSA_IO_NOT_VALID\n")); 11511 /* 11512 Nothing is reproted to OS layer 11513 */ 11514 if (oneDeviceData->OSAbortAll == agTRUE) 11515 { 11516 oneDeviceData->OSAbortAll = agFALSE; 11517 ostiInitiatorEvent( tiRoot, 11518 agNULL, 11519 tiDeviceHandle, 11520 tiIntrEventTypeLocalAbort, 11521 tiAbortFailed, 11522 agNULL ); 11523 } 11524 else 11525 { 11526 TI_DBG1(("ossaSATAAbortCB: calling saDeregisterDeviceHandle did %d\n", oneDeviceData->id)); 11527 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 11528 } 11529 TI_DBG1(("ossaSATAAbortCB: did %d\n", oneDeviceData->id)); 11530 ostiFreeMemory( 11531 tiRoot, 11532 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11533 sizeof(tdIORequestBody_t) 11534 ); 11535 } 11536 else if (status == OSSA_IO_NO_DEVICE) 11537 { 11538 TI_DBG1(("ossaSATAAbortCB: OSSA_IO_NO_DEVICE\n")); 11539 /* 11540 Nothing is reproted to OS layer 11541 */ 11542 if (oneDeviceData->OSAbortAll == agTRUE) 11543 { 11544 oneDeviceData->OSAbortAll = agFALSE; 11545 ostiInitiatorEvent( tiRoot, 11546 agNULL, 11547 tiDeviceHandle, 11548 tiIntrEventTypeLocalAbort, 11549 tiAbortInProgress, 11550 agNULL ); 11551 } 11552 else 11553 { 11554 TI_DBG1(("ossaSATAAbortCB: calling saDeregisterDeviceHandle did %d\n", oneDeviceData->id)); 11555 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 11556 } 11557 TI_DBG1(("ossaSATAAbortCB: did %d\n", oneDeviceData->id)); 11558 ostiFreeMemory( 11559 tiRoot, 11560 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11561 sizeof(tdIORequestBody_t) 11562 ); 11563 } 11564 else if (status == OSSA_IO_ABORT_IN_PROGRESS) 11565 { 11566 TI_DBG1(("ossaSATAAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n")); 11567 /* 11568 Nothing is reproted to OS layer 11569 */ 11570 if (oneDeviceData->OSAbortAll == agTRUE) 11571 { 11572 oneDeviceData->OSAbortAll = agFALSE; 11573 ostiInitiatorEvent( tiRoot, 11574 agNULL, 11575 tiDeviceHandle, 11576 tiIntrEventTypeLocalAbort, 11577 tiAbortInProgress, 11578 agNULL ); 11579 } 11580 else 11581 { 11582 TI_DBG1(("ossaSATAAbortCB: calling saDeregisterDeviceHandle did %d\n", oneDeviceData->id)); 11583 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 11584 } 11585 TI_DBG1(("ossaSATAAbortCB: did %d\n", oneDeviceData->id)); 11586 ostiFreeMemory( 11587 tiRoot, 11588 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11589 sizeof(tdIORequestBody_t) 11590 ); 11591 } 11592 else 11593 { 11594 TI_DBG1(("ossaSATAAbortCB: unspecified status 0x%x\n", status )); 11595 /* 11596 Nothing is reproted to OS layer 11597 */ 11598 if (oneDeviceData->OSAbortAll == agTRUE) 11599 { 11600 oneDeviceData->OSAbortAll = agFALSE; 11601 ostiInitiatorEvent( tiRoot, 11602 agNULL, 11603 tiDeviceHandle, 11604 tiIntrEventTypeLocalAbort, 11605 tiAbortInProgress, 11606 agNULL ); 11607 } 11608 else 11609 { 11610 TI_DBG1(("ossaSATAAbortCB: calling saDeregisterDeviceHandle did %d\n", oneDeviceData->id)); 11611 saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData)); 11612 } 11613 TI_DBG1(("ossaSATAAbortCB: did %d\n", oneDeviceData->id)); 11614 ostiFreeMemory( 11615 tiRoot, 11616 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11617 sizeof(tdIORequestBody_t) 11618 ); 11619 } 11620 } 11621 else if (flag == 0) 11622 { 11623 TI_DBG1(("ossaSATAAbortCB: abort one\n")); 11624 taskTag = tdAbortIORequestBody->tiIOToBeAbortedRequest; 11625 11626 if (status == OSSA_IO_SUCCESS) 11627 { 11628 TI_DBG1(("ossaSATAAbortCB: OSSA_IO_SUCCESS\n")); 11629 11630 ostiInitiatorEvent( tiRoot, 11631 agNULL, 11632 agNULL, 11633 tiIntrEventTypeLocalAbort, 11634 tiAbortOK, 11635 taskTag ); 11636 ostiFreeMemory( 11637 tiRoot, 11638 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11639 sizeof(tdIORequestBody_t) 11640 ); 11641 11642 } 11643 else if (status == OSSA_IO_NOT_VALID) 11644 { 11645 TI_DBG1(("ossaSATAAbortCB: OSSA_IO_NOT_VALID\n")); 11646 11647 ostiInitiatorEvent( tiRoot, 11648 agNULL, 11649 agNULL, 11650 tiIntrEventTypeLocalAbort, 11651 tiAbortFailed, 11652 taskTag ); 11653 11654 ostiFreeMemory( 11655 tiRoot, 11656 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11657 sizeof(tdIORequestBody_t) 11658 ); 11659 } 11660 else if (status == OSSA_IO_NO_DEVICE) 11661 { 11662 TI_DBG1(("ossaSATAAbortCB: OSSA_IO_NO_DEVICE\n")); 11663 11664 ostiInitiatorEvent( tiRoot, 11665 agNULL, 11666 agNULL, 11667 tiIntrEventTypeLocalAbort, 11668 tiAbortInProgress, 11669 taskTag ); 11670 11671 ostiFreeMemory( 11672 tiRoot, 11673 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11674 sizeof(tdIORequestBody_t) 11675 ); 11676 } 11677 else if (status == OSSA_IO_ABORT_IN_PROGRESS) 11678 { 11679 TI_DBG1(("ossaSATAAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n")); 11680 11681 ostiInitiatorEvent( tiRoot, 11682 agNULL, 11683 agNULL, 11684 tiIntrEventTypeLocalAbort, 11685 tiAbortInProgress, 11686 taskTag ); 11687 11688 ostiFreeMemory( 11689 tiRoot, 11690 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11691 sizeof(tdIORequestBody_t) 11692 ); 11693 } 11694 else 11695 { 11696 TI_DBG1(("ossaSATAAbortCB: unspecified status 0x%x\n", status )); 11697 11698 ostiInitiatorEvent( tiRoot, 11699 agNULL, 11700 agNULL, 11701 tiIntrEventTypeLocalAbort, 11702 tiAbortFailed, 11703 taskTag ); 11704 11705 ostiFreeMemory( 11706 tiRoot, 11707 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle, 11708 sizeof(tdIORequestBody_t) 11709 ); 11710 } 11711 } 11712 else 11713 { 11714 TI_DBG1(("ossaSATAAbortCB: wrong flag %d\n", flag)); 11715 } 11716 return; 11717 } 11718 11719 /***************************************************************************** 11720 *! \brief ossaSATADeviceResetCB 11721 * 11722 * This routine is called to complete a SATA device reset request previously 11723 * issued to the LL Layer in saSATADeviceReset(). 11724 * 11725 * \param agRoot: Handles for this instance of SAS/SATA hardware 11726 * \param agDevHandle: Pointer to a device handle 11727 * \param resetStatus: Reset status: 11728 * OSSA_SUCCESS: The reset operation completed successfully. 11729 * OSSA_FAILURE: The reset operation failed. 11730 * \param resetparm: Pointer to the Device-To-Host FIS received from the device. 11731 * 11732 * \return: none 11733 * 11734 *****************************************************************************/ 11735 osGLOBAL void 11736 ossaSATADeviceResetCB( 11737 agsaRoot_t *agRoot, 11738 agsaDevHandle_t *agDevHandle, 11739 bit32 resetStatus, 11740 void *resetparm) 11741 { 11742 bit32 tiResetStatus; 11743 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 11744 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 11745 tdsaDeviceData_t *pDeviceData; 11746 tiDeviceHandle_t *tiDeviceHandle; 11747 11748 TI_DBG1(("ossaSATADeviceResetCB: agDevHandle=%p resetStatus=0x%x\n", 11749 agDevHandle, resetStatus )); 11750 11751 pDeviceData = (tdsaDeviceData_t *) agDevHandle->osData; 11752 tiDeviceHandle = &(pDeviceData->tiDeviceHandle); 11753 11754 if (resetStatus == OSSA_SUCCESS ) 11755 tiResetStatus = tiSuccess; 11756 else 11757 tiResetStatus = tiError; 11758 11759 osSatResetCB( tiRoot, 11760 tiDeviceHandle, 11761 tiResetStatus, 11762 resetparm); 11763 11764 } 11765 11766 11767 /*****************************************************************************/ 11768 /*! \brief satDecrementPendingIO 11769 * 11770 * This function decrements the number of pending IO's 11771 * 11772 * \param tiRoot: Pointer to TISA initiator driver/port instance. 11773 * \param tdsaAllShared: Pointer to TD context. 11774 * \param satIOContext_t: Pointer to the SAT IO Context 11775 * 11776 * \return 11777 * None 11778 */ 11779 /*****************************************************************************/ 11780 GLOBAL void 11781 satDecrementPendingIO( 11782 tiRoot_t *tiRoot, 11783 tdsaContext_t *tdsaAllShared, 11784 satIOContext_t *satIOContext 11785 ) 11786 { 11787 satDeviceData_t *satDevData; 11788 11789 TI_DBG4(("satDecrementPendingIO: start\n")); 11790 11791 satDevData = satIOContext->pSatDevData; 11792 11793 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 11794 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 11795 { 11796 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 11797 satDevData->satPendingNCQIO--; 11798 satIOContext->pSatDevData->satPendingIO--; 11799 TDLIST_DEQUEUE_THIS (&satIOContext->satIoContextLink); 11800 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 11801 } 11802 else 11803 { 11804 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 11805 satDevData->satPendingNONNCQIO--; 11806 satIOContext->pSatDevData->satPendingIO--; 11807 TDLIST_DEQUEUE_THIS (&satIOContext->satIoContextLink); 11808 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 11809 } 11810 11811 return; 11812 } 11813 11814 GLOBAL void 11815 satTranslateATAPIErrorsToSCSIErrors( 11816 bit8 bCommand, 11817 bit8 bATAStatus, 11818 bit8 bATAError, 11819 bit8 *pSenseKey, 11820 bit16 *pSenseCodeInfo 11821 ) 11822 { 11823 if (pSenseKey == agNULL || pSenseCodeInfo == agNULL) 11824 { 11825 TI_DBG0(("TranslateATAErrorsToSCSIErros: pSenseKey == agNULL || pSenseCodeInfo == agNULL\n")); 11826 return; 11827 } 11828 11829 if((bATAStatus & ERR_ATA_STATUS_MASK) && (bATAError & NM_ATA_ERROR_MASK)) 11830 { 11831 *pSenseKey = SCSI_SNSKEY_NOT_READY; 11832 *pSenseCodeInfo = 0x3a00; 11833 } 11834 else if((bATAStatus & ERR_ATA_STATUS_MASK) && (bATAError & ABRT_ATA_ERROR_MASK)) 11835 { 11836 *pSenseKey = SCSI_SNSKEY_ABORTED_COMMAND; 11837 *pSenseCodeInfo = 0; 11838 } 11839 else if((bATAStatus & ERR_ATA_STATUS_MASK) && (bATAError & MCR_ATA_ERROR_MASK)) 11840 { 11841 *pSenseKey = SCSI_SNSKEY_UNIT_ATTENTION; 11842 *pSenseCodeInfo = 0x5a01; 11843 } 11844 else if((bATAStatus & ERR_ATA_STATUS_MASK) && (bATAError & IDNF_ATA_ERROR_MASK)) 11845 { 11846 *pSenseKey = SCSI_SNSKEY_MEDIUM_ERROR; 11847 *pSenseCodeInfo = 0x1401; 11848 } 11849 else if((bATAStatus & ERR_ATA_STATUS_MASK) && (bATAError & MC_ATA_ERROR_MASK)) 11850 { 11851 *pSenseKey = SCSI_SNSKEY_UNIT_ATTENTION; 11852 *pSenseCodeInfo = 0x2800; 11853 } 11854 else if((bATAStatus & ERR_ATA_STATUS_MASK) && (bATAError & UNC_ATA_ERROR_MASK)) 11855 { 11856 /*READ*/ 11857 *pSenseKey = SCSI_SNSKEY_MEDIUM_ERROR; 11858 *pSenseCodeInfo = 0x1100; 11859 11860 /*add WRITE here */ 11861 } 11862 else if((bATAStatus & ERR_ATA_STATUS_MASK) && (bATAError & ICRC_ATA_ERROR_MASK)) 11863 { 11864 *pSenseKey = SCSI_SNSKEY_ABORTED_COMMAND; 11865 *pSenseCodeInfo = 0x4703; 11866 } 11867 else if((bATAStatus & DF_ATA_STATUS_MASK)) 11868 { 11869 *pSenseKey = SCSI_SNSKEY_HARDWARE_ERROR; 11870 *pSenseCodeInfo = 0x4400; 11871 } 11872 else 11873 { 11874 TI_DBG0(("unhandled ata error: bATAStatus = 0x%x, bATAError = 0x%x\n", 11875 bATAStatus, bATAError)); 11876 } 11877 11878 } 11879 11880 #endif /* #ifdef SATA_ENABLE */ 11881 11882