fxr.watson.org: sys/dev/pms/RefTisa/tisa/sassata/sata/host/sat.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/pms/RefTisa/tisa/sassata/sata/host/sat.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

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). 26 * The routines in this file are independent from HW LL API. 27 * 28 */ 29 /*****************************************************************************/ 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 #include <dev/pms/config.h> 33 34 #include <dev/pms/freebsd/driver/common/osenv.h> 35 #include <dev/pms/freebsd/driver/common/ostypes.h> 36 #include <dev/pms/freebsd/driver/common/osdebug.h> 37 38 #ifdef SATA_ENABLE 39 40 #include <dev/pms/RefTisa/sallsdk/api/sa.h> 41 #include <dev/pms/RefTisa/sallsdk/api/saapi.h> 42 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h> 43 44 #include <dev/pms/RefTisa/tisa/api/titypes.h> 45 #include <dev/pms/RefTisa/tisa/api/ostiapi.h> 46 #include <dev/pms/RefTisa/tisa/api/tiapi.h> 47 #include <dev/pms/RefTisa/tisa/api/tiglobal.h> 48 49 #ifdef FDS_SM 50 #include <dev/pms/RefTisa/sat/api/sm.h> 51 #include <dev/pms/RefTisa/sat/api/smapi.h> 52 #include <dev/pms/RefTisa/sat/api/tdsmapi.h> 53 #endif 54 55 #ifdef FDS_DM 56 #include <dev/pms/RefTisa/discovery/api/dm.h> 57 #include <dev/pms/RefTisa/discovery/api/dmapi.h> 58 #include <dev/pms/RefTisa/discovery/api/tddmapi.h> 59 #endif 60 61 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h> 62 #include <dev/pms/freebsd/driver/common/osstring.h> 63 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h> 64 65 #ifdef INITIATOR_DRIVER 66 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h> 67 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h> 68 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h> 69 #endif 70 71 #ifdef TARGET_DRIVER 72 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h> 73 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h> 74 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h> 75 #endif 76 77 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h> 78 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h> 79 80 #include <dev/pms/RefTisa/tisa/sassata/sata/host/sat.h> 81 #include <dev/pms/RefTisa/tisa/sassata/sata/host/satproto.h> 82 83 /***************************************************************************** 84 *! \brief satIOStart 85 * 86 * This routine is called to initiate a new SCSI request to SATL. 87 * 88 * \param tiRoot: Pointer to TISA initiator driver/port instance. 89 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 90 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 91 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 92 * \param satIOContext_t: Pointer to the SAT IO Context 93 * 94 * \return: 95 * 96 * \e tiSuccess: I/O request successfully initiated. 97 * \e tiBusy: No resources available, try again later. 98 * \e tiIONoDevice: Invalid device handle. 99 * \e tiError: Other errors that prevent the I/O request to be started. 100 * 101 * 102 *****************************************************************************/ 103 GLOBAL bit32 satIOStart( 104 tiRoot_t *tiRoot, 105 tiIORequest_t *tiIORequest, 106 tiDeviceHandle_t *tiDeviceHandle, 107 tiScsiInitiatorRequest_t *tiScsiRequest, 108 satIOContext_t *satIOContext 109 ) 110 { 111 112 bit32 retVal = tiSuccess; 113 satDeviceData_t *pSatDevData; 114 scsiRspSense_t *pSense; 115 tiIniScsiCmnd_t *scsiCmnd; 116 tiLUN_t *pLun; 117 satInternalIo_t *pSatIntIo; 118 #ifdef TD_DEBUG_ENABLE 119 tdsaDeviceData_t *oneDeviceData; 120 #endif 121 122 pSense = satIOContext->pSense; 123 pSatDevData = satIOContext->pSatDevData; 124 scsiCmnd = &tiScsiRequest->scsiCmnd; 125 pLun = &scsiCmnd->lun; 126 127 /* 128 * Reject all other LUN other than LUN 0. 129 */ 130 if ( ((pLun->lun[0] | pLun->lun[1] | pLun->lun[2] | pLun->lun[3] | 131 pLun->lun[4] | pLun->lun[5] | pLun->lun[6] | pLun->lun[7] ) != 0) && 132 (scsiCmnd->cdb[0] != SCSIOPC_INQUIRY) 133 ) 134 { 135 TI_DBG1(("satIOStart: *** REJECT *** LUN not zero, cdb[0]=0x%x tiIORequest=%p tiDeviceHandle=%p\n", 136 scsiCmnd->cdb[0], tiIORequest, tiDeviceHandle)); 137 satSetSensePayload( pSense, 138 SCSI_SNSKEY_ILLEGAL_REQUEST, 139 0, 140 SCSI_SNSCODE_LOGICAL_NOT_SUPPORTED, 141 satIOContext); 142 143 ostiInitiatorIOCompleted( tiRoot, 144 tiIORequest, 145 tiIOSuccess, 146 SCSI_STAT_CHECK_CONDITION, 147 satIOContext->pTiSenseData, 148 satIOContext->interruptContext ); 149 retVal = tiSuccess; 150 goto ext; 151 } 152 153 TI_DBG6(("satIOStart: satPendingIO %d satNCQMaxIO %d\n",pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 154 155 /* this may happen after tiCOMReset until OS sends inquiry */ 156 if (pSatDevData->IDDeviceValid == agFALSE && (scsiCmnd->cdb[0] != SCSIOPC_INQUIRY)) 157 { 158 #ifdef TD_DEBUG_ENABLE 159 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 160 #endif 161 TI_DBG1(("satIOStart: invalid identify device data did %d\n", oneDeviceData->id)); 162 retVal = tiIONoDevice; 163 goto ext; 164 } 165 /* 166 * Check if we need to return BUSY, i.e. recovery in progress 167 */ 168 if (pSatDevData->satDriveState == SAT_DEV_STATE_IN_RECOVERY) 169 { 170 #ifdef TD_DEBUG_ENABLE 171 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 172 #endif 173 TI_DBG1(("satIOStart: IN RECOVERY STATE cdb[0]=0x%x tiIORequest=%p tiDeviceHandle=%p\n", 174 scsiCmnd->cdb[0], tiIORequest, tiDeviceHandle)); 175 TI_DBG1(("satIOStart: IN RECOVERY STATE did %d\n", oneDeviceData->id)); 176 177 TI_DBG1(("satIOStart: device %p satPendingIO %d satNCQMaxIO %d\n",pSatDevData, pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 178 TI_DBG1(("satIOStart: device %p satPendingNCQIO %d satPendingNONNCQIO %d\n",pSatDevData, pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 179 retVal = tiError; 180 goto ext; 181 // return tiBusy; 182 } 183 184 if (pSatDevData->satDeviceType == SATA_ATAPI_DEVICE) 185 { 186 if (scsiCmnd->cdb[0] == SCSIOPC_REPORT_LUN) 187 { 188 return satReportLun(tiRoot, tiIORequest, tiDeviceHandle, tiScsiRequest, satIOContext); 189 } 190 else 191 { 192 return satPacket(tiRoot, tiIORequest, tiDeviceHandle, tiScsiRequest, satIOContext); 193 } 194 } 195 else /* pSatDevData->satDeviceType != SATA_ATAPI_DEVICE */ 196 { 197 /* Parse CDB */ 198 switch(scsiCmnd->cdb[0]) 199 { 200 case SCSIOPC_READ_6: 201 retVal = satRead6( tiRoot, 202 tiIORequest, 203 tiDeviceHandle, 204 tiScsiRequest, 205 satIOContext); 206 break; 207 208 case SCSIOPC_READ_10: 209 retVal = satRead10( tiRoot, 210 tiIORequest, 211 tiDeviceHandle, 212 tiScsiRequest, 213 satIOContext); 214 break; 215 216 case SCSIOPC_READ_12: 217 TI_DBG5(("satIOStart: SCSIOPC_READ_12\n")); 218 retVal = satRead12( tiRoot, 219 tiIORequest, 220 tiDeviceHandle, 221 tiScsiRequest, 222 satIOContext); 223 break; 224 225 case SCSIOPC_READ_16: 226 retVal = satRead16( tiRoot, 227 tiIORequest, 228 tiDeviceHandle, 229 tiScsiRequest, 230 satIOContext); 231 break; 232 233 case SCSIOPC_WRITE_6: 234 retVal = satWrite6( tiRoot, 235 tiIORequest, 236 tiDeviceHandle, 237 tiScsiRequest, 238 satIOContext); 239 break; 240 241 case SCSIOPC_WRITE_10: 242 retVal = satWrite10( tiRoot, 243 tiIORequest, 244 tiDeviceHandle, 245 tiScsiRequest, 246 satIOContext); 247 break; 248 249 case SCSIOPC_WRITE_12: 250 TI_DBG5(("satIOStart: SCSIOPC_WRITE_12 \n")); 251 retVal = satWrite12( tiRoot, 252 tiIORequest, 253 tiDeviceHandle, 254 tiScsiRequest, 255 satIOContext); 256 257 break; 258 259 case SCSIOPC_WRITE_16: 260 TI_DBG5(("satIOStart: SCSIOPC_WRITE_16\n")); 261 retVal = satWrite16( tiRoot, 262 tiIORequest, 263 tiDeviceHandle, 264 tiScsiRequest, 265 satIOContext); 266 267 break; 268 269 case SCSIOPC_VERIFY_10: 270 retVal = satVerify10( tiRoot, 271 tiIORequest, 272 tiDeviceHandle, 273 tiScsiRequest, 274 satIOContext); 275 break; 276 277 case SCSIOPC_VERIFY_12: 278 TI_DBG5(("satIOStart: SCSIOPC_VERIFY_12\n")); 279 retVal = satVerify12( tiRoot, 280 tiIORequest, 281 tiDeviceHandle, 282 tiScsiRequest, 283 satIOContext); 284 break; 285 286 case SCSIOPC_VERIFY_16: 287 TI_DBG5(("satIOStart: SCSIOPC_VERIFY_16\n")); 288 retVal = satVerify16( tiRoot, 289 tiIORequest, 290 tiDeviceHandle, 291 tiScsiRequest, 292 satIOContext); 293 break; 294 295 case SCSIOPC_TEST_UNIT_READY: 296 retVal = satTestUnitReady( tiRoot, 297 tiIORequest, 298 tiDeviceHandle, 299 tiScsiRequest, 300 satIOContext); 301 break; 302 303 case SCSIOPC_INQUIRY: 304 retVal = satInquiry( tiRoot, 305 tiIORequest, 306 tiDeviceHandle, 307 tiScsiRequest, 308 satIOContext); 309 break; 310 311 case SCSIOPC_REQUEST_SENSE: 312 retVal = satRequestSense( tiRoot, 313 tiIORequest, 314 tiDeviceHandle, 315 tiScsiRequest, 316 satIOContext); 317 break; 318 319 case SCSIOPC_MODE_SENSE_6: 320 retVal = satModeSense6( tiRoot, 321 tiIORequest, 322 tiDeviceHandle, 323 tiScsiRequest, 324 satIOContext); 325 break; 326 327 case SCSIOPC_MODE_SENSE_10: 328 retVal = satModeSense10( tiRoot, 329 tiIORequest, 330 tiDeviceHandle, 331 tiScsiRequest, 332 satIOContext); 333 break; 334 335 336 case SCSIOPC_READ_CAPACITY_10: 337 retVal = satReadCapacity10( tiRoot, 338 tiIORequest, 339 tiDeviceHandle, 340 tiScsiRequest, 341 satIOContext); 342 break; 343 344 case SCSIOPC_READ_CAPACITY_16: 345 retVal = satReadCapacity16( tiRoot, 346 tiIORequest, 347 tiDeviceHandle, 348 tiScsiRequest, 349 satIOContext); 350 break; 351 352 case SCSIOPC_REPORT_LUN: 353 retVal = satReportLun( tiRoot, 354 tiIORequest, 355 tiDeviceHandle, 356 tiScsiRequest, 357 satIOContext); 358 break; 359 360 case SCSIOPC_FORMAT_UNIT: 361 TI_DBG5(("satIOStart: SCSIOPC_FORMAT_UNIT\n")); 362 retVal = satFormatUnit( tiRoot, 363 tiIORequest, 364 tiDeviceHandle, 365 tiScsiRequest, 366 satIOContext); 367 break; 368 case SCSIOPC_SEND_DIAGNOSTIC: /* Table 28, p40 */ 369 TI_DBG5(("satIOStart: SCSIOPC_SEND_DIAGNOSTIC\n")); 370 retVal = satSendDiagnostic( tiRoot, 371 tiIORequest, 372 tiDeviceHandle, 373 tiScsiRequest, 374 satIOContext); 375 break; 376 377 case SCSIOPC_START_STOP_UNIT: 378 TI_DBG5(("satIOStart: SCSIOPC_START_STOP_UNIT\n")); 379 retVal = satStartStopUnit( tiRoot, 380 tiIORequest, 381 tiDeviceHandle, 382 tiScsiRequest, 383 satIOContext); 384 break; 385 386 case SCSIOPC_WRITE_SAME_10: /* sector and LBA; SAT p64 case 3 accessing payload and very 387 inefficient now */ 388 TI_DBG5(("satIOStart: SCSIOPC_WRITE_SAME_10\n")); 389 retVal = satWriteSame10( tiRoot, 390 tiIORequest, 391 tiDeviceHandle, 392 tiScsiRequest, 393 satIOContext); 394 break; 395 396 case SCSIOPC_WRITE_SAME_16: /* no support due to transfer length(sector count) */ 397 TI_DBG5(("satIOStart: SCSIOPC_WRITE_SAME_16\n")); 398 retVal = satWriteSame16( tiRoot, 399 tiIORequest, 400 tiDeviceHandle, 401 tiScsiRequest, 402 satIOContext); 403 break; 404 405 case SCSIOPC_LOG_SENSE: /* SCT and log parameter(informational exceptions) */ 406 TI_DBG5(("satIOStart: SCSIOPC_LOG_SENSE\n")); 407 retVal = satLogSense( tiRoot, 408 tiIORequest, 409 tiDeviceHandle, 410 tiScsiRequest, 411 satIOContext); 412 break; 413 414 case SCSIOPC_MODE_SELECT_6: /*mode layout and AlloLen check */ 415 TI_DBG5(("satIOStart: SCSIOPC_MODE_SELECT_6\n")); 416 retVal = satModeSelect6( tiRoot, 417 tiIORequest, 418 tiDeviceHandle, 419 tiScsiRequest, 420 satIOContext); 421 break; 422 423 case SCSIOPC_MODE_SELECT_10: /* mode layout and AlloLen check and sharing CB with satModeSelect6*/ 424 TI_DBG5(("satIOStart: SCSIOPC_MODE_SELECT_10\n")); 425 retVal = satModeSelect10( tiRoot, 426 tiIORequest, 427 tiDeviceHandle, 428 tiScsiRequest, 429 satIOContext); 430 break; 431 432 case SCSIOPC_SYNCHRONIZE_CACHE_10: /* on error what to return, sharing CB with 433 satSynchronizeCache16 */ 434 TI_DBG5(("satIOStart: SCSIOPC_SYNCHRONIZE_CACHE_10\n")); 435 retVal = satSynchronizeCache10( tiRoot, 436 tiIORequest, 437 tiDeviceHandle, 438 tiScsiRequest, 439 satIOContext); 440 break; 441 442 case SCSIOPC_SYNCHRONIZE_CACHE_16:/* on error what to return, sharing CB with 443 satSynchronizeCache16 */ 444 445 TI_DBG5(("satIOStart: SCSIOPC_SYNCHRONIZE_CACHE_16\n")); 446 retVal = satSynchronizeCache16( tiRoot, 447 tiIORequest, 448 tiDeviceHandle, 449 tiScsiRequest, 450 satIOContext); 451 break; 452 453 case SCSIOPC_WRITE_AND_VERIFY_10: /* single write and multiple writes */ 454 TI_DBG5(("satIOStart: SCSIOPC_WRITE_AND_VERIFY_10\n")); 455 retVal = satWriteAndVerify10( tiRoot, 456 tiIORequest, 457 tiDeviceHandle, 458 tiScsiRequest, 459 satIOContext); 460 break; 461 462 case SCSIOPC_WRITE_AND_VERIFY_12: 463 TI_DBG5(("satIOStart: SCSIOPC_WRITE_AND_VERIFY_12\n")); 464 retVal = satWriteAndVerify12( tiRoot, 465 tiIORequest, 466 tiDeviceHandle, 467 tiScsiRequest, 468 satIOContext); 469 break; 470 471 case SCSIOPC_WRITE_AND_VERIFY_16: 472 TI_DBG5(("satIOStart: SCSIOPC_WRITE_AND_VERIFY_16\n")); 473 retVal = satWriteAndVerify16( tiRoot, 474 tiIORequest, 475 tiDeviceHandle, 476 tiScsiRequest, 477 satIOContext); 478 479 break; 480 481 case SCSIOPC_READ_MEDIA_SERIAL_NUMBER: 482 TI_DBG5(("satIOStart: SCSIOPC_READ_MEDIA_SERIAL_NUMBER\n")); 483 retVal = satReadMediaSerialNumber( tiRoot, 484 tiIORequest, 485 tiDeviceHandle, 486 tiScsiRequest, 487 satIOContext); 488 489 break; 490 491 case SCSIOPC_READ_BUFFER: 492 TI_DBG5(("satIOStart: SCSIOPC_READ_BUFFER\n")); 493 retVal = satReadBuffer( tiRoot, 494 tiIORequest, 495 tiDeviceHandle, 496 tiScsiRequest, 497 satIOContext); 498 499 break; 500 501 case SCSIOPC_WRITE_BUFFER: 502 TI_DBG5(("satIOStart: SCSIOPC_WRITE_BUFFER\n")); 503 retVal = satWriteBuffer( tiRoot, 504 tiIORequest, 505 tiDeviceHandle, 506 tiScsiRequest, 507 satIOContext); 508 509 break; 510 511 case SCSIOPC_REASSIGN_BLOCKS: 512 TI_DBG5(("satIOStart: SCSIOPC_REASSIGN_BLOCKS\n")); 513 retVal = satReassignBlocks( tiRoot, 514 tiIORequest, 515 tiDeviceHandle, 516 tiScsiRequest, 517 satIOContext); 518 519 break; 520 521 default: 522 /* Not implemented SCSI cmd, set up error response */ 523 TI_DBG1(("satIOStart: unsupported SCSI cdb[0]=0x%x tiIORequest=%p tiDeviceHandle=%p\n", 524 scsiCmnd->cdb[0], tiIORequest, tiDeviceHandle)); 525 526 satSetSensePayload( pSense, 527 SCSI_SNSKEY_ILLEGAL_REQUEST, 528 0, 529 SCSI_SNSCODE_INVALID_COMMAND, 530 satIOContext); 531 532 ostiInitiatorIOCompleted( tiRoot, 533 tiIORequest, 534 tiIOSuccess, 535 SCSI_STAT_CHECK_CONDITION, 536 satIOContext->pTiSenseData, 537 satIOContext->interruptContext ); 538 retVal = tiSuccess; 539 540 break; 541 542 } /* end switch */ 543 } 544 if (retVal == tiBusy) 545 { 546 #ifdef TD_DEBUG_ENABLE 547 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 548 #endif 549 TI_DBG1(("satIOStart: BUSY did %d\n", oneDeviceData->id)); 550 TI_DBG3(("satIOStart: LL is busy or target queue is full\n")); 551 TI_DBG3(("satIOStart: device %p satPendingIO %d satNCQMaxIO %d\n",pSatDevData, pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO )); 552 TI_DBG3(("satIOStart: device %p satPendingNCQIO %d satPendingNONNCQIO %d\n",pSatDevData, pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO)); 553 pSatIntIo = satIOContext->satIntIoContext; 554 555 /* interal structure free */ 556 satFreeIntIoResource( tiRoot, 557 pSatDevData, 558 pSatIntIo); 559 } 560 561 ext: 562 return retVal; 563 } 564 565 566 /*****************************************************************************/ 567 /*! \brief Setup up the SCSI Sense response. 568 * 569 * This function is used to setup up the Sense Data payload for 570 * CHECK CONDITION status. 571 * 572 * \param pSense: Pointer to the scsiRspSense_t sense data structure. 573 * \param SnsKey: SCSI Sense Key. 574 * \param SnsInfo: SCSI Sense Info. 575 * \param SnsCode: SCSI Sense Code. 576 * 577 * \return: None 578 */ 579 /*****************************************************************************/ 580 void satSetSensePayload( scsiRspSense_t *pSense, 581 bit8 SnsKey, 582 bit32 SnsInfo, 583 bit16 SnsCode, 584 satIOContext_t *satIOContext 585 ) 586 { 587 /* for fixed format sense data, SPC-4, p37 */ 588 bit32 i; 589 bit32 senseLength; 590 591 TI_DBG5(("satSetSensePayload: start\n")); 592 593 senseLength = sizeof(scsiRspSense_t); 594 595 /* zero out the data area */ 596 for (i=0;i< senseLength;i++) 597 { 598 ((bit8*)pSense)[i] = 0; 599 } 600 601 /* 602 * SCSI Sense Data part of response data 603 */ 604 pSense->snsRespCode = 0x70; /* 0xC0 == vendor specific */ 605 /* 0x70 == standard current error */ 606 pSense->senseKey = SnsKey; 607 /* 608 * Put sense info in scsi order format 609 */ 610 pSense->info[0] = (bit8)((SnsInfo >> 24) & 0xff); 611 pSense->info[1] = (bit8)((SnsInfo >> 16) & 0xff); 612 pSense->info[2] = (bit8)((SnsInfo >> 8) & 0xff); 613 pSense->info[3] = (bit8)((SnsInfo) & 0xff); 614 pSense->addSenseLen = 11; /* fixed size of sense data = 18 */ 615 pSense->addSenseCode = (bit8)((SnsCode >> 8) & 0xFF); 616 pSense->senseQual = (bit8)(SnsCode & 0xFF); 617 /* 618 * Set pointer in scsi status 619 */ 620 switch(SnsKey) 621 { 622 /* 623 * set illegal request sense key specific error in cdb, no bit pointer 624 */ 625 case SCSI_SNSKEY_ILLEGAL_REQUEST: 626 pSense->skeySpecific[0] = 0xC8; 627 break; 628 629 default: 630 break; 631 } 632 /* setting sense data length */ 633 if (satIOContext != agNULL) 634 { 635 satIOContext->pTiSenseData->senseLen = 18; 636 } 637 else 638 { 639 TI_DBG1(("satSetSensePayload: satIOContext is NULL\n")); 640 } 641 } 642 643 /*****************************************************************************/ 644 /*! \brief Setup up the SCSI Sense response. 645 * 646 * This function is used to setup up the Sense Data payload for 647 * CHECK CONDITION status. 648 * 649 * \param pSense: Pointer to the scsiRspSense_t sense data structure. 650 * \param SnsKey: SCSI Sense Key. 651 * \param SnsInfo: SCSI Sense Info. 652 * \param SnsCode: SCSI Sense Code. 653 * 654 * \return: None 655 */ 656 /*****************************************************************************/ 657 658 void satSetDeferredSensePayload( scsiRspSense_t *pSense, 659 bit8 SnsKey, 660 bit32 SnsInfo, 661 bit16 SnsCode, 662 satIOContext_t *satIOContext 663 ) 664 { 665 /* for fixed format sense data, SPC-4, p37 */ 666 bit32 i; 667 bit32 senseLength; 668 669 senseLength = sizeof(scsiRspSense_t); 670 671 /* zero out the data area */ 672 for (i=0;i< senseLength;i++) 673 { 674 ((bit8*)pSense)[i] = 0; 675 } 676 677 /* 678 * SCSI Sense Data part of response data 679 */ 680 pSense->snsRespCode = 0x71; /* 0xC0 == vendor specific */ 681 /* 0x70 == standard current error */ 682 pSense->senseKey = SnsKey; 683 /* 684 * Put sense info in scsi order format 685 */ 686 pSense->info[0] = (bit8)((SnsInfo >> 24) & 0xff); 687 pSense->info[1] = (bit8)((SnsInfo >> 16) & 0xff); 688 pSense->info[2] = (bit8)((SnsInfo >> 8) & 0xff); 689 pSense->info[3] = (bit8)((SnsInfo) & 0xff); 690 pSense->addSenseLen = 11; /* fixed size of sense data = 18 */ 691 pSense->addSenseCode = (bit8)((SnsCode >> 8) & 0xFF); 692 pSense->senseQual = (bit8)(SnsCode & 0xFF); 693 /* 694 * Set pointer in scsi status 695 */ 696 switch(SnsKey) 697 { 698 /* 699 * set illegal request sense key specific error in cdb, no bit pointer 700 */ 701 case SCSI_SNSKEY_ILLEGAL_REQUEST: 702 pSense->skeySpecific[0] = 0xC8; 703 break; 704 705 default: 706 break; 707 } 708 709 /* setting sense data length */ 710 if (satIOContext != agNULL) 711 { 712 satIOContext->pTiSenseData->senseLen = 18; 713 } 714 else 715 { 716 TI_DBG1(("satSetDeferredSensePayload: satIOContext is NULL\n")); 717 } 718 719 } 720 /*****************************************************************************/ 721 /*! \brief SAT implementation for ATAPI Packet Command. 722 * 723 * SAT implementation for ATAPI Packet and send FIS request to LL layer. 724 * 725 * \param tiRoot: Pointer to TISA initiator driver/port instance. 726 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 727 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 728 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 729 * \param satIOContext_t: Pointer to the SAT IO Context 730 * 731 * \return If command is started successfully 732 * - \e tiSuccess: I/O request successfully initiated. 733 * - \e tiBusy: No resources available, try again later. 734 * - \e tiIONoDevice: Invalid device handle. 735 * - \e tiError: Other errors. 736 */ 737 /*****************************************************************************/ 738 GLOBAL bit32 satPacket( 739 tiRoot_t *tiRoot, 740 tiIORequest_t *tiIORequest, 741 tiDeviceHandle_t *tiDeviceHandle, 742 tiScsiInitiatorRequest_t *tiScsiRequest, 743 satIOContext_t *satIOContext) 744 { 745 bit32 status; 746 bit32 agRequestType = AGSA_SATA_PROTOCOL_D2H_PKT; 747 satDeviceData_t *pSatDevData; 748 tiIniScsiCmnd_t *scsiCmnd; 749 agsaFisRegHostToDevice_t *fis; 750 751 pSatDevData = satIOContext->pSatDevData; 752 scsiCmnd = &tiScsiRequest->scsiCmnd; 753 fis = satIOContext->pFis; 754 755 TI_DBG3(("satPacket: start, SCSI CDB is 0x%X %X %X %X %X %X %X %X %X %X %X %X\n", 756 scsiCmnd->cdb[0],scsiCmnd->cdb[1],scsiCmnd->cdb[2],scsiCmnd->cdb[3], 757 scsiCmnd->cdb[4],scsiCmnd->cdb[5],scsiCmnd->cdb[6],scsiCmnd->cdb[7], 758 scsiCmnd->cdb[8],scsiCmnd->cdb[9],scsiCmnd->cdb[10],scsiCmnd->cdb[11])); 759 760 fis->h.fisType = 0x27; /* Reg host to device */ 761 fis->h.c_pmPort = 0x80; /* C Bit is set 1*/ 762 fis->h.command = SAT_PACKET; /* 0xA0 */ 763 if (pSatDevData->satDMADIRSupport) /* DMADIR enabled*/ 764 { 765 fis->h.features = (tiScsiRequest->dataDirection == tiDirectionIn)? 0x04 : 0; /* 1 for D2H, 0 for H2D */ 766 } 767 else 768 { 769 fis->h.features = 0; /* FIS reserve */ 770 } 771 /* Byte count low and byte count high */ 772 if ( scsiCmnd->expDataLength > 0xFFFF ) 773 { 774 fis->d.lbaMid = 0xFF; /* FIS LBA (7 :0 ) */ 775 fis->d.lbaHigh = 0xFF; /* FIS LBA (15:8 ) */ 776 } 777 else 778 { 779 fis->d.lbaMid = (bit8)scsiCmnd->expDataLength; /* FIS LBA (7 :0 ) */ 780 fis->d.lbaHigh = (bit8)(scsiCmnd->expDataLength>>8); /* FIS LBA (15:8 ) */ 781 } 782 783 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 784 fis->d.device = 0; /* FIS LBA (27:24) and FIS LBA mode */ 785 fis->d.lbaLowExp = 0; 786 fis->d.lbaMidExp = 0; 787 fis->d.lbaHighExp = 0; 788 fis->d.featuresExp = 0; 789 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 790 fis->d.sectorCountExp = 0; 791 fis->d.reserved4 = 0; 792 fis->d.control = 0; /* FIS HOB bit clear */ 793 fis->d.reserved5 = 0; 794 795 satIOContext->ATACmd = SAT_PACKET; 796 797 if (tiScsiRequest->dataDirection == tiDirectionIn) 798 { 799 agRequestType = AGSA_SATA_PROTOCOL_D2H_PKT; 800 } 801 else 802 { 803 agRequestType = AGSA_SATA_PROTOCOL_H2D_PKT; 804 } 805 806 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 807 { 808 /*DMA transfer mode*/ 809 fis->h.features |= 0x01; 810 } 811 else 812 { 813 /*PIO transfer mode*/ 814 fis->h.features |= 0x0; 815 } 816 817 satIOContext->satCompleteCB = &satPacketCB; 818 819 /* 820 * Prepare SGL and send FIS to LL layer. 821 */ 822 satIOContext->reqType = agRequestType; /* Save it */ 823 824 status = sataLLIOStart( tiRoot, 825 tiIORequest, 826 tiDeviceHandle, 827 tiScsiRequest, 828 satIOContext); 829 830 TI_DBG5(("satPacket: return\n")); 831 return (status); 832 } 833 834 /*****************************************************************************/ 835 /*! \brief SAT implementation for satSetFeatures. 836 * 837 * This function creates SetFeatures fis and sends the request to LL layer 838 * 839 * \param tiRoot: Pointer to TISA initiator driver/port instance. 840 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 841 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 842 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 843 * \param satIOContext_t: Pointer to the SAT IO Context 844 * 845 * \return If command is started successfully 846 * - \e tiSuccess: I/O request successfully initiated. 847 * - \e tiBusy: No resources available, try again later. 848 * - \e tiIONoDevice: Invalid device handle. 849 * - \e tiError: Other errors. 850 */ 851 /*****************************************************************************/ 852 GLOBAL bit32 satSetFeatures( 853 tiRoot_t *tiRoot, 854 tiIORequest_t *tiIORequest, 855 tiDeviceHandle_t *tiDeviceHandle, 856 tiScsiInitiatorRequest_t *tiScsiRequest, 857 satIOContext_t *satIOContext, 858 bit8 bIsDMAMode 859 ) 860 { 861 bit32 status; 862 bit32 agRequestType; 863 agsaFisRegHostToDevice_t *fis; 864 865 fis = satIOContext->pFis; 866 TI_DBG3(("satSetFeatures: start\n")); 867 868 /* 869 * Send the Set Features command. 870 */ 871 fis->h.fisType = 0x27; /* Reg host to device */ 872 fis->h.c_pmPort = 0x80; /* C Bit is set */ 873 fis->h.command = SAT_SET_FEATURES; /* 0xEF */ 874 fis->h.features = 0x03; /* set transfer mode */ 875 fis->d.lbaLow = 0; 876 fis->d.lbaMid = 0; 877 fis->d.lbaHigh = 0; 878 fis->d.device = 0; 879 fis->d.lbaLowExp = 0; 880 fis->d.lbaMidExp = 0; 881 fis->d.lbaHighExp = 0; 882 fis->d.featuresExp = 0; 883 fis->d.sectorCountExp = 0; 884 fis->d.reserved4 = 0; 885 fis->d.control = 0; /* FIS HOB bit clear */ 886 fis->d.reserved5 = 0; 887 888 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 889 890 /* Initialize CB for SATA completion. 891 */ 892 if (bIsDMAMode) 893 { 894 fis->d.sectorCount = 0x45; 895 /*satIOContext->satCompleteCB = &satSetFeaturesDMACB;*/ 896 } 897 else 898 { 899 fis->d.sectorCount = 0x0C; 900 /*satIOContext->satCompleteCB = &satSetFeaturesPIOCB;*/ 901 } 902 satIOContext->satCompleteCB = &satSetFeaturesCB; 903 904 /* 905 * Prepare SGL and send FIS to LL layer. 906 */ 907 satIOContext->reqType = agRequestType; /* Save it */ 908 909 status = sataLLIOStart( tiRoot, 910 tiIORequest, 911 tiDeviceHandle, 912 tiScsiRequest, 913 satIOContext); 914 915 TI_DBG5(("satSetFeatures: return\n")); 916 917 return status; 918 } 919 /*****************************************************************************/ 920 /*! \brief SAT implementation for SCSI REQUEST SENSE to ATAPI device. 921 * 922 * SAT implementation for SCSI REQUEST SENSE. 923 * 924 * \param tiRoot: Pointer to TISA initiator driver/port instance. 925 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 926 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 927 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 928 * \param satIOContext_t: Pointer to the SAT IO Context 929 * 930 * \return If command is started successfully 931 * - \e tiSuccess: I/O request successfully initiated. 932 * - \e tiBusy: No resources available, try again later. 933 * - \e tiIONoDevice: Invalid device handle. 934 * - \e tiError: Other errors. 935 */ 936 /*****************************************************************************/ 937 GLOBAL bit32 satRequestSenseForATAPI( 938 tiRoot_t *tiRoot, 939 tiIORequest_t *tiIORequest, 940 tiDeviceHandle_t *tiDeviceHandle, 941 tiScsiInitiatorRequest_t *tiScsiRequest, 942 satIOContext_t *satIOContext) 943 { 944 bit32 status; 945 bit32 agRequestType = AGSA_SATA_PROTOCOL_D2H_PKT; 946 satDeviceData_t *pSatDevData; 947 tiIniScsiCmnd_t *scsiCmnd; 948 agsaFisRegHostToDevice_t *fis; 949 950 pSatDevData = satIOContext->pSatDevData; 951 scsiCmnd = &tiScsiRequest->scsiCmnd; 952 fis = satIOContext->pFis; 953 954 scsiCmnd->cdb[0] = SCSIOPC_REQUEST_SENSE; 955 scsiCmnd->cdb[1] = 0; 956 scsiCmnd->cdb[2] = 0; 957 scsiCmnd->cdb[3] = 0; 958 scsiCmnd->cdb[4] = SENSE_DATA_LENGTH; 959 scsiCmnd->cdb[5] = 0; 960 TI_DBG3(("satRequestSenseForATAPI: start, SCSI CDB is 0x%X %X %X %X %X %X %X %X %X %X %X %X\n", 961 scsiCmnd->cdb[0],scsiCmnd->cdb[1],scsiCmnd->cdb[2],scsiCmnd->cdb[3], 962 scsiCmnd->cdb[4],scsiCmnd->cdb[5],scsiCmnd->cdb[6],scsiCmnd->cdb[7], 963 scsiCmnd->cdb[8],scsiCmnd->cdb[9],scsiCmnd->cdb[10],scsiCmnd->cdb[11])); 964 965 fis->h.fisType = 0x27; /* Reg host to device */ 966 fis->h.c_pmPort = 0x80; /* C Bit is set 1*/ 967 fis->h.command = SAT_PACKET; /* 0xA0 */ 968 if (pSatDevData->satDMADIRSupport) /* DMADIR enabled*/ 969 { 970 fis->h.features = (tiScsiRequest->dataDirection == tiDirectionIn)? 0x04 : 0; /* 1 for D2H, 0 for H2D */ 971 } 972 else 973 { 974 fis->h.features = 0; /* FIS reserve */ 975 } 976 977 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 978 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 979 fis->d.lbaHigh = 0x20; /* FIS LBA (23:16) */ 980 fis->d.device = 0; /* FIS LBA (27:24) and FIS LBA mode */ 981 fis->d.lbaLowExp = 0; 982 fis->d.lbaMidExp = 0; 983 fis->d.lbaHighExp = 0; 984 fis->d.featuresExp = 0; 985 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 986 fis->d.sectorCountExp = 0; 987 fis->d.reserved4 = 0; 988 fis->d.control = 0; /* FIS HOB bit clear */ 989 fis->d.reserved5 = (bit32)(scsiCmnd->cdb[0]|(scsiCmnd->cdb[1]<<8)|(scsiCmnd->cdb[2]<<16)|(scsiCmnd->cdb[3]<<24)); 990 991 satIOContext->ATACmd = SAT_PACKET; 992 993 agRequestType = AGSA_SATA_PROTOCOL_D2H_PKT; 994 995 //if (pSatDevData->sat48BitSupport == agTRUE) 996 { 997 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 998 { 999 fis->h.features |= 0x01; 1000 } 1001 else 1002 { 1003 fis->h.features |= 0x0; 1004 } 1005 } 1006 1007 satIOContext->satCompleteCB = &satRequestSenseForATAPICB; 1008 1009 /* 1010 * Prepare SGL and send FIS to LL layer. 1011 */ 1012 satIOContext->reqType = agRequestType; /* Save it */ 1013 1014 status = sataLLIOStart( tiRoot, 1015 tiIORequest, 1016 tiDeviceHandle, 1017 tiScsiRequest, 1018 satIOContext); 1019 1020 TI_DBG5(("satRequestSenseForATAPI: return\n")); 1021 return (status); 1022 } 1023 /*****************************************************************************/ 1024 /*! \brief SAT implementation for satDeviceReset. 1025 * 1026 * This function creates DEVICE RESET fis and sends the request to LL layer 1027 * 1028 * \param tiRoot: Pointer to TISA initiator driver/port instance. 1029 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 1030 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 1031 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 1032 * \param satIOContext_t: Pointer to the SAT IO Context 1033 * 1034 * \return If command is started successfully 1035 * - \e tiSuccess: I/O request successfully initiated. 1036 * - \e tiBusy: No resources available, try again later. 1037 * - \e tiIONoDevice: Invalid device handle. 1038 * - \e tiError: Other errors. 1039 */ 1040 /*****************************************************************************/ 1041 GLOBAL bit32 satDeviceReset( 1042 tiRoot_t *tiRoot, 1043 tiIORequest_t *tiIORequest, 1044 tiDeviceHandle_t *tiDeviceHandle, 1045 tiScsiInitiatorRequest_t *tiScsiRequest, 1046 satIOContext_t *satIOContext 1047 ) 1048 { 1049 bit32 status; 1050 bit32 agRequestType; 1051 agsaFisRegHostToDevice_t *fis; 1052 1053 fis = satIOContext->pFis; 1054 1055 TI_DBG3(("satDeviceReset: start\n")); 1056 1057 /* 1058 * Send the Execute Device Diagnostic command. 1059 */ 1060 fis->h.fisType = 0x27; /* Reg host to device */ 1061 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1062 fis->h.command = SAT_DEVICE_RESET; /* 0x90 */ 1063 fis->h.features = 0; 1064 fis->d.lbaLow = 0; 1065 fis->d.lbaMid = 0; 1066 fis->d.lbaHigh = 0; 1067 fis->d.device = 0; 1068 fis->d.lbaLowExp = 0; 1069 fis->d.lbaMidExp = 0; 1070 fis->d.lbaHighExp = 0; 1071 fis->d.featuresExp = 0; 1072 fis->d.sectorCount = 0; 1073 fis->d.sectorCountExp = 0; 1074 fis->d.reserved4 = 0; 1075 fis->d.control = 0; /* FIS HOB bit clear */ 1076 fis->d.reserved5 = 0; 1077 1078 agRequestType = AGSA_SATA_PROTOCOL_DEV_RESET; 1079 1080 /* Initialize CB for SATA completion. 1081 */ 1082 satIOContext->satCompleteCB = &satDeviceResetCB; 1083 1084 /* 1085 * Prepare SGL and send FIS to LL layer. 1086 */ 1087 satIOContext->reqType = agRequestType; /* Save it */ 1088 1089 status = sataLLIOStart( tiRoot, 1090 tiIORequest, 1091 tiDeviceHandle, 1092 tiScsiRequest, 1093 satIOContext); 1094 1095 TI_DBG3(("satDeviceReset: return\n")); 1096 1097 return status; 1098 } 1099 1100 /*****************************************************************************/ 1101 /*! \brief SAT implementation for saExecuteDeviceDiagnostic. 1102 * 1103 * This function creates Execute Device Diagnostic fis and sends the request to LL layer 1104 * 1105 * \param tiRoot: Pointer to TISA initiator driver/port instance. 1106 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 1107 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 1108 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 1109 * \param satIOContext_t: Pointer to the SAT IO Context 1110 * 1111 * \return If command is started successfully 1112 * - \e tiSuccess: I/O request successfully initiated. 1113 * - \e tiBusy: No resources available, try again later. 1114 * - \e tiIONoDevice: Invalid device handle. 1115 * - \e tiError: Other errors. 1116 */ 1117 /*****************************************************************************/ 1118 GLOBAL bit32 satExecuteDeviceDiagnostic( 1119 tiRoot_t *tiRoot, 1120 tiIORequest_t *tiIORequest, 1121 tiDeviceHandle_t *tiDeviceHandle, 1122 tiScsiInitiatorRequest_t *tiScsiRequest, 1123 satIOContext_t *satIOContext 1124 ) 1125 { 1126 bit32 status; 1127 bit32 agRequestType; 1128 agsaFisRegHostToDevice_t *fis; 1129 1130 fis = satIOContext->pFis; 1131 1132 TI_DBG3(("satExecuteDeviceDiagnostic: start\n")); 1133 1134 /* 1135 * Send the Execute Device Diagnostic command. 1136 */ 1137 fis->h.fisType = 0x27; /* Reg host to device */ 1138 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1139 fis->h.command = SAT_EXECUTE_DEVICE_DIAGNOSTIC; /* 0x90 */ 1140 fis->h.features = 0; 1141 fis->d.lbaLow = 0; 1142 fis->d.lbaMid = 0; 1143 fis->d.lbaHigh = 0; 1144 fis->d.device = 0; 1145 fis->d.lbaLowExp = 0; 1146 fis->d.lbaMidExp = 0; 1147 fis->d.lbaHighExp = 0; 1148 fis->d.featuresExp = 0; 1149 fis->d.sectorCount = 0; 1150 fis->d.sectorCountExp = 0; 1151 fis->d.reserved4 = 0; 1152 fis->d.control = 0; /* FIS HOB bit clear */ 1153 fis->d.reserved5 = 0; 1154 1155 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 1156 1157 /* Initialize CB for SATA completion. 1158 */ 1159 satIOContext->satCompleteCB = &satExecuteDeviceDiagnosticCB; 1160 1161 /* 1162 * Prepare SGL and send FIS to LL layer. 1163 */ 1164 satIOContext->reqType = agRequestType; /* Save it */ 1165 1166 status = sataLLIOStart( tiRoot, 1167 tiIORequest, 1168 tiDeviceHandle, 1169 tiScsiRequest, 1170 satIOContext); 1171 1172 TI_DBG5(("satExecuteDeviceDiagnostic: return\n")); 1173 1174 return status; 1175 } 1176 1177 1178 /*****************************************************************************/ 1179 /*! \brief SAT implementation for SCSI READ10. 1180 * 1181 * SAT implementation for SCSI READ10 and send FIS request to LL layer. 1182 * 1183 * \param tiRoot: Pointer to TISA initiator driver/port instance. 1184 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 1185 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 1186 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 1187 * \param satIOContext_t: Pointer to the SAT IO Context 1188 * 1189 * \return If command is started successfully 1190 * - \e tiSuccess: I/O request successfully initiated. 1191 * - \e tiBusy: No resources available, try again later. 1192 * - \e tiIONoDevice: Invalid device handle. 1193 * - \e tiError: Other errors. 1194 */ 1195 /*****************************************************************************/ 1196 GLOBAL bit32 satRead10( 1197 tiRoot_t *tiRoot, 1198 tiIORequest_t *tiIORequest, 1199 tiDeviceHandle_t *tiDeviceHandle, 1200 tiScsiInitiatorRequest_t *tiScsiRequest, 1201 satIOContext_t *satIOContext) 1202 { 1203 1204 bit32 status; 1205 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 1206 satDeviceData_t *pSatDevData; 1207 scsiRspSense_t *pSense; 1208 tiIniScsiCmnd_t *scsiCmnd; 1209 agsaFisRegHostToDevice_t *fis; 1210 bit32 lba = 0; 1211 bit32 tl = 0; 1212 bit32 LoopNum = 1; 1213 bit8 LBA[4]; 1214 bit8 TL[4]; 1215 bit32 rangeChk = agFALSE; /* lba and tl range check */ 1216 1217 pSense = satIOContext->pSense; 1218 pSatDevData = satIOContext->pSatDevData; 1219 scsiCmnd = &tiScsiRequest->scsiCmnd; 1220 fis = satIOContext->pFis; 1221 1222 TI_DBG5(("satRead10: start\n")); 1223 TI_DBG5(("satRead10: pSatDevData=%p\n", pSatDevData)); 1224 // tdhexdump("satRead10", (bit8 *)scsiCmnd->cdb, 10); 1225 1226 /* checking FUA_NV */ 1227 if (scsiCmnd->cdb[1] & SCSI_FUA_NV_MASK) 1228 { 1229 satSetSensePayload( pSense, 1230 SCSI_SNSKEY_ILLEGAL_REQUEST, 1231 0, 1232 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 1233 satIOContext); 1234 1235 ostiInitiatorIOCompleted( tiRoot, 1236 tiIORequest, 1237 tiIOSuccess, 1238 SCSI_STAT_CHECK_CONDITION, 1239 satIOContext->pTiSenseData, 1240 satIOContext->interruptContext ); 1241 1242 TI_DBG1(("satRead10: return FUA_NV\n")); 1243 return tiSuccess; 1244 1245 } 1246 1247 /* checking CONTROL */ 1248 /* NACA == 1 or LINK == 1*/ 1249 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 1250 { 1251 satSetSensePayload( pSense, 1252 SCSI_SNSKEY_ILLEGAL_REQUEST, 1253 0, 1254 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 1255 satIOContext); 1256 1257 ostiInitiatorIOCompleted( tiRoot, 1258 tiIORequest, 1259 tiIOSuccess, 1260 SCSI_STAT_CHECK_CONDITION, 1261 satIOContext->pTiSenseData, 1262 satIOContext->interruptContext ); 1263 1264 TI_DBG1(("satRead10: return control\n")); 1265 return tiSuccess; 1266 } 1267 1268 osti_memset(LBA, 0, sizeof(LBA)); 1269 osti_memset(TL, 0, sizeof(TL)); 1270 1271 /* do not use memcpy due to indexing in LBA and TL */ 1272 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 1273 LBA[1] = scsiCmnd->cdb[3]; 1274 LBA[2] = scsiCmnd->cdb[4]; 1275 LBA[3] = scsiCmnd->cdb[5]; /* LSB */ 1276 1277 TL[0] = 0; 1278 TL[1] = 0; 1279 TL[2] = scsiCmnd->cdb[7]; /* MSB */ 1280 TL[3] = scsiCmnd->cdb[8]; /* LSB */ 1281 1282 rangeChk = satAddNComparebit32(LBA, TL); 1283 1284 /* cbd10; computing LBA and transfer length */ 1285 lba = (scsiCmnd->cdb[2] << (8*3)) + (scsiCmnd->cdb[3] << (8*2)) 1286 + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 1287 tl = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 1288 1289 1290 TI_DBG5(("satRead10: lba %d functioned lba %d\n", lba, satComputeCDB10LBA(satIOContext))); 1291 TI_DBG5(("satRead10: lba 0x%x functioned lba 0x%x\n", lba, satComputeCDB10LBA(satIOContext))); 1292 TI_DBG5(("satRead10: tl %d functioned tl %d\n", tl, satComputeCDB10TL(satIOContext))); 1293 1294 /* Table 34, 9.1, p 46 */ 1295 /* 1296 note: As of 2/10/2006, no support for DMA QUEUED 1297 */ 1298 1299 /* 1300 Table 34, 9.1, p 46, b 1301 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 1302 return check condition 1303 */ 1304 1305 if (pSatDevData->satNCQ != agTRUE && 1306 pSatDevData->sat48BitSupport != agTRUE 1307 ) 1308 { 1309 if (lba > SAT_TR_LBA_LIMIT - 1) 1310 { 1311 TI_DBG1(("satRead10: return LBA out of range, not EXT\n")); 1312 satSetSensePayload( pSense, 1313 SCSI_SNSKEY_ILLEGAL_REQUEST, 1314 0, 1315 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 1316 satIOContext); 1317 1318 ostiInitiatorIOCompleted( tiRoot, 1319 tiIORequest, 1320 tiIOSuccess, 1321 SCSI_STAT_CHECK_CONDITION, 1322 satIOContext->pTiSenseData, 1323 satIOContext->interruptContext ); 1324 1325 return tiSuccess; 1326 } 1327 1328 1329 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 1330 { 1331 TI_DBG1(("satRead10: return LBA+TL out of range, not EXT\n")); 1332 satSetSensePayload( pSense, 1333 SCSI_SNSKEY_ILLEGAL_REQUEST, 1334 0, 1335 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 1336 satIOContext); 1337 1338 ostiInitiatorIOCompleted( tiRoot, 1339 tiIORequest, 1340 tiIOSuccess, 1341 SCSI_STAT_CHECK_CONDITION, 1342 satIOContext->pTiSenseData, 1343 satIOContext->interruptContext ); 1344 1345 return tiSuccess; 1346 } 1347 } 1348 1349 /* case 1 and 2 */ 1350 if (!rangeChk) // if (lba + tl <= SAT_TR_LBA_LIMIT) 1351 { 1352 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 1353 { 1354 /* case 2 */ 1355 /* READ DMA*/ 1356 /* in case that we can't fit the transfer length, 1357 we need to make it fit by sending multiple ATA cmnds */ 1358 TI_DBG5(("satRead10: case 2\n")); 1359 1360 1361 fis->h.fisType = 0x27; /* Reg host to device */ 1362 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1363 fis->h.command = SAT_READ_DMA; /* 0xC8 */ 1364 fis->h.features = 0; /* FIS reserve */ 1365 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 1366 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 1367 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 1368 fis->d.device = 1369 (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); /* FIS LBA (27:24) and FIS LBA mode */ 1370 fis->d.lbaLowExp = 0; 1371 fis->d.lbaMidExp = 0; 1372 fis->d.lbaHighExp = 0; 1373 fis->d.featuresExp = 0; 1374 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 1375 fis->d.sectorCountExp = 0; 1376 fis->d.reserved4 = 0; 1377 fis->d.control = 0; /* FIS HOB bit clear */ 1378 fis->d.reserved5 = 0; 1379 1380 1381 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 1382 satIOContext->ATACmd = SAT_READ_DMA; 1383 } 1384 else 1385 { 1386 /* case 1 */ 1387 /* READ MULTIPLE or READ SECTOR(S) */ 1388 /* READ SECTORS for easier implemetation */ 1389 /* in case that we can't fit the transfer length, 1390 we need to make it fit by sending multiple ATA cmnds */ 1391 TI_DBG5(("satRead10: case 1\n")); 1392 1393 fis->h.fisType = 0x27; /* Reg host to device */ 1394 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1395 fis->h.command = SAT_READ_SECTORS; /* 0x20 */ 1396 fis->h.features = 0; /* FIS reserve */ 1397 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 1398 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 1399 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 1400 fis->d.device = 1401 (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); /* FIS LBA (27:24) and FIS LBA mode */ 1402 fis->d.lbaLowExp = 0; 1403 fis->d.lbaMidExp = 0; 1404 fis->d.lbaHighExp = 0; 1405 fis->d.featuresExp = 0; 1406 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 1407 fis->d.sectorCountExp = 0; 1408 fis->d.reserved4 = 0; 1409 fis->d.control = 0; /* FIS HOB bit clear */ 1410 fis->d.reserved5 = 0; 1411 1412 1413 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 1414 satIOContext->ATACmd = SAT_READ_SECTORS; 1415 } 1416 } 1417 1418 /* case 3 and 4 */ 1419 if (pSatDevData->sat48BitSupport == agTRUE) 1420 { 1421 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 1422 { 1423 /* case 3 */ 1424 /* READ DMA EXT */ 1425 TI_DBG5(("satRead10: case 3\n")); 1426 fis->h.fisType = 0x27; /* Reg host to device */ 1427 1428 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1429 fis->h.command = SAT_READ_DMA_EXT; /* 0x25 */ 1430 fis->h.features = 0; /* FIS reserve */ 1431 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 1432 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 1433 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 1434 fis->d.device = 0x40; /* FIS LBA mode set */ 1435 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 1436 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 1437 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 1438 fis->d.featuresExp = 0; /* FIS reserve */ 1439 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 1440 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 1441 fis->d.reserved4 = 0; 1442 fis->d.control = 0; /* FIS HOB bit clear */ 1443 fis->d.reserved5 = 0; 1444 1445 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 1446 satIOContext->ATACmd = SAT_READ_DMA_EXT; 1447 1448 } 1449 else 1450 { 1451 /* case 4 */ 1452 /* READ MULTIPLE EXT or READ SECTOR(S) EXT or READ VERIFY SECTOR(S) EXT*/ 1453 /* READ SECTORS EXT for easier implemetation */ 1454 TI_DBG5(("satRead10: case 4\n")); 1455 fis->h.fisType = 0x27; /* Reg host to device */ 1456 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1457 1458 /* Check FUA bit */ 1459 if (scsiCmnd->cdb[1] & SCSI_READ10_FUA_MASK) 1460 { 1461 1462 /* for now, no support for FUA */ 1463 satSetSensePayload( pSense, 1464 SCSI_SNSKEY_ILLEGAL_REQUEST, 1465 0, 1466 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 1467 satIOContext); 1468 1469 ostiInitiatorIOCompleted( tiRoot, 1470 tiIORequest, 1471 tiIOSuccess, 1472 SCSI_STAT_CHECK_CONDITION, 1473 satIOContext->pTiSenseData, 1474 satIOContext->interruptContext ); 1475 return tiSuccess; 1476 } 1477 1478 fis->h.command = SAT_READ_SECTORS_EXT; /* 0x24 */ 1479 1480 fis->h.features = 0; /* FIS reserve */ 1481 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 1482 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 1483 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 1484 fis->d.device = 0x40; /* FIS LBA mode set */ 1485 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 1486 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 1487 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 1488 fis->d.featuresExp = 0; /* FIS reserve */ 1489 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 1490 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 1491 fis->d.reserved4 = 0; 1492 fis->d.control = 0; /* FIS HOB bit clear */ 1493 fis->d.reserved5 = 0; 1494 1495 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 1496 satIOContext->ATACmd = SAT_READ_SECTORS_EXT; 1497 } 1498 } 1499 1500 /* case 5 */ 1501 if (pSatDevData->satNCQ == agTRUE) 1502 { 1503 /* READ FPDMA QUEUED */ 1504 if (pSatDevData->sat48BitSupport != agTRUE) 1505 { 1506 TI_DBG5(("satRead10: case 5 !!! error NCQ but 28 bit address support \n")); 1507 satSetSensePayload( pSense, 1508 SCSI_SNSKEY_ILLEGAL_REQUEST, 1509 0, 1510 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 1511 satIOContext); 1512 1513 ostiInitiatorIOCompleted( tiRoot, 1514 tiIORequest, 1515 tiIOSuccess, 1516 SCSI_STAT_CHECK_CONDITION, 1517 satIOContext->pTiSenseData, 1518 satIOContext->interruptContext ); 1519 return tiSuccess; 1520 } 1521 1522 TI_DBG6(("satRead10: case 5\n")); 1523 1524 /* Support 48-bit FPDMA addressing, use READ FPDMA QUEUE command */ 1525 1526 fis->h.fisType = 0x27; /* Reg host to device */ 1527 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1528 fis->h.command = SAT_READ_FPDMA_QUEUED; /* 0x60 */ 1529 fis->h.features = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 1530 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 1531 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 1532 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 1533 1534 /* Check FUA bit */ 1535 if (scsiCmnd->cdb[1] & SCSI_READ10_FUA_MASK) 1536 fis->d.device = 0xC0; /* FIS FUA set */ 1537 else 1538 fis->d.device = 0x40; /* FIS FUA clear */ 1539 1540 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 1541 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 1542 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 1543 fis->d.featuresExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 1544 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 1545 fis->d.sectorCountExp = 0; 1546 fis->d.reserved4 = 0; 1547 fis->d.control = 0; /* FIS HOB bit clear */ 1548 fis->d.reserved5 = 0; 1549 1550 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_READ; 1551 satIOContext->ATACmd = SAT_READ_FPDMA_QUEUED; 1552 } 1553 1554 1555 // tdhexdump("satRead10 final fis", (bit8 *)fis, sizeof(agsaFisRegHostToDevice_t)); 1556 1557 /* saves the current LBA and orginal TL */ 1558 satIOContext->currentLBA = lba; 1559 satIOContext->OrgTL = tl; 1560 1561 /* 1562 computing number of loop and remainder for tl 1563 0xFF in case not ext 1564 0xFFFF in case EXT 1565 */ 1566 if (fis->h.command == SAT_READ_SECTORS || fis->h.command == SAT_READ_DMA) 1567 { 1568 LoopNum = satComputeLoopNum(tl, 0xFF); 1569 } 1570 else if (fis->h.command == SAT_READ_SECTORS_EXT || fis->h.command == SAT_READ_DMA_EXT) 1571 { 1572 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 1573 LoopNum = satComputeLoopNum(tl, 0xFFFF); 1574 } 1575 else 1576 { 1577 /* SAT_READ_FPDMA_QUEUED */ 1578 LoopNum = satComputeLoopNum(tl, 0xFFFF); 1579 } 1580 1581 satIOContext->LoopNum = LoopNum; 1582 1583 /* Initialize CB for SATA completion. 1584 */ 1585 if (LoopNum == 1) 1586 { 1587 TI_DBG5(("satRead10: NON CHAINED data\n")); 1588 satIOContext->satCompleteCB = &satNonChainedDataIOCB; 1589 } 1590 else 1591 { 1592 TI_DBG1(("satRead10: CHAINED data\n")); 1593 /* re-setting tl */ 1594 if (fis->h.command == SAT_READ_SECTORS || fis->h.command == SAT_READ_DMA) 1595 { 1596 fis->d.sectorCount = 0xFF; 1597 } 1598 else if (fis->h.command == SAT_READ_SECTORS_EXT || fis->h.command == SAT_READ_DMA_EXT) 1599 { 1600 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 1601 fis->d.sectorCount = 0xFF; 1602 fis->d.sectorCountExp = 0xFF; 1603 } 1604 else 1605 { 1606 /* SAT_READ_FPDMA_QUEUED */ 1607 fis->h.features = 0xFF; 1608 fis->d.featuresExp = 0xFF; 1609 } 1610 1611 /* chained data */ 1612 satIOContext->satCompleteCB = &satChainedDataIOCB; 1613 1614 } 1615 1616 /* 1617 * Prepare SGL and send FIS to LL layer. 1618 */ 1619 satIOContext->reqType = agRequestType; /* Save it */ 1620 1621 status = sataLLIOStart( tiRoot, 1622 tiIORequest, 1623 tiDeviceHandle, 1624 tiScsiRequest, 1625 satIOContext); 1626 1627 TI_DBG5(("satRead10: return\n")); 1628 return (status); 1629 1630 } 1631 1632 1633 /*****************************************************************************/ 1634 /*! \brief SAT implementation for SCSI satRead_1. 1635 * 1636 * SAT implementation for SCSI satRead_1 1637 * Sub function of satRead10 1638 * 1639 * \param tiRoot: Pointer to TISA initiator driver/port instance. 1640 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 1641 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 1642 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 1643 * \param satIOContext_t: Pointer to the SAT IO Context 1644 * 1645 * \return If command is started successfully 1646 * - \e tiSuccess: I/O request successfully initiated. 1647 * - \e tiBusy: No resources available, try again later. 1648 * - \e tiIONoDevice: Invalid device handle. 1649 * - \e tiError: Other errors. 1650 */ 1651 /*****************************************************************************/ 1652 /* 1653 * as a part of loop for read10 1654 */ 1655 GLOBAL bit32 satRead_1( 1656 tiRoot_t *tiRoot, 1657 tiIORequest_t *tiIORequest, 1658 tiDeviceHandle_t *tiDeviceHandle, 1659 tiScsiInitiatorRequest_t *tiScsiRequest, 1660 satIOContext_t *satIOContext) 1661 { 1662 /* 1663 Assumption: error check on lba and tl has been done in satRead*() 1664 lba = lba + tl; 1665 */ 1666 bit32 status; 1667 satIOContext_t *satOrgIOContext = agNULL; 1668 tiIniScsiCmnd_t *scsiCmnd; 1669 agsaFisRegHostToDevice_t *fis; 1670 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 1671 bit32 lba = 0; 1672 bit32 DenomTL = 0xFF; 1673 bit32 Remainder = 0; 1674 bit8 LBA[4]; /* 0 MSB, 3 LSB */ 1675 1676 TI_DBG2(("satRead_1: start\n")); 1677 1678 fis = satIOContext->pFis; 1679 satOrgIOContext = satIOContext->satOrgIOContext; 1680 scsiCmnd = satOrgIOContext->pScsiCmnd; 1681 1682 osti_memset(LBA,0, sizeof(LBA)); 1683 1684 switch (satOrgIOContext->ATACmd) 1685 { 1686 case SAT_READ_DMA: 1687 DenomTL = 0xFF; 1688 break; 1689 case SAT_READ_SECTORS: 1690 DenomTL = 0xFF; 1691 break; 1692 case SAT_READ_DMA_EXT: 1693 DenomTL = 0xFFFF; 1694 break; 1695 case SAT_READ_SECTORS_EXT: 1696 DenomTL = 0xFFFF; 1697 break; 1698 case SAT_READ_FPDMA_QUEUED: 1699 DenomTL = 0xFFFF; 1700 break; 1701 default: 1702 TI_DBG1(("satRead_1: error incorrect ata command 0x%x\n", satIOContext->ATACmd)); 1703 return tiError; 1704 break; 1705 } 1706 1707 Remainder = satOrgIOContext->OrgTL % DenomTL; 1708 satOrgIOContext->currentLBA = satOrgIOContext->currentLBA + DenomTL; 1709 lba = satOrgIOContext->currentLBA; 1710 1711 LBA[0] = (bit8)((lba & 0xF000) >> (8 * 3)); 1712 LBA[1] = (bit8)((lba & 0xF00) >> (8 * 2)); 1713 LBA[2] = (bit8)((lba & 0xF0) >> 8); 1714 LBA[3] = (bit8)(lba & 0xF); 1715 1716 1717 switch (satOrgIOContext->ATACmd) 1718 { 1719 case SAT_READ_DMA: 1720 fis->h.fisType = 0x27; /* Reg host to device */ 1721 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1722 fis->h.command = SAT_READ_DMA; /* 0xC8 */ 1723 fis->h.features = 0; /* FIS reserve */ 1724 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 1725 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 1726 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 1727 fis->d.device = 1728 (bit8)((0x4 << 4) | (LBA[0] & 0xF)); /* FIS LBA (27:24) and FIS LBA mode */ 1729 fis->d.lbaLowExp = 0; 1730 fis->d.lbaMidExp = 0; 1731 fis->d.lbaHighExp = 0; 1732 fis->d.featuresExp = 0; 1733 1734 if (satOrgIOContext->LoopNum == 1) 1735 { 1736 /* last loop */ 1737 fis->d.sectorCount = (bit8)Remainder; /* FIS sector count (7:0) */ 1738 } 1739 else 1740 { 1741 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 1742 } 1743 1744 fis->d.sectorCountExp = 0; 1745 fis->d.reserved4 = 0; 1746 fis->d.control = 0; /* FIS HOB bit clear */ 1747 fis->d.reserved5 = 0; 1748 1749 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 1750 1751 break; 1752 case SAT_READ_SECTORS: 1753 fis->h.fisType = 0x27; /* Reg host to device */ 1754 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1755 fis->h.command = SAT_READ_SECTORS; /* 0x20 */ 1756 fis->h.features = 0; /* FIS reserve */ 1757 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 1758 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 1759 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 1760 fis->d.device = 1761 (bit8)((0x4 << 4) | (LBA[0] & 0xF)); /* FIS LBA (27:24) and FIS LBA mode */ 1762 fis->d.lbaLowExp = 0; 1763 fis->d.lbaMidExp = 0; 1764 fis->d.lbaHighExp = 0; 1765 fis->d.featuresExp = 0; 1766 if (satOrgIOContext->LoopNum == 1) 1767 { 1768 /* last loop */ 1769 fis->d.sectorCount = (bit8)Remainder; /* FIS sector count (7:0) */ 1770 } 1771 else 1772 { 1773 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 1774 } 1775 fis->d.sectorCountExp = 0; 1776 fis->d.reserved4 = 0; 1777 fis->d.control = 0; /* FIS HOB bit clear */ 1778 fis->d.reserved5 = 0; 1779 1780 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 1781 1782 break; 1783 case SAT_READ_DMA_EXT: 1784 fis->h.fisType = 0x27; /* Reg host to device */ 1785 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1786 fis->h.command = SAT_READ_DMA_EXT; /* 0x25 */ 1787 fis->h.features = 0; /* FIS reserve */ 1788 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 1789 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 1790 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 1791 fis->d.device = 0x40; /* FIS LBA mode set */ 1792 fis->d.lbaLowExp = LBA[0]; /* FIS LBA (31:24) */ 1793 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 1794 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 1795 fis->d.featuresExp = 0; /* FIS reserve */ 1796 if (satOrgIOContext->LoopNum == 1) 1797 { 1798 /* last loop */ 1799 fis->d.sectorCount = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 1800 fis->d.sectorCountExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 1801 1802 } 1803 else 1804 { 1805 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 1806 fis->d.sectorCountExp = 0xFF; /* FIS sector count (15:8) */ 1807 } 1808 fis->d.reserved4 = 0; 1809 fis->d.control = 0; /* FIS HOB bit clear */ 1810 fis->d.reserved5 = 0; 1811 1812 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 1813 1814 break; 1815 case SAT_READ_SECTORS_EXT: 1816 fis->h.fisType = 0x27; /* Reg host to device */ 1817 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1818 fis->h.command = SAT_READ_SECTORS_EXT; /* 0x24 */ 1819 fis->h.features = 0; /* FIS reserve */ 1820 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 1821 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 1822 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 1823 fis->d.device = 0x40; /* FIS LBA mode set */ 1824 fis->d.lbaLowExp = LBA[0]; /* FIS LBA (31:24) */ 1825 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 1826 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 1827 fis->d.featuresExp = 0; /* FIS reserve */ 1828 if (satOrgIOContext->LoopNum == 1) 1829 { 1830 /* last loop */ 1831 fis->d.sectorCount = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 1832 fis->d.sectorCountExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 1833 } 1834 else 1835 { 1836 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 1837 fis->d.sectorCountExp = 0xFF; /* FIS sector count (15:8) */ 1838 } 1839 fis->d.reserved4 = 0; 1840 fis->d.control = 0; /* FIS HOB bit clear */ 1841 fis->d.reserved5 = 0; 1842 1843 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 1844 break; 1845 case SAT_READ_FPDMA_QUEUED: 1846 fis->h.fisType = 0x27; /* Reg host to device */ 1847 fis->h.c_pmPort = 0x80; /* C Bit is set */ 1848 fis->h.command = SAT_READ_FPDMA_QUEUED; /* 0x60 */ 1849 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 1850 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 1851 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 1852 1853 /* Check FUA bit */ 1854 if (scsiCmnd->cdb[1] & SCSI_READ10_FUA_MASK) 1855 fis->d.device = 0xC0; /* FIS FUA set */ 1856 else 1857 fis->d.device = 0x40; /* FIS FUA clear */ 1858 1859 fis->d.lbaLowExp = LBA[0]; /* FIS LBA (31:24) */ 1860 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 1861 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 1862 if (satOrgIOContext->LoopNum == 1) 1863 { 1864 /* last loop */ 1865 fis->h.features = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 1866 fis->d.featuresExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 1867 } 1868 else 1869 { 1870 fis->h.features = 0xFF; /* FIS sector count (7:0) */ 1871 fis->d.featuresExp = 0xFF; /* FIS sector count (15:8) */ 1872 } 1873 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 1874 fis->d.sectorCountExp = 0; 1875 fis->d.reserved4 = 0; 1876 fis->d.control = 0; /* FIS HOB bit clear */ 1877 fis->d.reserved5 = 0; 1878 1879 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_READ; 1880 break; 1881 default: 1882 TI_DBG1(("satRead_1: error incorrect ata command 0x%x\n", satIOContext->ATACmd)); 1883 return tiError; 1884 break; 1885 } 1886 1887 /* Initialize CB for SATA completion. 1888 */ 1889 /* chained data */ 1890 satIOContext->satCompleteCB = &satChainedDataIOCB; 1891 1892 1893 /* 1894 * Prepare SGL and send FIS to LL layer. 1895 */ 1896 satIOContext->reqType = agRequestType; /* Save it */ 1897 1898 status = sataLLIOStart( tiRoot, 1899 tiIORequest, 1900 tiDeviceHandle, 1901 tiScsiRequest, 1902 satIOContext); 1903 1904 TI_DBG5(("satRead_1: return\n")); 1905 return (status); 1906 } 1907 /*****************************************************************************/ 1908 /*! \brief SAT implementation for SCSI READ12. 1909 * 1910 * SAT implementation for SCSI READ12 and send FIS request to LL layer. 1911 * 1912 * \param tiRoot: Pointer to TISA initiator driver/port instance. 1913 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 1914 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 1915 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 1916 * \param satIOContext_t: Pointer to the SAT IO Context 1917 * 1918 * \return If command is started successfully 1919 * - \e tiSuccess: I/O request successfully initiated. 1920 * - \e tiBusy: No resources available, try again later. 1921 * - \e tiIONoDevice: Invalid device handle. 1922 * - \e tiError: Other errors. 1923 */ 1924 /*****************************************************************************/ 1925 GLOBAL bit32 satRead12( 1926 tiRoot_t *tiRoot, 1927 tiIORequest_t *tiIORequest, 1928 tiDeviceHandle_t *tiDeviceHandle, 1929 tiScsiInitiatorRequest_t *tiScsiRequest, 1930 satIOContext_t *satIOContext) 1931 { 1932 bit32 status; 1933 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 1934 satDeviceData_t *pSatDevData; 1935 scsiRspSense_t *pSense; 1936 tiIniScsiCmnd_t *scsiCmnd; 1937 agsaFisRegHostToDevice_t *fis; 1938 bit32 lba = 0; 1939 bit32 tl = 0; 1940 bit32 LoopNum = 1; 1941 bit8 LBA[4]; 1942 bit8 TL[4]; 1943 bit32 rangeChk = agFALSE; /* lba and tl range check */ 1944 1945 pSense = satIOContext->pSense; 1946 pSatDevData = satIOContext->pSatDevData; 1947 scsiCmnd = &tiScsiRequest->scsiCmnd; 1948 fis = satIOContext->pFis; 1949 1950 TI_DBG5(("satRead12: start\n")); 1951 1952 /* checking FUA_NV */ 1953 if (scsiCmnd->cdb[1] & SCSI_FUA_NV_MASK) 1954 { 1955 satSetSensePayload( pSense, 1956 SCSI_SNSKEY_ILLEGAL_REQUEST, 1957 0, 1958 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 1959 satIOContext); 1960 1961 ostiInitiatorIOCompleted( tiRoot, 1962 tiIORequest, 1963 tiIOSuccess, 1964 SCSI_STAT_CHECK_CONDITION, 1965 satIOContext->pTiSenseData, 1966 satIOContext->interruptContext ); 1967 1968 TI_DBG1(("satRead12: return FUA_NV\n")); 1969 return tiSuccess; 1970 1971 } 1972 1973 /* checking CONTROL */ 1974 /* NACA == 1 or LINK == 1*/ 1975 if ( (scsiCmnd->cdb[11] & SCSI_NACA_MASK) || (scsiCmnd->cdb[11] & SCSI_LINK_MASK) ) 1976 { 1977 satSetSensePayload( pSense, 1978 SCSI_SNSKEY_ILLEGAL_REQUEST, 1979 0, 1980 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 1981 satIOContext); 1982 1983 ostiInitiatorIOCompleted( tiRoot, 1984 tiIORequest, 1985 tiIOSuccess, 1986 SCSI_STAT_CHECK_CONDITION, 1987 satIOContext->pTiSenseData, 1988 satIOContext->interruptContext ); 1989 1990 TI_DBG2(("satRead12: return control\n")); 1991 return tiSuccess; 1992 } 1993 1994 osti_memset(LBA, 0, sizeof(LBA)); 1995 osti_memset(TL, 0, sizeof(TL)); 1996 1997 /* do not use memcpy due to indexing in LBA and TL */ 1998 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 1999 LBA[1] = scsiCmnd->cdb[3]; 2000 LBA[2] = scsiCmnd->cdb[4]; 2001 LBA[3] = scsiCmnd->cdb[5]; /* LSB */ 2002 2003 TL[0] = scsiCmnd->cdb[6]; /* MSB */ 2004 TL[1] = scsiCmnd->cdb[7]; 2005 TL[2] = scsiCmnd->cdb[8]; 2006 TL[3] = scsiCmnd->cdb[9]; /* LSB */ 2007 2008 rangeChk = satAddNComparebit32(LBA, TL); 2009 2010 lba = satComputeCDB12LBA(satIOContext); 2011 tl = satComputeCDB12TL(satIOContext); 2012 2013 /* Table 34, 9.1, p 46 */ 2014 /* 2015 note: As of 2/10/2006, no support for DMA QUEUED 2016 */ 2017 2018 /* 2019 Table 34, 9.1, p 46, b 2020 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 2021 return check condition 2022 */ 2023 if (pSatDevData->satNCQ != agTRUE && 2024 pSatDevData->sat48BitSupport != agTRUE 2025 ) 2026 { 2027 if (lba > SAT_TR_LBA_LIMIT - 1) 2028 { 2029 TI_DBG1(("satRead12: return LBA out of range, not EXT\n")); 2030 satSetSensePayload( pSense, 2031 SCSI_SNSKEY_ILLEGAL_REQUEST, 2032 0, 2033 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 2034 satIOContext); 2035 2036 ostiInitiatorIOCompleted( tiRoot, 2037 tiIORequest, 2038 tiIOSuccess, 2039 SCSI_STAT_CHECK_CONDITION, 2040 satIOContext->pTiSenseData, 2041 satIOContext->interruptContext ); 2042 2043 return tiSuccess; 2044 } 2045 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 2046 { 2047 TI_DBG1(("satRead12: return LBA+TL out of range, not EXT\n")); 2048 satSetSensePayload( pSense, 2049 SCSI_SNSKEY_ILLEGAL_REQUEST, 2050 0, 2051 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 2052 satIOContext); 2053 2054 ostiInitiatorIOCompleted( tiRoot, 2055 tiIORequest, 2056 tiIOSuccess, 2057 SCSI_STAT_CHECK_CONDITION, 2058 satIOContext->pTiSenseData, 2059 satIOContext->interruptContext ); 2060 2061 return tiSuccess; 2062 } 2063 } 2064 2065 /* case 1 and 2 */ 2066 if (!rangeChk) // if (lba + tl <= SAT_TR_LBA_LIMIT) 2067 { 2068 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 2069 { 2070 /* case 2 */ 2071 /* READ DMA*/ 2072 /* in case that we can't fit the transfer length, 2073 we need to make it fit by sending multiple ATA cmnds */ 2074 TI_DBG5(("satRead12: case 2\n")); 2075 2076 2077 fis->h.fisType = 0x27; /* Reg host to device */ 2078 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2079 fis->h.command = SAT_READ_DMA; /* 0xC8 */ 2080 fis->h.features = 0; /* FIS reserve */ 2081 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 2082 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 2083 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 2084 fis->d.device = 2085 (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); /* FIS LBA (27:24) and FIS LBA mode */ 2086 fis->d.lbaLowExp = 0; 2087 fis->d.lbaMidExp = 0; 2088 fis->d.lbaHighExp = 0; 2089 fis->d.featuresExp = 0; 2090 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 2091 fis->d.sectorCountExp = 0; 2092 fis->d.reserved4 = 0; 2093 fis->d.control = 0; /* FIS HOB bit clear */ 2094 fis->d.reserved5 = 0; 2095 2096 2097 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 2098 satIOContext->ATACmd = SAT_READ_DMA; 2099 } 2100 else 2101 { 2102 /* case 1 */ 2103 /* READ MULTIPLE or READ SECTOR(S) */ 2104 /* READ SECTORS for easier implemetation */ 2105 /* can't fit the transfer length but need to make it fit by sending multiple*/ 2106 TI_DBG5(("satRead12: case 1\n")); 2107 2108 fis->h.fisType = 0x27; /* Reg host to device */ 2109 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2110 fis->h.command = SAT_READ_SECTORS; /* 0x20 */ 2111 fis->h.features = 0; /* FIS reserve */ 2112 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 2113 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 2114 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 2115 fis->d.device = 2116 (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); /* FIS LBA (27:24) and FIS LBA mode */ 2117 fis->d.lbaLowExp = 0; 2118 fis->d.lbaMidExp = 0; 2119 fis->d.lbaHighExp = 0; 2120 fis->d.featuresExp = 0; 2121 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 2122 fis->d.sectorCountExp = 0; 2123 fis->d.reserved4 = 0; 2124 fis->d.control = 0; /* FIS HOB bit clear */ 2125 fis->d.reserved5 = 0; 2126 2127 2128 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 2129 satIOContext->ATACmd = SAT_READ_SECTORS; 2130 } 2131 } 2132 2133 /* case 3 and 4 */ 2134 if (pSatDevData->sat48BitSupport == agTRUE) 2135 { 2136 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 2137 { 2138 /* case 3 */ 2139 /* READ DMA EXT */ 2140 TI_DBG5(("satRead12: case 3\n")); 2141 fis->h.fisType = 0x27; /* Reg host to device */ 2142 2143 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2144 fis->h.command = SAT_READ_DMA_EXT; /* 0x25 */ 2145 fis->h.features = 0; /* FIS reserve */ 2146 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 2147 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 2148 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 2149 fis->d.device = 0x40; /* FIS LBA mode set */ 2150 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 2151 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 2152 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 2153 fis->d.featuresExp = 0; /* FIS reserve */ 2154 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 2155 fis->d.sectorCountExp = scsiCmnd->cdb[8]; /* FIS sector count (15:8) */ 2156 fis->d.reserved4 = 0; 2157 fis->d.control = 0; /* FIS HOB bit clear */ 2158 fis->d.reserved5 = 0; 2159 2160 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 2161 satIOContext->ATACmd = SAT_READ_DMA_EXT; 2162 2163 } 2164 else 2165 { 2166 /* case 4 */ 2167 /* READ MULTIPLE EXT or READ SECTOR(S) EXT or READ VERIFY SECTOR(S) EXT*/ 2168 /* READ SECTORS EXT for easier implemetation */ 2169 TI_DBG5(("satRead12: case 4\n")); 2170 fis->h.fisType = 0x27; /* Reg host to device */ 2171 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2172 2173 /* Check FUA bit */ 2174 if (scsiCmnd->cdb[1] & SCSI_READ12_FUA_MASK) 2175 { 2176 /* for now, no support for FUA */ 2177 satSetSensePayload( pSense, 2178 SCSI_SNSKEY_ILLEGAL_REQUEST, 2179 0, 2180 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 2181 satIOContext); 2182 2183 ostiInitiatorIOCompleted( tiRoot, 2184 tiIORequest, 2185 tiIOSuccess, 2186 SCSI_STAT_CHECK_CONDITION, 2187 satIOContext->pTiSenseData, 2188 satIOContext->interruptContext ); 2189 return tiSuccess; 2190 } 2191 2192 fis->h.command = SAT_READ_SECTORS_EXT; /* 0x24 */ 2193 2194 fis->h.features = 0; /* FIS reserve */ 2195 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 2196 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 2197 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 2198 fis->d.device = 0x40; /* FIS LBA mode set */ 2199 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 2200 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 2201 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 2202 fis->d.featuresExp = 0; /* FIS reserve */ 2203 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 2204 fis->d.sectorCountExp = scsiCmnd->cdb[8]; /* FIS sector count (15:8) */ 2205 fis->d.reserved4 = 0; 2206 fis->d.control = 0; /* FIS HOB bit clear */ 2207 fis->d.reserved5 = 0; 2208 2209 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 2210 satIOContext->ATACmd = SAT_READ_SECTORS_EXT; 2211 } 2212 } 2213 2214 /* case 5 */ 2215 if (pSatDevData->satNCQ == agTRUE) 2216 { 2217 /* READ FPDMA QUEUED */ 2218 if (pSatDevData->sat48BitSupport != agTRUE) 2219 { 2220 TI_DBG5(("satRead12: case 5 !!! error NCQ but 28 bit address support \n")); 2221 satSetSensePayload( pSense, 2222 SCSI_SNSKEY_ILLEGAL_REQUEST, 2223 0, 2224 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 2225 satIOContext); 2226 2227 ostiInitiatorIOCompleted( tiRoot, 2228 tiIORequest, 2229 tiIOSuccess, 2230 SCSI_STAT_CHECK_CONDITION, 2231 satIOContext->pTiSenseData, 2232 satIOContext->interruptContext ); 2233 return tiSuccess; 2234 } 2235 2236 TI_DBG6(("satRead12: case 5\n")); 2237 2238 /* Support 48-bit FPDMA addressing, use READ FPDMA QUEUE command */ 2239 2240 fis->h.fisType = 0x27; /* Reg host to device */ 2241 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2242 fis->h.command = SAT_READ_FPDMA_QUEUED; /* 0x60 */ 2243 fis->h.features = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 2244 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 2245 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 2246 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 2247 2248 /* Check FUA bit */ 2249 if (scsiCmnd->cdb[1] & SCSI_READ12_FUA_MASK) 2250 fis->d.device = 0xC0; /* FIS FUA set */ 2251 else 2252 fis->d.device = 0x40; /* FIS FUA clear */ 2253 2254 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 2255 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 2256 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 2257 fis->d.featuresExp = scsiCmnd->cdb[8]; /* FIS sector count (15:8) */ 2258 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 2259 fis->d.sectorCountExp = 0; 2260 fis->d.reserved4 = 0; 2261 fis->d.control = 0; /* FIS HOB bit clear */ 2262 fis->d.reserved5 = 0; 2263 2264 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_READ; 2265 satIOContext->ATACmd = SAT_READ_FPDMA_QUEUED; 2266 } 2267 2268 /* saves the current LBA and orginal TL */ 2269 satIOContext->currentLBA = lba; 2270 satIOContext->OrgTL = tl; 2271 2272 /* 2273 computing number of loop and remainder for tl 2274 0xFF in case not ext 2275 0xFFFF in case EXT 2276 */ 2277 if (fis->h.command == SAT_READ_SECTORS || fis->h.command == SAT_READ_DMA) 2278 { 2279 LoopNum = satComputeLoopNum(tl, 0xFF); 2280 } 2281 else if (fis->h.command == SAT_READ_SECTORS_EXT || fis->h.command == SAT_READ_DMA_EXT) 2282 { 2283 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 2284 LoopNum = satComputeLoopNum(tl, 0xFFFF); 2285 } 2286 else 2287 { 2288 /* SAT_READ_FPDMA_QUEUEDK */ 2289 LoopNum = satComputeLoopNum(tl, 0xFFFF); 2290 } 2291 2292 satIOContext->LoopNum = LoopNum; 2293 2294 if (LoopNum == 1) 2295 { 2296 TI_DBG5(("satRead12: NON CHAINED data\n")); 2297 satIOContext->satCompleteCB = &satNonChainedDataIOCB; 2298 } 2299 else 2300 { 2301 TI_DBG1(("satRead12: CHAINED data\n")); 2302 /* re-setting tl */ 2303 if (fis->h.command == SAT_READ_SECTORS || fis->h.command == SAT_READ_DMA) 2304 { 2305 fis->d.sectorCount = 0xFF; 2306 } 2307 else if (fis->h.command == SAT_READ_SECTORS_EXT || fis->h.command == SAT_READ_DMA_EXT) 2308 { 2309 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 2310 fis->d.sectorCount = 0xFF; 2311 fis->d.sectorCountExp = 0xFF; 2312 } 2313 else 2314 { 2315 /* SAT_READ_FPDMA_QUEUED */ 2316 fis->h.features = 0xFF; 2317 fis->d.featuresExp = 0xFF; 2318 } 2319 2320 /* chained data */ 2321 satIOContext->satCompleteCB = &satChainedDataIOCB; 2322 } 2323 2324 /* 2325 * Prepare SGL and send FIS to LL layer. 2326 */ 2327 satIOContext->reqType = agRequestType; /* Save it */ 2328 2329 status = sataLLIOStart( tiRoot, 2330 tiIORequest, 2331 tiDeviceHandle, 2332 tiScsiRequest, 2333 satIOContext); 2334 2335 TI_DBG5(("satRead12: return\n")); 2336 return (status); 2337 } 2338 /*****************************************************************************/ 2339 /*! \brief SAT implementation for SCSI READ16. 2340 * 2341 * SAT implementation for SCSI READ16 and send FIS request to LL layer. 2342 * 2343 * \param tiRoot: Pointer to TISA initiator driver/port instance. 2344 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 2345 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 2346 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 2347 * \param satIOContext_t: Pointer to the SAT IO Context 2348 * 2349 * \return If command is started successfully 2350 * - \e tiSuccess: I/O request successfully initiated. 2351 * - \e tiBusy: No resources available, try again later. 2352 * - \e tiIONoDevice: Invalid device handle. 2353 * - \e tiError: Other errors. 2354 */ 2355 /*****************************************************************************/ 2356 GLOBAL bit32 satRead16( 2357 tiRoot_t *tiRoot, 2358 tiIORequest_t *tiIORequest, 2359 tiDeviceHandle_t *tiDeviceHandle, 2360 tiScsiInitiatorRequest_t *tiScsiRequest, 2361 satIOContext_t *satIOContext) 2362 { 2363 bit32 status; 2364 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 2365 satDeviceData_t *pSatDevData; 2366 scsiRspSense_t *pSense; 2367 tiIniScsiCmnd_t *scsiCmnd; 2368 agsaFisRegHostToDevice_t *fis; 2369 bit32 lba = 0; 2370 bit32 tl = 0; 2371 bit32 LoopNum = 1; 2372 bit8 LBA[8]; 2373 bit8 TL[8]; 2374 bit32 rangeChk = agFALSE; /* lba and tl range check */ 2375 bit32 limitChk = agFALSE; /* lba and tl range check */ 2376 2377 pSense = satIOContext->pSense; 2378 pSatDevData = satIOContext->pSatDevData; 2379 scsiCmnd = &tiScsiRequest->scsiCmnd; 2380 fis = satIOContext->pFis; 2381 2382 TI_DBG5(("satRead16: start\n")); 2383 2384 /* checking FUA_NV */ 2385 if (scsiCmnd->cdb[1] & SCSI_FUA_NV_MASK) 2386 { 2387 satSetSensePayload( pSense, 2388 SCSI_SNSKEY_ILLEGAL_REQUEST, 2389 0, 2390 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 2391 satIOContext); 2392 2393 ostiInitiatorIOCompleted( tiRoot, 2394 tiIORequest, 2395 tiIOSuccess, 2396 SCSI_STAT_CHECK_CONDITION, 2397 satIOContext->pTiSenseData, 2398 satIOContext->interruptContext ); 2399 2400 TI_DBG1(("satRead16: return FUA_NV\n")); 2401 return tiSuccess; 2402 2403 } 2404 2405 /* checking CONTROL */ 2406 /* NACA == 1 or LINK == 1*/ 2407 if ( (scsiCmnd->cdb[15] & SCSI_NACA_MASK) || (scsiCmnd->cdb[15] & SCSI_LINK_MASK) ) 2408 { 2409 satSetSensePayload( pSense, 2410 SCSI_SNSKEY_ILLEGAL_REQUEST, 2411 0, 2412 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 2413 satIOContext); 2414 2415 ostiInitiatorIOCompleted( tiRoot, 2416 tiIORequest, 2417 tiIOSuccess, 2418 SCSI_STAT_CHECK_CONDITION, 2419 satIOContext->pTiSenseData, 2420 satIOContext->interruptContext ); 2421 2422 TI_DBG1(("satRead16: return control\n")); 2423 return tiSuccess; 2424 } 2425 2426 2427 osti_memset(LBA, 0, sizeof(LBA)); 2428 osti_memset(TL, 0, sizeof(TL)); 2429 2430 2431 /* do not use memcpy due to indexing in LBA and TL */ 2432 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 2433 LBA[1] = scsiCmnd->cdb[3]; 2434 LBA[2] = scsiCmnd->cdb[4]; 2435 LBA[3] = scsiCmnd->cdb[5]; 2436 LBA[4] = scsiCmnd->cdb[6]; 2437 LBA[5] = scsiCmnd->cdb[7]; 2438 LBA[6] = scsiCmnd->cdb[8]; 2439 LBA[7] = scsiCmnd->cdb[9]; /* LSB */ 2440 2441 TL[0] = 0; 2442 TL[1] = 0; 2443 TL[2] = 0; 2444 TL[3] = 0; 2445 TL[4] = scsiCmnd->cdb[10]; /* MSB */ 2446 TL[5] = scsiCmnd->cdb[11]; 2447 TL[6] = scsiCmnd->cdb[12]; 2448 TL[7] = scsiCmnd->cdb[13]; /* LSB */ 2449 2450 rangeChk = satAddNComparebit64(LBA, TL); 2451 2452 limitChk = satCompareLBALimitbit(LBA); 2453 2454 lba = satComputeCDB16LBA(satIOContext); 2455 tl = satComputeCDB16TL(satIOContext); 2456 2457 2458 /* Table 34, 9.1, p 46 */ 2459 /* 2460 note: As of 2/10/2006, no support for DMA QUEUED 2461 */ 2462 2463 /* 2464 Table 34, 9.1, p 46, b 2465 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 2466 return check condition 2467 */ 2468 if (pSatDevData->satNCQ != agTRUE && 2469 pSatDevData->sat48BitSupport != agTRUE 2470 ) 2471 { 2472 if (limitChk) 2473 { 2474 TI_DBG1(("satRead16: return LBA out of range, not EXT\n")); 2475 satSetSensePayload( pSense, 2476 SCSI_SNSKEY_ILLEGAL_REQUEST, 2477 0, 2478 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 2479 satIOContext); 2480 2481 ostiInitiatorIOCompleted( tiRoot, 2482 tiIORequest, 2483 tiIOSuccess, 2484 SCSI_STAT_CHECK_CONDITION, 2485 satIOContext->pTiSenseData, 2486 satIOContext->interruptContext ); 2487 2488 return tiSuccess; 2489 } 2490 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 2491 { 2492 TI_DBG1(("satRead16: return LBA+TL out of range, not EXT\n")); 2493 satSetSensePayload( pSense, 2494 SCSI_SNSKEY_ILLEGAL_REQUEST, 2495 0, 2496 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 2497 satIOContext); 2498 2499 ostiInitiatorIOCompleted( tiRoot, 2500 tiIORequest, 2501 tiIOSuccess, 2502 SCSI_STAT_CHECK_CONDITION, 2503 satIOContext->pTiSenseData, 2504 satIOContext->interruptContext ); 2505 2506 return tiSuccess; 2507 } 2508 } 2509 2510 /* case 1 and 2 */ 2511 if (!rangeChk) // if (lba + tl <= SAT_TR_LBA_LIMIT) 2512 { 2513 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 2514 { 2515 /* case 2 */ 2516 /* READ DMA*/ 2517 /* in case that we can't fit the transfer length, 2518 we need to make it fit by sending multiple ATA cmnds */ 2519 TI_DBG5(("satRead16: case 2\n")); 2520 2521 2522 fis->h.fisType = 0x27; /* Reg host to device */ 2523 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2524 fis->h.command = SAT_READ_DMA; /* 0xC8 */ 2525 fis->h.features = 0; /* FIS reserve */ 2526 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 2527 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 2528 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 2529 fis->d.device = 2530 (bit8)((0x4 << 4) | (scsiCmnd->cdb[6] & 0xF)); /* FIS LBA (27:24) and FIS LBA mode */ 2531 fis->d.lbaLowExp = 0; 2532 fis->d.lbaMidExp = 0; 2533 fis->d.lbaHighExp = 0; 2534 fis->d.featuresExp = 0; 2535 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 2536 fis->d.sectorCountExp = 0; 2537 fis->d.reserved4 = 0; 2538 fis->d.control = 0; /* FIS HOB bit clear */ 2539 fis->d.reserved5 = 0; 2540 2541 2542 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 2543 satIOContext->ATACmd = SAT_READ_DMA; 2544 } 2545 else 2546 { 2547 /* case 1 */ 2548 /* READ MULTIPLE or READ SECTOR(S) */ 2549 /* READ SECTORS for easier implemetation */ 2550 /* can't fit the transfer length but need to make it fit by sending multiple*/ 2551 TI_DBG5(("satRead16: case 1\n")); 2552 2553 fis->h.fisType = 0x27; /* Reg host to device */ 2554 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2555 fis->h.command = SAT_READ_SECTORS; /* 0x20 */ 2556 fis->h.features = 0; /* FIS reserve */ 2557 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 2558 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 2559 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 2560 fis->d.device = 2561 (bit8)((0x4 << 4) | (scsiCmnd->cdb[6] & 0xF)); /* FIS LBA (27:24) and FIS LBA mode */ 2562 fis->d.lbaLowExp = 0; 2563 fis->d.lbaMidExp = 0; 2564 fis->d.lbaHighExp = 0; 2565 fis->d.featuresExp = 0; 2566 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 2567 fis->d.sectorCountExp = 0; 2568 fis->d.reserved4 = 0; 2569 fis->d.control = 0; /* FIS HOB bit clear */ 2570 fis->d.reserved5 = 0; 2571 2572 2573 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 2574 satIOContext->ATACmd = SAT_READ_SECTORS; 2575 } 2576 } 2577 2578 /* case 3 and 4 */ 2579 if (pSatDevData->sat48BitSupport == agTRUE) 2580 { 2581 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 2582 { 2583 /* case 3 */ 2584 /* READ DMA EXT */ 2585 TI_DBG5(("satRead16: case 3\n")); 2586 fis->h.fisType = 0x27; /* Reg host to device */ 2587 2588 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2589 fis->h.command = SAT_READ_DMA_EXT; /* 0x25 */ 2590 fis->h.features = 0; /* FIS reserve */ 2591 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 2592 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 2593 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 2594 fis->d.device = 0x40; /* FIS LBA mode set */ 2595 fis->d.lbaLowExp = scsiCmnd->cdb[6]; /* FIS LBA (31:24) */ 2596 fis->d.lbaMidExp = scsiCmnd->cdb[5]; /* FIS LBA (39:32) */ 2597 fis->d.lbaHighExp = scsiCmnd->cdb[4]; /* FIS LBA (47:40) */ 2598 fis->d.featuresExp = 0; /* FIS reserve */ 2599 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 2600 fis->d.sectorCountExp = scsiCmnd->cdb[12]; /* FIS sector count (15:8) */ 2601 fis->d.reserved4 = 0; 2602 fis->d.control = 0; /* FIS HOB bit clear */ 2603 fis->d.reserved5 = 0; 2604 2605 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 2606 satIOContext->ATACmd = SAT_READ_DMA_EXT; 2607 2608 } 2609 else 2610 { 2611 /* case 4 */ 2612 /* READ MULTIPLE EXT or READ SECTOR(S) EXT or READ VERIFY SECTOR(S) EXT*/ 2613 /* READ SECTORS EXT for easier implemetation */ 2614 TI_DBG5(("satRead16: case 4\n")); 2615 fis->h.fisType = 0x27; /* Reg host to device */ 2616 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2617 2618 /* Check FUA bit */ 2619 if (scsiCmnd->cdb[1] & SCSI_READ16_FUA_MASK) 2620 { 2621 2622 /* for now, no support for FUA */ 2623 satSetSensePayload( pSense, 2624 SCSI_SNSKEY_ILLEGAL_REQUEST, 2625 0, 2626 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 2627 satIOContext); 2628 2629 ostiInitiatorIOCompleted( tiRoot, 2630 tiIORequest, 2631 tiIOSuccess, 2632 SCSI_STAT_CHECK_CONDITION, 2633 satIOContext->pTiSenseData, 2634 satIOContext->interruptContext ); 2635 return tiSuccess; 2636 } 2637 2638 fis->h.command = SAT_READ_SECTORS_EXT; /* 0x24 */ 2639 2640 fis->h.features = 0; /* FIS reserve */ 2641 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 2642 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 2643 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 2644 fis->d.device = 0x40; /* FIS LBA mode set */ 2645 fis->d.lbaLowExp = scsiCmnd->cdb[6]; /* FIS LBA (31:24) */ 2646 fis->d.lbaMidExp = scsiCmnd->cdb[5]; /* FIS LBA (39:32) */ 2647 fis->d.lbaHighExp = scsiCmnd->cdb[4]; /* FIS LBA (47:40) */ 2648 fis->d.featuresExp = 0; /* FIS reserve */ 2649 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 2650 fis->d.sectorCountExp = scsiCmnd->cdb[12]; /* FIS sector count (15:8) */ 2651 fis->d.reserved4 = 0; 2652 fis->d.control = 0; /* FIS HOB bit clear */ 2653 fis->d.reserved5 = 0; 2654 2655 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 2656 satIOContext->ATACmd = SAT_READ_SECTORS_EXT; 2657 } 2658 } 2659 2660 2661 /* case 5 */ 2662 if (pSatDevData->satNCQ == agTRUE) 2663 { 2664 /* READ FPDMA QUEUED */ 2665 if (pSatDevData->sat48BitSupport != agTRUE) 2666 { 2667 TI_DBG5(("satRead16: case 5 !!! error NCQ but 28 bit address support \n")); 2668 satSetSensePayload( pSense, 2669 SCSI_SNSKEY_ILLEGAL_REQUEST, 2670 0, 2671 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 2672 satIOContext); 2673 2674 ostiInitiatorIOCompleted( tiRoot, 2675 tiIORequest, 2676 tiIOSuccess, 2677 SCSI_STAT_CHECK_CONDITION, 2678 satIOContext->pTiSenseData, 2679 satIOContext->interruptContext ); 2680 return tiSuccess; 2681 } 2682 2683 TI_DBG6(("satRead16: case 5\n")); 2684 2685 /* Support 48-bit FPDMA addressing, use READ FPDMA QUEUE command */ 2686 2687 fis->h.fisType = 0x27; /* Reg host to device */ 2688 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2689 fis->h.command = SAT_READ_FPDMA_QUEUED; /* 0x60 */ 2690 fis->h.features = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 2691 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 2692 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 2693 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 2694 2695 /* Check FUA bit */ 2696 if (scsiCmnd->cdb[1] & SCSI_READ16_FUA_MASK) 2697 fis->d.device = 0xC0; /* FIS FUA set */ 2698 else 2699 fis->d.device = 0x40; /* FIS FUA clear */ 2700 2701 fis->d.lbaLowExp = scsiCmnd->cdb[6]; /* FIS LBA (31:24) */ 2702 fis->d.lbaMidExp = scsiCmnd->cdb[5]; /* FIS LBA (39:32) */ 2703 fis->d.lbaHighExp = scsiCmnd->cdb[4]; /* FIS LBA (47:40) */ 2704 fis->d.featuresExp = scsiCmnd->cdb[12]; /* FIS sector count (15:8) */ 2705 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 2706 fis->d.sectorCountExp = 0; 2707 fis->d.reserved4 = 0; 2708 fis->d.control = 0; /* FIS HOB bit clear */ 2709 fis->d.reserved5 = 0; 2710 2711 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_READ; 2712 satIOContext->ATACmd = SAT_READ_FPDMA_QUEUED; 2713 } 2714 2715 /* saves the current LBA and orginal TL */ 2716 satIOContext->currentLBA = lba; 2717 satIOContext->OrgTL = tl; 2718 2719 /* 2720 computing number of loop and remainder for tl 2721 0xFF in case not ext 2722 0xFFFF in case EXT 2723 */ 2724 if (fis->h.command == SAT_READ_SECTORS || fis->h.command == SAT_READ_DMA) 2725 { 2726 LoopNum = satComputeLoopNum(tl, 0xFF); 2727 } 2728 else if (fis->h.command == SAT_READ_SECTORS_EXT || fis->h.command == SAT_READ_DMA_EXT) 2729 { 2730 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 2731 LoopNum = satComputeLoopNum(tl, 0xFFFF); 2732 } 2733 else 2734 { 2735 /* SAT_READ_FPDMA_QUEUEDK */ 2736 LoopNum = satComputeLoopNum(tl, 0xFFFF); 2737 } 2738 satIOContext->LoopNum = LoopNum; 2739 2740 if (LoopNum == 1) 2741 { 2742 TI_DBG5(("satRead16: NON CHAINED data\n")); 2743 satIOContext->satCompleteCB = &satNonChainedDataIOCB; 2744 } 2745 else 2746 { 2747 TI_DBG1(("satRead16: CHAINED data\n")); 2748 /* re-setting tl */ 2749 if (fis->h.command == SAT_READ_SECTORS || fis->h.command == SAT_READ_DMA) 2750 { 2751 fis->d.sectorCount = 0xFF; 2752 } 2753 else if (fis->h.command == SAT_READ_SECTORS_EXT || fis->h.command == SAT_READ_DMA_EXT) 2754 { 2755 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 2756 fis->d.sectorCount = 0xFF; 2757 fis->d.sectorCountExp = 0xFF; 2758 } 2759 else 2760 { 2761 /* SAT_READ_FPDMA_QUEUED */ 2762 fis->h.features = 0xFF; 2763 fis->d.featuresExp = 0xFF; 2764 } 2765 2766 /* chained data */ 2767 satIOContext->satCompleteCB = &satChainedDataIOCB; 2768 } 2769 2770 /* 2771 * Prepare SGL and send FIS to LL layer. 2772 */ 2773 satIOContext->reqType = agRequestType; /* Save it */ 2774 2775 status = sataLLIOStart( tiRoot, 2776 tiIORequest, 2777 tiDeviceHandle, 2778 tiScsiRequest, 2779 satIOContext); 2780 2781 TI_DBG5(("satRead16: return\n")); 2782 return (status); 2783 2784 } 2785 2786 /*****************************************************************************/ 2787 /*! \brief SAT implementation for SCSI READ6. 2788 * 2789 * SAT implementation for SCSI READ6 and send FIS request to LL layer. 2790 * 2791 * \param tiRoot: Pointer to TISA initiator driver/port instance. 2792 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 2793 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 2794 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 2795 * \param satIOContext_t: Pointer to the SAT IO Context 2796 * 2797 * \return If command is started successfully 2798 * - \e tiSuccess: I/O request successfully initiated. 2799 * - \e tiBusy: No resources available, try again later. 2800 * - \e tiIONoDevice: Invalid device handle. 2801 * - \e tiError: Other errors. 2802 */ 2803 /*****************************************************************************/ 2804 GLOBAL bit32 satRead6( 2805 tiRoot_t *tiRoot, 2806 tiIORequest_t *tiIORequest, 2807 tiDeviceHandle_t *tiDeviceHandle, 2808 tiScsiInitiatorRequest_t *tiScsiRequest, 2809 satIOContext_t *satIOContext) 2810 { 2811 2812 bit32 status; 2813 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 2814 satDeviceData_t *pSatDevData; 2815 scsiRspSense_t *pSense; 2816 tiIniScsiCmnd_t *scsiCmnd; 2817 agsaFisRegHostToDevice_t *fis; 2818 bit32 lba = 0; 2819 bit16 tl = 0; 2820 2821 pSense = satIOContext->pSense; 2822 pSatDevData = satIOContext->pSatDevData; 2823 scsiCmnd = &tiScsiRequest->scsiCmnd; 2824 fis = satIOContext->pFis; 2825 2826 2827 TI_DBG5(("satRead6: start\n")); 2828 2829 /* no FUA checking since read6 */ 2830 2831 2832 /* checking CONTROL */ 2833 /* NACA == 1 or LINK == 1*/ 2834 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 2835 { 2836 satSetSensePayload( pSense, 2837 SCSI_SNSKEY_ILLEGAL_REQUEST, 2838 0, 2839 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 2840 satIOContext); 2841 2842 ostiInitiatorIOCompleted( tiRoot, 2843 tiIORequest, 2844 tiIOSuccess, 2845 SCSI_STAT_CHECK_CONDITION, 2846 satIOContext->pTiSenseData, 2847 satIOContext->interruptContext ); 2848 2849 TI_DBG2(("satRead6: return control\n")); 2850 return tiSuccess; 2851 } 2852 2853 /* cbd6; computing LBA and transfer length */ 2854 lba = (((scsiCmnd->cdb[1]) & 0x1f) << (8*2)) 2855 + (scsiCmnd->cdb[2] << 8) + scsiCmnd->cdb[3]; 2856 tl = scsiCmnd->cdb[4]; 2857 2858 2859 /* Table 34, 9.1, p 46 */ 2860 /* 2861 note: As of 2/10/2006, no support for DMA QUEUED 2862 */ 2863 2864 /* 2865 Table 34, 9.1, p 46, b 2866 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 2867 return check condition 2868 */ 2869 if (pSatDevData->satNCQ != agTRUE && 2870 pSatDevData->sat48BitSupport != agTRUE 2871 ) 2872 { 2873 if (lba > SAT_TR_LBA_LIMIT - 1) 2874 { 2875 satSetSensePayload( pSense, 2876 SCSI_SNSKEY_ILLEGAL_REQUEST, 2877 0, 2878 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 2879 satIOContext); 2880 2881 ostiInitiatorIOCompleted( tiRoot, 2882 tiIORequest, 2883 tiIOSuccess, 2884 SCSI_STAT_CHECK_CONDITION, 2885 satIOContext->pTiSenseData, 2886 satIOContext->interruptContext ); 2887 2888 TI_DBG1(("satRead6: return LBA out of range\n")); 2889 return tiSuccess; 2890 } 2891 } 2892 2893 /* case 1 and 2 */ 2894 if (lba + tl <= SAT_TR_LBA_LIMIT) 2895 { 2896 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 2897 { 2898 /* case 2 */ 2899 /* READ DMA*/ 2900 TI_DBG5(("satRead6: case 2\n")); 2901 2902 2903 fis->h.fisType = 0x27; /* Reg host to device */ 2904 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2905 fis->h.command = SAT_READ_DMA; /* 0xC8 */ 2906 fis->h.features = 0; /* FIS reserve */ 2907 fis->d.lbaLow = scsiCmnd->cdb[3]; /* FIS LBA (7 :0 ) */ 2908 fis->d.lbaMid = scsiCmnd->cdb[2]; /* FIS LBA (15:8 ) */ 2909 fis->d.lbaHigh = (bit8)((scsiCmnd->cdb[1]) & 0x1f); /* FIS LBA (23:16) */ 2910 fis->d.device = 0x40; /* FIS LBA mode */ 2911 fis->d.lbaLowExp = 0; 2912 fis->d.lbaMidExp = 0; 2913 fis->d.lbaHighExp = 0; 2914 fis->d.featuresExp = 0; 2915 if (tl == 0) 2916 { 2917 /* temporary fix */ 2918 fis->d.sectorCount = 0xff; /* FIS sector count (7:0) */ 2919 } 2920 else 2921 { 2922 fis->d.sectorCount = scsiCmnd->cdb[4]; /* FIS sector count (7:0) */ 2923 } 2924 fis->d.sectorCountExp = 0; 2925 fis->d.reserved4 = 0; 2926 fis->d.control = 0; /* FIS HOB bit clear */ 2927 fis->d.reserved5 = 0; 2928 2929 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 2930 } 2931 else 2932 { 2933 /* case 1 */ 2934 /* READ SECTORS for easier implemetation */ 2935 TI_DBG5(("satRead6: case 1\n")); 2936 2937 fis->h.fisType = 0x27; /* Reg host to device */ 2938 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2939 fis->h.command = SAT_READ_SECTORS; /* 0x20 */ 2940 fis->h.features = 0; /* FIS reserve */ 2941 fis->d.lbaLow = scsiCmnd->cdb[3]; /* FIS LBA (7 :0 ) */ 2942 fis->d.lbaMid = scsiCmnd->cdb[2]; /* FIS LBA (15:8 ) */ 2943 fis->d.lbaHigh = (bit8)((scsiCmnd->cdb[1]) & 0x1f); /* FIS LBA (23:16) */ 2944 fis->d.device = 0x40; /* FIS LBA mode */ 2945 fis->d.lbaLowExp = 0; 2946 fis->d.lbaMidExp = 0; 2947 fis->d.lbaHighExp = 0; 2948 fis->d.featuresExp = 0; 2949 if (tl == 0) 2950 { 2951 /* temporary fix */ 2952 fis->d.sectorCount = 0xff; /* FIS sector count (7:0) */ 2953 } 2954 else 2955 { 2956 fis->d.sectorCount = scsiCmnd->cdb[4]; /* FIS sector count (7:0) */ 2957 } 2958 fis->d.sectorCountExp = 0; 2959 fis->d.reserved4 = 0; 2960 fis->d.control = 0; /* FIS HOB bit clear */ 2961 fis->d.reserved5 = 0; 2962 2963 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 2964 2965 } 2966 } 2967 2968 /* case 3 and 4 */ 2969 if (pSatDevData->sat48BitSupport == agTRUE) 2970 { 2971 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 2972 { 2973 /* case 3 */ 2974 /* READ DMA EXT only */ 2975 TI_DBG5(("satRead6: case 3\n")); 2976 fis->h.fisType = 0x27; /* Reg host to device */ 2977 fis->h.c_pmPort = 0x80; /* C Bit is set */ 2978 fis->h.command = SAT_READ_DMA_EXT; /* 0x25 */ 2979 fis->h.features = 0; /* FIS reserve */ 2980 fis->d.lbaLow = scsiCmnd->cdb[3]; /* FIS LBA (7 :0 ) */ 2981 fis->d.lbaMid = scsiCmnd->cdb[2]; /* FIS LBA (15:8 ) */ 2982 fis->d.lbaHigh = (bit8)((scsiCmnd->cdb[1]) & 0x1f); /* FIS LBA (23:16) */ 2983 fis->d.device = 0x40; /* FIS LBA mode set */ 2984 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 2985 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 2986 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 2987 fis->d.featuresExp = 0; /* FIS reserve */ 2988 if (tl == 0) 2989 { 2990 /* sector count is 256, 0x100*/ 2991 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 2992 fis->d.sectorCountExp = 0x01; /* FIS sector count (15:8) */ 2993 } 2994 else 2995 { 2996 fis->d.sectorCount = scsiCmnd->cdb[4]; /* FIS sector count (7:0) */ 2997 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 2998 } 2999 fis->d.reserved4 = 0; 3000 fis->d.control = 0; /* FIS HOB bit clear */ 3001 fis->d.reserved5 = 0; 3002 3003 agRequestType = AGSA_SATA_PROTOCOL_DMA_READ; 3004 } 3005 else 3006 { 3007 /* case 4 */ 3008 /* READ SECTORS EXT for easier implemetation */ 3009 TI_DBG5(("satRead6: case 4\n")); 3010 3011 fis->h.fisType = 0x27; /* Reg host to device */ 3012 fis->h.c_pmPort = 0x80; /* C Bit is set */ 3013 fis->h.command = SAT_READ_SECTORS_EXT; /* 0x24 */ 3014 fis->h.features = 0; /* FIS reserve */ 3015 fis->d.lbaLow = scsiCmnd->cdb[3]; /* FIS LBA (7 :0 ) */ 3016 fis->d.lbaMid = scsiCmnd->cdb[2]; /* FIS LBA (15:8 ) */ 3017 fis->d.lbaHigh = (bit8)((scsiCmnd->cdb[1]) & 0x1f); /* FIS LBA (23:16) */ 3018 fis->d.device = 0x40; /* FIS LBA mode set */ 3019 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 3020 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 3021 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 3022 fis->d.featuresExp = 0; /* FIS reserve */ 3023 if (tl == 0) 3024 { 3025 /* sector count is 256, 0x100*/ 3026 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 3027 fis->d.sectorCountExp = 0x01; /* FIS sector count (15:8) */ 3028 } 3029 else 3030 { 3031 fis->d.sectorCount = scsiCmnd->cdb[4]; /* FIS sector count (7:0) */ 3032 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 3033 } 3034 fis->d.reserved4 = 0; 3035 fis->d.control = 0; /* FIS HOB bit clear */ 3036 fis->d.reserved5 = 0; 3037 3038 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 3039 } 3040 } 3041 3042 /* case 5 */ 3043 if (pSatDevData->satNCQ == agTRUE) 3044 { 3045 /* READ FPDMA QUEUED */ 3046 if (pSatDevData->sat48BitSupport != agTRUE) 3047 { 3048 /* sanity check */ 3049 TI_DBG5(("satRead6: case 5 !!! error NCQ but 28 bit address support \n")); 3050 satSetSensePayload( pSense, 3051 SCSI_SNSKEY_ILLEGAL_REQUEST, 3052 0, 3053 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 3054 satIOContext); 3055 3056 ostiInitiatorIOCompleted( tiRoot, 3057 tiIORequest, 3058 tiIOSuccess, 3059 SCSI_STAT_CHECK_CONDITION, 3060 satIOContext->pTiSenseData, 3061 satIOContext->interruptContext ); 3062 return tiSuccess; 3063 } 3064 TI_DBG5(("satRead6: case 5\n")); 3065 3066 /* Support 48-bit FPDMA addressing, use READ FPDMA QUEUE command */ 3067 3068 fis->h.fisType = 0x27; /* Reg host to device */ 3069 fis->h.c_pmPort = 0x80; /* C Bit is set */ 3070 fis->h.command = SAT_READ_FPDMA_QUEUED; /* 0x60 */ 3071 fis->d.lbaLow = scsiCmnd->cdb[3]; /* FIS LBA (7 :0 ) */ 3072 fis->d.lbaMid = scsiCmnd->cdb[2]; /* FIS LBA (15:8 ) */ 3073 fis->d.lbaHigh = (bit8)((scsiCmnd->cdb[1]) & 0x1f); /* FIS LBA (23:16) */ 3074 fis->d.device = 0x40; /* FIS FUA clear */ 3075 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 3076 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 3077 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 3078 if (tl == 0) 3079 { 3080 /* sector count is 256, 0x100*/ 3081 fis->h.features = 0; /* FIS sector count (7:0) */ 3082 fis->d.featuresExp = 0x01; /* FIS sector count (15:8) */ 3083 } 3084 else 3085 { 3086 fis->h.features = scsiCmnd->cdb[4]; /* FIS sector count (7:0) */ 3087 fis->d.featuresExp = 0; /* FIS sector count (15:8) */ 3088 } 3089 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 3090 fis->d.sectorCountExp = 0; 3091 fis->d.reserved4 = 0; 3092 fis->d.control = 0; /* FIS HOB bit clear */ 3093 fis->d.reserved5 = 0; 3094 3095 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_READ; 3096 } 3097 3098 /* Initialize CB for SATA completion. 3099 */ 3100 satIOContext->satCompleteCB = &satNonChainedDataIOCB; 3101 3102 /* 3103 * Prepare SGL and send FIS to LL layer. 3104 */ 3105 satIOContext->reqType = agRequestType; /* Save it */ 3106 3107 status = sataLLIOStart( tiRoot, 3108 tiIORequest, 3109 tiDeviceHandle, 3110 tiScsiRequest, 3111 satIOContext); 3112 return (status); 3113 3114 } 3115 3116 /*****************************************************************************/ 3117 /*! \brief SAT implementation for SCSI WRITE16. 3118 * 3119 * SAT implementation for SCSI WRITE16 and send FIS request to LL layer. 3120 * 3121 * \param tiRoot: Pointer to TISA initiator driver/port instance. 3122 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 3123 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 3124 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 3125 * \param satIOContext_t: Pointer to the SAT IO Context 3126 * 3127 * \return If command is started successfully 3128 * - \e tiSuccess: I/O request successfully initiated. 3129 * - \e tiBusy: No resources available, try again later. 3130 * - \e tiIONoDevice: Invalid device handle. 3131 * - \e tiError: Other errors. 3132 */ 3133 /*****************************************************************************/ 3134 GLOBAL bit32 satWrite16( 3135 tiRoot_t *tiRoot, 3136 tiIORequest_t *tiIORequest, 3137 tiDeviceHandle_t *tiDeviceHandle, 3138 tiScsiInitiatorRequest_t *tiScsiRequest, 3139 satIOContext_t *satIOContext) 3140 { 3141 bit32 status; 3142 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 3143 satDeviceData_t *pSatDevData; 3144 scsiRspSense_t *pSense; 3145 tiIniScsiCmnd_t *scsiCmnd; 3146 agsaFisRegHostToDevice_t *fis; 3147 bit32 lba = 0; 3148 bit32 tl = 0; 3149 bit32 LoopNum = 1; 3150 bit8 LBA[8]; 3151 bit8 TL[8]; 3152 bit32 rangeChk = agFALSE; /* lba and tl range check */ 3153 bit32 limitChk = agFALSE; /* lba and tl range check */ 3154 3155 pSense = satIOContext->pSense; 3156 pSatDevData = satIOContext->pSatDevData; 3157 scsiCmnd = &tiScsiRequest->scsiCmnd; 3158 fis = satIOContext->pFis; 3159 3160 TI_DBG5(("satWrite16: start\n")); 3161 3162 /* checking FUA_NV */ 3163 if (scsiCmnd->cdb[1] & SCSI_FUA_NV_MASK) 3164 { 3165 satSetSensePayload( pSense, 3166 SCSI_SNSKEY_ILLEGAL_REQUEST, 3167 0, 3168 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 3169 satIOContext); 3170 3171 ostiInitiatorIOCompleted( tiRoot, 3172 tiIORequest, 3173 tiIOSuccess, 3174 SCSI_STAT_CHECK_CONDITION, 3175 satIOContext->pTiSenseData, 3176 satIOContext->interruptContext ); 3177 3178 TI_DBG1(("satWrite16: return FUA_NV\n")); 3179 return tiSuccess; 3180 3181 } 3182 3183 /* checking CONTROL */ 3184 /* NACA == 1 or LINK == 1*/ 3185 if ( (scsiCmnd->cdb[15] & SCSI_NACA_MASK) || (scsiCmnd->cdb[15] & SCSI_LINK_MASK) ) 3186 { 3187 satSetSensePayload( pSense, 3188 SCSI_SNSKEY_ILLEGAL_REQUEST, 3189 0, 3190 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 3191 satIOContext); 3192 3193 ostiInitiatorIOCompleted( tiRoot, 3194 tiIORequest, 3195 tiIOSuccess, 3196 SCSI_STAT_CHECK_CONDITION, 3197 satIOContext->pTiSenseData, 3198 satIOContext->interruptContext ); 3199 3200 TI_DBG1(("satWrite16: return control\n")); 3201 return tiSuccess; 3202 } 3203 3204 3205 osti_memset(LBA, 0, sizeof(LBA)); 3206 osti_memset(TL, 0, sizeof(TL)); 3207 3208 3209 /* do not use memcpy due to indexing in LBA and TL */ 3210 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 3211 LBA[1] = scsiCmnd->cdb[3]; 3212 LBA[2] = scsiCmnd->cdb[4]; 3213 LBA[3] = scsiCmnd->cdb[5]; 3214 LBA[4] = scsiCmnd->cdb[6]; 3215 LBA[5] = scsiCmnd->cdb[7]; 3216 LBA[6] = scsiCmnd->cdb[8]; 3217 LBA[7] = scsiCmnd->cdb[9]; /* LSB */ 3218 3219 TL[0] = 0; 3220 TL[1] = 0; 3221 TL[2] = 0; 3222 TL[3] = 0; 3223 TL[4] = scsiCmnd->cdb[10]; /* MSB */ 3224 TL[5] = scsiCmnd->cdb[11]; 3225 TL[6] = scsiCmnd->cdb[12]; 3226 TL[7] = scsiCmnd->cdb[13]; /* LSB */ 3227 3228 rangeChk = satAddNComparebit64(LBA, TL); 3229 3230 limitChk = satCompareLBALimitbit(LBA); 3231 3232 lba = satComputeCDB16LBA(satIOContext); 3233 tl = satComputeCDB16TL(satIOContext); 3234 3235 3236 3237 /* Table 34, 9.1, p 46 */ 3238 /* 3239 note: As of 2/10/2006, no support for DMA QUEUED 3240 */ 3241 3242 /* 3243 Table 34, 9.1, p 46, b 3244 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 3245 return check condition 3246 */ 3247 if (pSatDevData->satNCQ != agTRUE && 3248 pSatDevData->sat48BitSupport != agTRUE 3249 ) 3250 { 3251 if (limitChk) 3252 { 3253 TI_DBG1(("satWrite16: return LBA out of range, not EXT\n")); 3254 satSetSensePayload( pSense, 3255 SCSI_SNSKEY_ILLEGAL_REQUEST, 3256 0, 3257 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 3258 satIOContext); 3259 3260 ostiInitiatorIOCompleted( tiRoot, 3261 tiIORequest, 3262 tiIOSuccess, 3263 SCSI_STAT_CHECK_CONDITION, 3264 satIOContext->pTiSenseData, 3265 satIOContext->interruptContext ); 3266 3267 return tiSuccess; 3268 } 3269 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 3270 { 3271 TI_DBG1(("satWrite16: return LBA+TL out of range, not EXT\n")); 3272 satSetSensePayload( pSense, 3273 SCSI_SNSKEY_ILLEGAL_REQUEST, 3274 0, 3275 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 3276 satIOContext); 3277 3278 ostiInitiatorIOCompleted( tiRoot, 3279 tiIORequest, 3280 tiIOSuccess, 3281 SCSI_STAT_CHECK_CONDITION, 3282 satIOContext->pTiSenseData, 3283 satIOContext->interruptContext ); 3284 3285 return tiSuccess; 3286 } 3287 } 3288 3289 /* case 1 and 2 */ 3290 if (!rangeChk) // if (lba + tl <= SAT_TR_LBA_LIMIT) 3291 { 3292 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 3293 { 3294 /* case 2 */ 3295 /* WRITE DMA*/ 3296 /* In case that we can't fit the transfer length, we loop */ 3297 TI_DBG5(("satWrite16: case 2\n")); 3298 fis->h.fisType = 0x27; /* Reg host to device */ 3299 fis->h.c_pmPort = 0x80; /* C bit is set */ 3300 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 3301 fis->h.features = 0; /* FIS reserve */ 3302 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 3303 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 3304 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 3305 3306 /* FIS LBA mode set LBA (27:24) */ 3307 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[6] & 0xF)); 3308 3309 fis->d.lbaLowExp = 0; 3310 fis->d.lbaMidExp = 0; 3311 fis->d.lbaHighExp = 0; 3312 fis->d.featuresExp = 0; 3313 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 3314 fis->d.sectorCountExp = 0; 3315 fis->d.reserved4 = 0; 3316 fis->d.control = 0; /* FIS HOB bit clear */ 3317 fis->d.reserved5 = 0; 3318 3319 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 3320 satIOContext->ATACmd = SAT_WRITE_DMA; 3321 } 3322 else 3323 { 3324 /* case 1 */ 3325 /* WRITE MULTIPLE or WRITE SECTOR(S) */ 3326 /* WRITE SECTORS for easier implemetation */ 3327 /* In case that we can't fit the transfer length, we loop */ 3328 TI_DBG5(("satWrite16: case 1\n")); 3329 fis->h.fisType = 0x27; /* Reg host to device */ 3330 fis->h.c_pmPort = 0x80; /* C bit is set */ 3331 fis->h.command = SAT_WRITE_SECTORS; /* 0x30 */ 3332 fis->h.features = 0; /* FIS reserve */ 3333 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 3334 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 3335 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 3336 3337 /* FIS LBA mode set LBA (27:24) */ 3338 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[6] & 0xF)); 3339 3340 fis->d.lbaLowExp = 0; 3341 fis->d.lbaMidExp = 0; 3342 fis->d.lbaHighExp = 0; 3343 fis->d.featuresExp = 0; 3344 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 3345 fis->d.sectorCountExp = 0; 3346 fis->d.reserved4 = 0; 3347 fis->d.control = 0; /* FIS HOB bit clear */ 3348 fis->d.reserved5 = 0; 3349 3350 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 3351 satIOContext->ATACmd = SAT_WRITE_SECTORS; 3352 } 3353 } 3354 3355 /* case 3 and 4 */ 3356 if (pSatDevData->sat48BitSupport == agTRUE) 3357 { 3358 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 3359 { 3360 /* case 3 */ 3361 /* WRITE DMA EXT or WRITE DMA FUA EXT */ 3362 TI_DBG5(("satWrite16: case 3\n")); 3363 fis->h.fisType = 0x27; /* Reg host to device */ 3364 fis->h.c_pmPort = 0x80; /* C Bit is set */ 3365 3366 /* SAT_WRITE_DMA_FUA_EXT is optional and we don't support it */ 3367 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 3368 3369 fis->h.features = 0; /* FIS reserve */ 3370 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 3371 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 3372 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 3373 fis->d.device = 0x40; /* FIS LBA mode set */ 3374 fis->d.lbaLowExp = scsiCmnd->cdb[6]; /* FIS LBA (31:24) */ 3375 fis->d.lbaMidExp = scsiCmnd->cdb[5]; /* FIS LBA (39:32) */ 3376 fis->d.lbaHighExp = scsiCmnd->cdb[4]; /* FIS LBA (47:40) */ 3377 fis->d.featuresExp = 0; /* FIS reserve */ 3378 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 3379 fis->d.sectorCountExp = scsiCmnd->cdb[12]; /* FIS sector count (15:8) */ 3380 fis->d.reserved4 = 0; 3381 fis->d.control = 0; /* FIS HOB bit clear */ 3382 fis->d.reserved5 = 0; 3383 3384 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 3385 satIOContext->ATACmd = SAT_WRITE_DMA_EXT; 3386 } 3387 else 3388 { 3389 /* case 4 */ 3390 /* WRITE MULTIPLE EXT or WRITE MULTIPLE FUA EXT or WRITE SECTOR(S) EXT */ 3391 /* WRITE SECTORS EXT for easier implemetation */ 3392 TI_DBG5(("satWrite16: case 4\n")); 3393 fis->h.fisType = 0x27; /* Reg host to device */ 3394 fis->h.c_pmPort = 0x80; /* C Bit is set */ 3395 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 3396 3397 fis->h.features = 0; /* FIS reserve */ 3398 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 3399 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 3400 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 3401 fis->d.device = 0x40; /* FIS LBA mode set */ 3402 fis->d.lbaLowExp = scsiCmnd->cdb[6]; /* FIS LBA (31:24) */ 3403 fis->d.lbaMidExp = scsiCmnd->cdb[5]; /* FIS LBA (39:32) */ 3404 fis->d.lbaHighExp = scsiCmnd->cdb[4]; /* FIS LBA (47:40) */ 3405 fis->d.featuresExp = 0; /* FIS reserve */ 3406 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 3407 fis->d.sectorCountExp = scsiCmnd->cdb[12]; /* FIS sector count (15:8) */ 3408 fis->d.reserved4 = 0; 3409 fis->d.control = 0; /* FIS HOB bit clear */ 3410 fis->d.reserved5 = 0; 3411 3412 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 3413 satIOContext->ATACmd = SAT_WRITE_SECTORS_EXT; 3414 } 3415 } 3416 3417 /* case 5 */ 3418 if (pSatDevData->satNCQ == agTRUE) 3419 { 3420 /* WRITE FPDMA QUEUED */ 3421 if (pSatDevData->sat48BitSupport != agTRUE) 3422 { 3423 TI_DBG5(("satWrite16: case 5 !!! error NCQ but 28 bit address support \n")); 3424 satSetSensePayload( pSense, 3425 SCSI_SNSKEY_ILLEGAL_REQUEST, 3426 0, 3427 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 3428 satIOContext); 3429 3430 ostiInitiatorIOCompleted( tiRoot, 3431 tiIORequest, 3432 tiIOSuccess, 3433 SCSI_STAT_CHECK_CONDITION, 3434 satIOContext->pTiSenseData, 3435 satIOContext->interruptContext ); 3436 return tiSuccess; 3437 } 3438 TI_DBG6(("satWrite16: case 5\n")); 3439 3440 /* Support 48-bit FPDMA addressing, use WRITE FPDMA QUEUE command */ 3441 3442 fis->h.fisType = 0x27; /* Reg host to device */ 3443 fis->h.c_pmPort = 0x80; /* C Bit is set */ 3444 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 3445 fis->h.features = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 3446 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 3447 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 3448 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 3449 3450 /* Check FUA bit */ 3451 if (scsiCmnd->cdb[1] & SCSI_WRITE16_FUA_MASK) 3452 fis->d.device = 0xC0; /* FIS FUA set */ 3453 else 3454 fis->d.device = 0x40; /* FIS FUA clear */ 3455 3456 fis->d.lbaLowExp = scsiCmnd->cdb[6]; /* FIS LBA (31:24) */ 3457 fis->d.lbaMidExp = scsiCmnd->cdb[5]; /* FIS LBA (39:32) */ 3458 fis->d.lbaHighExp = scsiCmnd->cdb[4]; /* FIS LBA (47:40) */ 3459 fis->d.featuresExp = scsiCmnd->cdb[12]; /* FIS sector count (15:8) */ 3460 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 3461 fis->d.sectorCountExp = 0; 3462 fis->d.reserved4 = 0; 3463 fis->d.control = 0; /* FIS HOB bit clear */ 3464 fis->d.reserved5 = 0; 3465 3466 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 3467 satIOContext->ATACmd = SAT_WRITE_FPDMA_QUEUED; 3468 } 3469 3470 satIOContext->currentLBA = lba; 3471 satIOContext->OrgTL = tl; 3472 3473 /* 3474 computing number of loop and remainder for tl 3475 0xFF in case not ext 3476 0xFFFF in case EXT 3477 */ 3478 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 3479 { 3480 LoopNum = satComputeLoopNum(tl, 0xFF); 3481 } 3482 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 3483 fis->h.command == SAT_WRITE_DMA_EXT || 3484 fis->h.command == SAT_WRITE_DMA_FUA_EXT 3485 ) 3486 { 3487 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 3488 LoopNum = satComputeLoopNum(tl, 0xFFFF); 3489 } 3490 else 3491 { 3492 /* SAT_WRITE_FPDMA_QUEUEDK */ 3493 LoopNum = satComputeLoopNum(tl, 0xFFFF); 3494 } 3495 3496 satIOContext->LoopNum = LoopNum; 3497 3498 3499 if (LoopNum == 1) 3500 { 3501 TI_DBG5(("satWrite16: NON CHAINED data\n")); 3502 /* Initialize CB for SATA completion. 3503 */ 3504 satIOContext->satCompleteCB = &satNonChainedDataIOCB; 3505 } 3506 else 3507 { 3508 TI_DBG1(("satWrite16: CHAINED data\n")); 3509 /* re-setting tl */ 3510 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 3511 { 3512 fis->d.sectorCount = 0xFF; 3513 } 3514 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 3515 fis->h.command == SAT_WRITE_DMA_EXT || 3516 fis->h.command == SAT_WRITE_DMA_FUA_EXT 3517 ) 3518 { 3519 fis->d.sectorCount = 0xFF; 3520 fis->d.sectorCountExp = 0xFF; 3521 } 3522 else 3523 { 3524 /* SAT_WRITE_FPDMA_QUEUED */ 3525 fis->h.features = 0xFF; 3526 fis->d.featuresExp = 0xFF; 3527 } 3528 3529 /* Initialize CB for SATA completion. 3530 */ 3531 satIOContext->satCompleteCB = &satChainedDataIOCB; 3532 } 3533 3534 3535 /* 3536 * Prepare SGL and send FIS to LL layer. 3537 */ 3538 satIOContext->reqType = agRequestType; /* Save it */ 3539 3540 status = sataLLIOStart( tiRoot, 3541 tiIORequest, 3542 tiDeviceHandle, 3543 tiScsiRequest, 3544 satIOContext); 3545 return (status); 3546 } 3547 3548 /*****************************************************************************/ 3549 /*! \brief SAT implementation for SCSI WRITE12. 3550 * 3551 * SAT implementation for SCSI WRITE12 and send FIS request to LL layer. 3552 * 3553 * \param tiRoot: Pointer to TISA initiator driver/port instance. 3554 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 3555 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 3556 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 3557 * \param satIOContext_t: Pointer to the SAT IO Context 3558 * 3559 * \return If command is started successfully 3560 * - \e tiSuccess: I/O request successfully initiated. 3561 * - \e tiBusy: No resources available, try again later. 3562 * - \e tiIONoDevice: Invalid device handle. 3563 * - \e tiError: Other errors. 3564 */ 3565 /*****************************************************************************/ 3566 GLOBAL bit32 satWrite12( 3567 tiRoot_t *tiRoot, 3568 tiIORequest_t *tiIORequest, 3569 tiDeviceHandle_t *tiDeviceHandle, 3570 tiScsiInitiatorRequest_t *tiScsiRequest, 3571 satIOContext_t *satIOContext) 3572 { 3573 bit32 status; 3574 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 3575 satDeviceData_t *pSatDevData; 3576 scsiRspSense_t *pSense; 3577 tiIniScsiCmnd_t *scsiCmnd; 3578 agsaFisRegHostToDevice_t *fis; 3579 bit32 lba = 0; 3580 bit32 tl = 0; 3581 bit32 LoopNum = 1; 3582 bit8 LBA[4]; 3583 bit8 TL[4]; 3584 bit32 rangeChk = agFALSE; /* lba and tl range check */ 3585 3586 pSense = satIOContext->pSense; 3587 pSatDevData = satIOContext->pSatDevData; 3588 scsiCmnd = &tiScsiRequest->scsiCmnd; 3589 fis = satIOContext->pFis; 3590 3591 TI_DBG5(("satWrite12: start\n")); 3592 3593 /* checking FUA_NV */ 3594 if (scsiCmnd->cdb[1] & SCSI_FUA_NV_MASK) 3595 { 3596 satSetSensePayload( pSense, 3597 SCSI_SNSKEY_ILLEGAL_REQUEST, 3598 0, 3599 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 3600 satIOContext); 3601 3602 ostiInitiatorIOCompleted( tiRoot, 3603 tiIORequest, 3604 tiIOSuccess, 3605 SCSI_STAT_CHECK_CONDITION, 3606 satIOContext->pTiSenseData, 3607 satIOContext->interruptContext ); 3608 3609 TI_DBG1(("satWrite12: return FUA_NV\n")); 3610 return tiSuccess; 3611 3612 } 3613 3614 3615 /* checking CONTROL */ 3616 /* NACA == 1 or LINK == 1*/ 3617 if ( (scsiCmnd->cdb[11] & SCSI_NACA_MASK) || (scsiCmnd->cdb[11] & SCSI_LINK_MASK) ) 3618 { 3619 satSetSensePayload( pSense, 3620 SCSI_SNSKEY_ILLEGAL_REQUEST, 3621 0, 3622 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 3623 satIOContext); 3624 3625 ostiInitiatorIOCompleted( tiRoot, 3626 tiIORequest, 3627 tiIOSuccess, 3628 SCSI_STAT_CHECK_CONDITION, 3629 satIOContext->pTiSenseData, 3630 satIOContext->interruptContext ); 3631 3632 TI_DBG1(("satWrite12: return control\n")); 3633 return tiSuccess; 3634 } 3635 3636 3637 osti_memset(LBA, 0, sizeof(LBA)); 3638 osti_memset(TL, 0, sizeof(TL)); 3639 3640 /* do not use memcpy due to indexing in LBA and TL */ 3641 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 3642 LBA[1] = scsiCmnd->cdb[3]; 3643 LBA[2] = scsiCmnd->cdb[4]; 3644 LBA[3] = scsiCmnd->cdb[5]; /* LSB */ 3645 3646 TL[0] = scsiCmnd->cdb[6]; /* MSB */ 3647 TL[1] = scsiCmnd->cdb[7]; 3648 TL[2] = scsiCmnd->cdb[8]; 3649 TL[3] = scsiCmnd->cdb[9]; /* LSB */ 3650 3651 rangeChk = satAddNComparebit32(LBA, TL); 3652 3653 lba = satComputeCDB12LBA(satIOContext); 3654 tl = satComputeCDB12TL(satIOContext); 3655 3656 3657 /* Table 34, 9.1, p 46 */ 3658 /* 3659 note: As of 2/10/2006, no support for DMA QUEUED 3660 */ 3661 3662 /* 3663 Table 34, 9.1, p 46, b 3664 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 3665 return check condition 3666 */ 3667 if (pSatDevData->satNCQ != agTRUE && 3668 pSatDevData->sat48BitSupport != agTRUE 3669 ) 3670 { 3671 if (lba > SAT_TR_LBA_LIMIT - 1) 3672 { 3673 satSetSensePayload( pSense, 3674 SCSI_SNSKEY_ILLEGAL_REQUEST, 3675 0, 3676 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 3677 satIOContext); 3678 3679 ostiInitiatorIOCompleted( tiRoot, 3680 tiIORequest, 3681 tiIOSuccess, 3682 SCSI_STAT_CHECK_CONDITION, 3683 satIOContext->pTiSenseData, 3684 satIOContext->interruptContext ); 3685 3686 TI_DBG1(("satWrite12: return LBA out of range, not EXT\n")); 3687 return tiSuccess; 3688 } 3689 3690 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 3691 { 3692 TI_DBG1(("satWrite12: return LBA+TL out of range, not EXT\n")); 3693 satSetSensePayload( pSense, 3694 SCSI_SNSKEY_ILLEGAL_REQUEST, 3695 0, 3696 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 3697 satIOContext); 3698 3699 ostiInitiatorIOCompleted( tiRoot, 3700 tiIORequest, 3701 tiIOSuccess, 3702 SCSI_STAT_CHECK_CONDITION, 3703 satIOContext->pTiSenseData, 3704 satIOContext->interruptContext ); 3705 3706 return tiSuccess; 3707 } 3708 } 3709 3710 3711 /* case 1 and 2 */ 3712 if (!rangeChk) // if (lba + tl <= SAT_TR_LBA_LIMIT) 3713 { 3714 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 3715 { 3716 /* case 2 */ 3717 /* WRITE DMA*/ 3718 /* In case that we can't fit the transfer length, we loop */ 3719 TI_DBG5(("satWrite12: case 2\n")); 3720 fis->h.fisType = 0x27; /* Reg host to device */ 3721 fis->h.c_pmPort = 0x80; /* C bit is set */ 3722 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 3723 fis->h.features = 0; /* FIS reserve */ 3724 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 3725 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 3726 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 3727 3728 /* FIS LBA mode set LBA (27:24) */ 3729 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 3730 3731 fis->d.lbaLowExp = 0; 3732 fis->d.lbaMidExp = 0; 3733 fis->d.lbaHighExp = 0; 3734 fis->d.featuresExp = 0; 3735 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 3736 fis->d.sectorCountExp = 0; 3737 fis->d.reserved4 = 0; 3738 fis->d.control = 0; /* FIS HOB bit clear */ 3739 fis->d.reserved5 = 0; 3740 3741 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 3742 satIOContext->ATACmd = SAT_WRITE_DMA; 3743 } 3744 else 3745 { 3746 /* case 1 */ 3747 /* WRITE MULTIPLE or WRITE SECTOR(S) */ 3748 /* WRITE SECTORS for easier implemetation */ 3749 /* In case that we can't fit the transfer length, we loop */ 3750 TI_DBG5(("satWrite12: case 1\n")); 3751 fis->h.fisType = 0x27; /* Reg host to device */ 3752 fis->h.c_pmPort = 0x80; /* C bit is set */ 3753 fis->h.command = SAT_WRITE_SECTORS; /* 0x30 */ 3754 fis->h.features = 0; /* FIS reserve */ 3755 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 3756 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 3757 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 3758 3759 /* FIS LBA mode set LBA (27:24) */ 3760 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 3761 3762 fis->d.lbaLowExp = 0; 3763 fis->d.lbaMidExp = 0; 3764 fis->d.lbaHighExp = 0; 3765 fis->d.featuresExp = 0; 3766 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 3767 fis->d.sectorCountExp = 0; 3768 fis->d.reserved4 = 0; 3769 fis->d.control = 0; /* FIS HOB bit clear */ 3770 fis->d.reserved5 = 0; 3771 3772 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 3773 satIOContext->ATACmd = SAT_WRITE_SECTORS; 3774 } 3775 } 3776 3777 /* case 3 and 4 */ 3778 if (pSatDevData->sat48BitSupport == agTRUE) 3779 { 3780 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 3781 { 3782 /* case 3 */ 3783 /* WRITE DMA EXT or WRITE DMA FUA EXT */ 3784 TI_DBG5(("satWrite12: case 3\n")); 3785 fis->h.fisType = 0x27; /* Reg host to device */ 3786 fis->h.c_pmPort = 0x80; /* C Bit is set */ 3787 3788 /* SAT_WRITE_DMA_FUA_EXT is optional and we don't support it */ 3789 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 3790 3791 fis->h.features = 0; /* FIS reserve */ 3792 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 3793 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 3794 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 3795 fis->d.device = 0x40; /* FIS LBA mode set */ 3796 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 3797 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 3798 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 3799 fis->d.featuresExp = 0; /* FIS reserve */ 3800 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 3801 fis->d.sectorCountExp = scsiCmnd->cdb[8]; /* FIS sector count (15:8) */ 3802 fis->d.reserved4 = 0; 3803 fis->d.control = 0; /* FIS HOB bit clear */ 3804 fis->d.reserved5 = 0; 3805 3806 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 3807 satIOContext->ATACmd = SAT_WRITE_DMA_EXT; 3808 } 3809 else 3810 { 3811 /* case 4 */ 3812 /* WRITE MULTIPLE EXT or WRITE MULTIPLE FUA EXT or WRITE SECTOR(S) EXT */ 3813 /* WRITE SECTORS EXT for easier implemetation */ 3814 TI_DBG5(("satWrite12: case 4\n")); 3815 fis->h.fisType = 0x27; /* Reg host to device */ 3816 fis->h.c_pmPort = 0x80; /* C Bit is set */ 3817 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 3818 3819 fis->h.features = 0; /* FIS reserve */ 3820 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 3821 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 3822 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 3823 fis->d.device = 0x40; /* FIS LBA mode set */ 3824 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 3825 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 3826 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 3827 fis->d.featuresExp = 0; /* FIS reserve */ 3828 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 3829 fis->d.sectorCountExp = scsiCmnd->cdb[8]; /* FIS sector count (15:8) */ 3830 fis->d.reserved4 = 0; 3831 fis->d.control = 0; /* FIS HOB bit clear */ 3832 fis->d.reserved5 = 0; 3833 3834 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 3835 satIOContext->ATACmd = SAT_WRITE_SECTORS_EXT; 3836 } 3837 } 3838 3839 /* case 5 */ 3840 if (pSatDevData->satNCQ == agTRUE) 3841 { 3842 /* WRITE FPDMA QUEUED */ 3843 if (pSatDevData->sat48BitSupport != agTRUE) 3844 { 3845 TI_DBG5(("satWrite12: case 5 !!! error NCQ but 28 bit address support \n")); 3846 satSetSensePayload( pSense, 3847 SCSI_SNSKEY_ILLEGAL_REQUEST, 3848 0, 3849 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 3850 satIOContext); 3851 3852 ostiInitiatorIOCompleted( tiRoot, 3853 tiIORequest, 3854 tiIOSuccess, 3855 SCSI_STAT_CHECK_CONDITION, 3856 satIOContext->pTiSenseData, 3857 satIOContext->interruptContext ); 3858 return tiSuccess; 3859 } 3860 TI_DBG6(("satWrite12: case 5\n")); 3861 3862 /* Support 48-bit FPDMA addressing, use WRITE FPDMA QUEUE command */ 3863 3864 fis->h.fisType = 0x27; /* Reg host to device */ 3865 fis->h.c_pmPort = 0x80; /* C Bit is set */ 3866 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 3867 fis->h.features = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 3868 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 3869 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 3870 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 3871 3872 /* Check FUA bit */ 3873 if (scsiCmnd->cdb[1] & SCSI_WRITE12_FUA_MASK) 3874 fis->d.device = 0xC0; /* FIS FUA set */ 3875 else 3876 fis->d.device = 0x40; /* FIS FUA clear */ 3877 3878 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 3879 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 3880 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 3881 fis->d.featuresExp = scsiCmnd->cdb[8]; /* FIS sector count (15:8) */ 3882 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 3883 fis->d.sectorCountExp = 0; 3884 fis->d.reserved4 = 0; 3885 fis->d.control = 0; /* FIS HOB bit clear */ 3886 fis->d.reserved5 = 0; 3887 3888 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 3889 satIOContext->ATACmd = SAT_WRITE_FPDMA_QUEUED; 3890 } 3891 3892 satIOContext->currentLBA = lba; 3893 satIOContext->OrgTL = tl; 3894 3895 /* 3896 computing number of loop and remainder for tl 3897 0xFF in case not ext 3898 0xFFFF in case EXT 3899 */ 3900 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 3901 { 3902 LoopNum = satComputeLoopNum(tl, 0xFF); 3903 } 3904 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 3905 fis->h.command == SAT_WRITE_DMA_EXT || 3906 fis->h.command == SAT_WRITE_DMA_FUA_EXT 3907 ) 3908 { 3909 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 3910 LoopNum = satComputeLoopNum(tl, 0xFFFF); 3911 } 3912 else 3913 { 3914 /* SAT_WRITE_FPDMA_QUEUEDK */ 3915 LoopNum = satComputeLoopNum(tl, 0xFFFF); 3916 } 3917 3918 satIOContext->LoopNum = LoopNum; 3919 3920 3921 if (LoopNum == 1) 3922 { 3923 TI_DBG5(("satWrite12: NON CHAINED data\n")); 3924 /* Initialize CB for SATA completion. 3925 */ 3926 satIOContext->satCompleteCB = &satNonChainedDataIOCB; 3927 } 3928 else 3929 { 3930 TI_DBG1(("satWrite12: CHAINED data\n")); 3931 /* re-setting tl */ 3932 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 3933 { 3934 fis->d.sectorCount = 0xFF; 3935 } 3936 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 3937 fis->h.command == SAT_WRITE_DMA_EXT || 3938 fis->h.command == SAT_WRITE_DMA_FUA_EXT 3939 ) 3940 { 3941 fis->d.sectorCount = 0xFF; 3942 fis->d.sectorCountExp = 0xFF; 3943 } 3944 else 3945 { 3946 /* SAT_WRITE_FPDMA_QUEUED */ 3947 fis->h.features = 0xFF; 3948 fis->d.featuresExp = 0xFF; 3949 } 3950 3951 /* Initialize CB for SATA completion. 3952 */ 3953 satIOContext->satCompleteCB = &satChainedDataIOCB; 3954 } 3955 3956 3957 /* 3958 * Prepare SGL and send FIS to LL layer. 3959 */ 3960 satIOContext->reqType = agRequestType; /* Save it */ 3961 3962 status = sataLLIOStart( tiRoot, 3963 tiIORequest, 3964 tiDeviceHandle, 3965 tiScsiRequest, 3966 satIOContext); 3967 return (status); 3968 } 3969 3970 /*****************************************************************************/ 3971 /*! \brief SAT implementation for SCSI WRITE10. 3972 * 3973 * SAT implementation for SCSI WRITE10 and send FIS request to LL layer. 3974 * 3975 * \param tiRoot: Pointer to TISA initiator driver/port instance. 3976 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 3977 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 3978 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 3979 * \param satIOContext_t: Pointer to the SAT IO Context 3980 * 3981 * \return If command is started successfully 3982 * - \e tiSuccess: I/O request successfully initiated. 3983 * - \e tiBusy: No resources available, try again later. 3984 * - \e tiIONoDevice: Invalid device handle. 3985 * - \e tiError: Other errors. 3986 */ 3987 /*****************************************************************************/ 3988 GLOBAL bit32 satWrite10( 3989 tiRoot_t *tiRoot, 3990 tiIORequest_t *tiIORequest, 3991 tiDeviceHandle_t *tiDeviceHandle, 3992 tiScsiInitiatorRequest_t *tiScsiRequest, 3993 satIOContext_t *satIOContext) 3994 { 3995 3996 bit32 status; 3997 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 3998 satDeviceData_t *pSatDevData; 3999 scsiRspSense_t *pSense; 4000 tiIniScsiCmnd_t *scsiCmnd; 4001 agsaFisRegHostToDevice_t *fis; 4002 bit32 lba = 0; 4003 bit32 tl = 0; 4004 bit32 LoopNum = 1; 4005 bit8 LBA[4]; 4006 bit8 TL[4]; 4007 bit32 rangeChk = agFALSE; /* lba and tl range check */ 4008 4009 pSense = satIOContext->pSense; 4010 pSatDevData = satIOContext->pSatDevData; 4011 scsiCmnd = &tiScsiRequest->scsiCmnd; 4012 fis = satIOContext->pFis; 4013 4014 TI_DBG5(("satWrite10: start\n")); 4015 4016 /* checking FUA_NV */ 4017 if (scsiCmnd->cdb[1] & SCSI_FUA_NV_MASK) 4018 { 4019 satSetSensePayload( pSense, 4020 SCSI_SNSKEY_ILLEGAL_REQUEST, 4021 0, 4022 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 4023 satIOContext); 4024 4025 ostiInitiatorIOCompleted( tiRoot, 4026 tiIORequest, 4027 tiIOSuccess, 4028 SCSI_STAT_CHECK_CONDITION, 4029 satIOContext->pTiSenseData, 4030 satIOContext->interruptContext ); 4031 4032 TI_DBG1(("satWrite10: return FUA_NV\n")); 4033 return tiSuccess; 4034 4035 } 4036 4037 /* checking CONTROL */ 4038 /* NACA == 1 or LINK == 1*/ 4039 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 4040 { 4041 satSetSensePayload( pSense, 4042 SCSI_SNSKEY_ILLEGAL_REQUEST, 4043 0, 4044 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 4045 satIOContext); 4046 4047 ostiInitiatorIOCompleted( tiRoot, 4048 tiIORequest, 4049 tiIOSuccess, 4050 SCSI_STAT_CHECK_CONDITION, 4051 satIOContext->pTiSenseData, 4052 satIOContext->interruptContext ); 4053 4054 TI_DBG1(("satWrite10: return control\n")); 4055 return tiSuccess; 4056 } 4057 4058 osti_memset(LBA, 0, sizeof(LBA)); 4059 osti_memset(TL, 0, sizeof(TL)); 4060 4061 /* do not use memcpy due to indexing in LBA and TL */ 4062 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 4063 LBA[1] = scsiCmnd->cdb[3]; 4064 LBA[2] = scsiCmnd->cdb[4]; 4065 LBA[3] = scsiCmnd->cdb[5]; /* LSB */ 4066 4067 TL[0] = 0; 4068 TL[1] = 0; 4069 TL[2] = scsiCmnd->cdb[7]; /* MSB */ 4070 TL[3] = scsiCmnd->cdb[8]; /* LSB */ 4071 4072 rangeChk = satAddNComparebit32(LBA, TL); 4073 4074 4075 /* cbd10; computing LBA and transfer length */ 4076 lba = (scsiCmnd->cdb[2] << (8*3)) + (scsiCmnd->cdb[3] << (8*2)) 4077 + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 4078 tl = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 4079 4080 TI_DBG5(("satWrite10: lba %d functioned lba %d\n", lba, satComputeCDB10LBA(satIOContext))); 4081 TI_DBG5(("satWrite10: tl %d functioned tl %d\n", tl, satComputeCDB10TL(satIOContext))); 4082 4083 /* Table 34, 9.1, p 46 */ 4084 /* 4085 note: As of 2/10/2006, no support for DMA QUEUED 4086 */ 4087 4088 /* 4089 Table 34, 9.1, p 46, b 4090 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 4091 return check condition 4092 */ 4093 if (pSatDevData->satNCQ != agTRUE && 4094 pSatDevData->sat48BitSupport != agTRUE 4095 ) 4096 { 4097 if (lba > SAT_TR_LBA_LIMIT - 1) 4098 { 4099 satSetSensePayload( pSense, 4100 SCSI_SNSKEY_ILLEGAL_REQUEST, 4101 0, 4102 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 4103 satIOContext); 4104 4105 ostiInitiatorIOCompleted( tiRoot, 4106 tiIORequest, 4107 tiIOSuccess, 4108 SCSI_STAT_CHECK_CONDITION, 4109 satIOContext->pTiSenseData, 4110 satIOContext->interruptContext ); 4111 4112 TI_DBG1(("satWrite10: return LBA out of range, not EXT\n")); 4113 TI_DBG1(("satWrite10: cdb 0x%x 0x%x 0x%x 0x%x\n",scsiCmnd->cdb[2], scsiCmnd->cdb[3], 4114 scsiCmnd->cdb[4], scsiCmnd->cdb[5])); 4115 TI_DBG1(("satWrite10: lba 0x%x SAT_TR_LBA_LIMIT 0x%x\n", lba, SAT_TR_LBA_LIMIT)); 4116 return tiSuccess; 4117 } 4118 4119 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 4120 { 4121 TI_DBG1(("satWrite10: return LBA+TL out of range, not EXT\n")); 4122 satSetSensePayload( pSense, 4123 SCSI_SNSKEY_ILLEGAL_REQUEST, 4124 0, 4125 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 4126 satIOContext); 4127 4128 ostiInitiatorIOCompleted( tiRoot, 4129 tiIORequest, 4130 tiIOSuccess, 4131 SCSI_STAT_CHECK_CONDITION, 4132 satIOContext->pTiSenseData, 4133 satIOContext->interruptContext ); 4134 4135 return tiSuccess; 4136 } 4137 4138 } 4139 4140 4141 /* case 1 and 2 */ 4142 if (!rangeChk) // if (lba + tl <= SAT_TR_LBA_LIMIT) 4143 { 4144 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 4145 { 4146 /* case 2 */ 4147 /* WRITE DMA*/ 4148 /* can't fit the transfer length */ 4149 TI_DBG5(("satWrite10: case 2\n")); 4150 fis->h.fisType = 0x27; /* Reg host to device */ 4151 fis->h.c_pmPort = 0x80; /* C bit is set */ 4152 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 4153 fis->h.features = 0; /* FIS reserve */ 4154 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 4155 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 4156 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 4157 4158 /* FIS LBA mode set LBA (27:24) */ 4159 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 4160 4161 fis->d.lbaLowExp = 0; 4162 fis->d.lbaMidExp = 0; 4163 fis->d.lbaHighExp = 0; 4164 fis->d.featuresExp = 0; 4165 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 4166 fis->d.sectorCountExp = 0; 4167 fis->d.reserved4 = 0; 4168 fis->d.control = 0; /* FIS HOB bit clear */ 4169 fis->d.reserved5 = 0; 4170 4171 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 4172 satIOContext->ATACmd = SAT_WRITE_DMA; 4173 } 4174 else 4175 { 4176 /* case 1 */ 4177 /* WRITE MULTIPLE or WRITE SECTOR(S) */ 4178 /* WRITE SECTORS for easier implemetation */ 4179 /* can't fit the transfer length */ 4180 TI_DBG5(("satWrite10: case 1\n")); 4181 fis->h.fisType = 0x27; /* Reg host to device */ 4182 fis->h.c_pmPort = 0x80; /* C bit is set */ 4183 fis->h.command = SAT_WRITE_SECTORS; /* 0x30 */ 4184 fis->h.features = 0; /* FIS reserve */ 4185 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 4186 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 4187 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 4188 4189 /* FIS LBA mode set LBA (27:24) */ 4190 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 4191 4192 fis->d.lbaLowExp = 0; 4193 fis->d.lbaMidExp = 0; 4194 fis->d.lbaHighExp = 0; 4195 fis->d.featuresExp = 0; 4196 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 4197 fis->d.sectorCountExp = 0; 4198 fis->d.reserved4 = 0; 4199 fis->d.control = 0; /* FIS HOB bit clear */ 4200 fis->d.reserved5 = 0; 4201 4202 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 4203 satIOContext->ATACmd = SAT_WRITE_SECTORS; 4204 } 4205 } 4206 /* case 3 and 4 */ 4207 if (pSatDevData->sat48BitSupport == agTRUE) 4208 { 4209 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 4210 { 4211 /* case 3 */ 4212 /* WRITE DMA EXT or WRITE DMA FUA EXT */ 4213 TI_DBG5(("satWrite10: case 3\n")); 4214 fis->h.fisType = 0x27; /* Reg host to device */ 4215 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4216 4217 /* SAT_WRITE_DMA_FUA_EXT is optional and we don't support it */ 4218 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 4219 satIOContext->ATACmd = SAT_WRITE_DMA_EXT; 4220 4221 fis->h.features = 0; /* FIS reserve */ 4222 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 4223 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 4224 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 4225 fis->d.device = 0x40; /* FIS LBA mode set */ 4226 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 4227 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 4228 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 4229 fis->d.featuresExp = 0; /* FIS reserve */ 4230 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 4231 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 4232 fis->d.reserved4 = 0; 4233 fis->d.control = 0; /* FIS HOB bit clear */ 4234 fis->d.reserved5 = 0; 4235 4236 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 4237 } 4238 else 4239 { 4240 /* case 4 */ 4241 /* WRITE MULTIPLE EXT or WRITE MULTIPLE FUA EXT or WRITE SECTOR(S) EXT */ 4242 /* WRITE SECTORS EXT for easier implemetation */ 4243 TI_DBG5(("satWrite10: case 4\n")); 4244 fis->h.fisType = 0x27; /* Reg host to device */ 4245 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4246 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 4247 4248 fis->h.features = 0; /* FIS reserve */ 4249 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 4250 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 4251 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 4252 fis->d.device = 0x40; /* FIS LBA mode set */ 4253 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 4254 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 4255 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 4256 fis->d.featuresExp = 0; /* FIS reserve */ 4257 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 4258 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 4259 fis->d.reserved4 = 0; 4260 fis->d.control = 0; /* FIS HOB bit clear */ 4261 fis->d.reserved5 = 0; 4262 4263 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 4264 satIOContext->ATACmd = SAT_WRITE_SECTORS_EXT; 4265 } 4266 } 4267 /* case 5 */ 4268 if (pSatDevData->satNCQ == agTRUE) 4269 { 4270 /* WRITE FPDMA QUEUED */ 4271 if (pSatDevData->sat48BitSupport != agTRUE) 4272 { 4273 TI_DBG5(("satWrite10: case 5 !!! error NCQ but 28 bit address support \n")); 4274 satSetSensePayload( pSense, 4275 SCSI_SNSKEY_ILLEGAL_REQUEST, 4276 0, 4277 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 4278 satIOContext); 4279 4280 ostiInitiatorIOCompleted( tiRoot, 4281 tiIORequest, 4282 tiIOSuccess, 4283 SCSI_STAT_CHECK_CONDITION, 4284 satIOContext->pTiSenseData, 4285 satIOContext->interruptContext ); 4286 return tiSuccess; 4287 } 4288 TI_DBG6(("satWrite10: case 5\n")); 4289 4290 /* Support 48-bit FPDMA addressing, use WRITE FPDMA QUEUE command */ 4291 4292 fis->h.fisType = 0x27; /* Reg host to device */ 4293 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4294 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 4295 fis->h.features = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 4296 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 4297 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 4298 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 4299 4300 /* Check FUA bit */ 4301 if (scsiCmnd->cdb[1] & SCSI_WRITE10_FUA_MASK) 4302 fis->d.device = 0xC0; /* FIS FUA set */ 4303 else 4304 fis->d.device = 0x40; /* FIS FUA clear */ 4305 4306 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 4307 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 4308 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 4309 fis->d.featuresExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 4310 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 4311 fis->d.sectorCountExp = 0; 4312 fis->d.reserved4 = 0; 4313 fis->d.control = 0; /* FIS HOB bit clear */ 4314 fis->d.reserved5 = 0; 4315 4316 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 4317 satIOContext->ATACmd = SAT_WRITE_FPDMA_QUEUED; 4318 } 4319 4320 // tdhexdump("satWrite10 final fis", (bit8 *)fis, sizeof(agsaFisRegHostToDevice_t)); 4321 4322 satIOContext->currentLBA = lba; 4323 satIOContext->OrgTL = tl; 4324 4325 /* 4326 computing number of loop and remainder for tl 4327 0xFF in case not ext 4328 0xFFFF in case EXT 4329 */ 4330 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 4331 { 4332 LoopNum = satComputeLoopNum(tl, 0xFF); 4333 } 4334 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 4335 fis->h.command == SAT_WRITE_DMA_EXT || 4336 fis->h.command == SAT_WRITE_DMA_FUA_EXT 4337 ) 4338 { 4339 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 4340 LoopNum = satComputeLoopNum(tl, 0xFFFF); 4341 } 4342 else 4343 { 4344 /* SAT_WRITE_FPDMA_QUEUEDK */ 4345 LoopNum = satComputeLoopNum(tl, 0xFFFF); 4346 } 4347 4348 satIOContext->LoopNum = LoopNum; 4349 4350 4351 if (LoopNum == 1) 4352 { 4353 TI_DBG5(("satWrite10: NON CHAINED data\n")); 4354 /* Initialize CB for SATA completion. 4355 */ 4356 satIOContext->satCompleteCB = &satNonChainedDataIOCB; 4357 } 4358 else 4359 { 4360 TI_DBG1(("satWrite10: CHAINED data\n")); 4361 /* re-setting tl */ 4362 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 4363 { 4364 fis->d.sectorCount = 0xFF; 4365 } 4366 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 4367 fis->h.command == SAT_WRITE_DMA_EXT || 4368 fis->h.command == SAT_WRITE_DMA_FUA_EXT 4369 ) 4370 { 4371 fis->d.sectorCount = 0xFF; 4372 fis->d.sectorCountExp = 0xFF; 4373 } 4374 else 4375 { 4376 /* SAT_WRITE_FPDMA_QUEUED */ 4377 fis->h.features = 0xFF; 4378 fis->d.featuresExp = 0xFF; 4379 } 4380 4381 /* Initialize CB for SATA completion. 4382 */ 4383 satIOContext->satCompleteCB = &satChainedDataIOCB; 4384 } 4385 4386 4387 /* 4388 * Prepare SGL and send FIS to LL layer. 4389 */ 4390 satIOContext->reqType = agRequestType; /* Save it */ 4391 4392 status = sataLLIOStart( tiRoot, 4393 tiIORequest, 4394 tiDeviceHandle, 4395 tiScsiRequest, 4396 satIOContext); 4397 return (status); 4398 } 4399 4400 /*****************************************************************************/ 4401 /*! \brief SAT implementation for SCSI satWrite_1. 4402 * 4403 * SAT implementation for SCSI WRITE10 and send FIS request to LL layer. 4404 * This is used when WRITE10 is divided into multiple ATA commands 4405 * 4406 * \param tiRoot: Pointer to TISA initiator driver/port instance. 4407 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 4408 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 4409 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 4410 * \param satIOContext_t: Pointer to the SAT IO Context 4411 * 4412 * \return If command is started successfully 4413 * - \e tiSuccess: I/O request successfully initiated. 4414 * - \e tiBusy: No resources available, try again later. 4415 * - \e tiIONoDevice: Invalid device handle. 4416 * - \e tiError: Other errors. 4417 */ 4418 /*****************************************************************************/ 4419 GLOBAL bit32 satWrite_1( 4420 tiRoot_t *tiRoot, 4421 tiIORequest_t *tiIORequest, 4422 tiDeviceHandle_t *tiDeviceHandle, 4423 tiScsiInitiatorRequest_t *tiScsiRequest, 4424 satIOContext_t *satIOContext) 4425 { 4426 /* 4427 Assumption: error check on lba and tl has been done in satWrite*() 4428 lba = lba + tl; 4429 */ 4430 bit32 status; 4431 satIOContext_t *satOrgIOContext = agNULL; 4432 tiIniScsiCmnd_t *scsiCmnd; 4433 agsaFisRegHostToDevice_t *fis; 4434 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 4435 bit32 lba = 0; 4436 bit32 DenomTL = 0xFF; 4437 bit32 Remainder = 0; 4438 bit8 LBA[4]; /* 0 MSB, 3 LSB */ 4439 4440 TI_DBG2(("satWrite_1: start\n")); 4441 4442 fis = satIOContext->pFis; 4443 satOrgIOContext = satIOContext->satOrgIOContext; 4444 scsiCmnd = satOrgIOContext->pScsiCmnd; 4445 4446 osti_memset(LBA,0, sizeof(LBA)); 4447 4448 switch (satOrgIOContext->ATACmd) 4449 { 4450 case SAT_WRITE_DMA: 4451 DenomTL = 0xFF; 4452 break; 4453 case SAT_WRITE_SECTORS: 4454 DenomTL = 0xFF; 4455 break; 4456 case SAT_WRITE_DMA_EXT: 4457 DenomTL = 0xFFFF; 4458 break; 4459 case SAT_WRITE_DMA_FUA_EXT: 4460 DenomTL = 0xFFFF; 4461 break; 4462 case SAT_WRITE_SECTORS_EXT: 4463 DenomTL = 0xFFFF; 4464 break; 4465 case SAT_WRITE_FPDMA_QUEUED: 4466 DenomTL = 0xFFFF; 4467 break; 4468 default: 4469 TI_DBG1(("satWrite_1: error incorrect ata command 0x%x\n", satIOContext->ATACmd)); 4470 return tiError; 4471 break; 4472 } 4473 4474 Remainder = satOrgIOContext->OrgTL % DenomTL; 4475 satOrgIOContext->currentLBA = satOrgIOContext->currentLBA + DenomTL; 4476 lba = satOrgIOContext->currentLBA; 4477 4478 LBA[0] = (bit8)((lba & 0xF000) >> (8 * 3)); /* MSB */ 4479 LBA[1] = (bit8)((lba & 0xF00) >> (8 * 2)); 4480 LBA[2] = (bit8)((lba & 0xF0) >> 8); 4481 LBA[3] = (bit8)(lba & 0xF); /* LSB */ 4482 4483 switch (satOrgIOContext->ATACmd) 4484 { 4485 case SAT_WRITE_DMA: 4486 fis->h.fisType = 0x27; /* Reg host to device */ 4487 fis->h.c_pmPort = 0x80; /* C bit is set */ 4488 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 4489 fis->h.features = 0; /* FIS reserve */ 4490 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 4491 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 4492 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 4493 4494 /* FIS LBA mode set LBA (27:24) */ 4495 fis->d.device = (bit8)((0x4 << 4) | (LBA[0] & 0xF)); 4496 4497 fis->d.lbaLowExp = 0; 4498 fis->d.lbaMidExp = 0; 4499 fis->d.lbaHighExp = 0; 4500 fis->d.featuresExp = 0; 4501 if (satOrgIOContext->LoopNum == 1) 4502 { 4503 /* last loop */ 4504 fis->d.sectorCount = (bit8)Remainder; /* FIS sector count (7:0) */ 4505 } 4506 else 4507 { 4508 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 4509 } 4510 fis->d.sectorCountExp = 0; 4511 fis->d.reserved4 = 0; 4512 fis->d.control = 0; /* FIS HOB bit clear */ 4513 fis->d.reserved5 = 0; 4514 4515 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 4516 4517 break; 4518 case SAT_WRITE_SECTORS: 4519 fis->h.fisType = 0x27; /* Reg host to device */ 4520 fis->h.c_pmPort = 0x80; /* C bit is set */ 4521 fis->h.command = SAT_WRITE_SECTORS; /* 0x30 */ 4522 fis->h.features = 0; /* FIS reserve */ 4523 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 4524 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 4525 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 4526 4527 /* FIS LBA mode set LBA (27:24) */ 4528 fis->d.device = (bit8)((0x4 << 4) | (LBA[0] & 0xF)); 4529 4530 fis->d.lbaLowExp = 0; 4531 fis->d.lbaMidExp = 0; 4532 fis->d.lbaHighExp = 0; 4533 fis->d.featuresExp = 0; 4534 if (satOrgIOContext->LoopNum == 1) 4535 { 4536 /* last loop */ 4537 fis->d.sectorCount = (bit8)Remainder; /* FIS sector count (7:0) */ 4538 } 4539 else 4540 { 4541 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 4542 } 4543 fis->d.sectorCountExp = 0; 4544 fis->d.reserved4 = 0; 4545 fis->d.control = 0; /* FIS HOB bit clear */ 4546 fis->d.reserved5 = 0; 4547 4548 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 4549 4550 break; 4551 case SAT_WRITE_DMA_EXT: 4552 fis->h.fisType = 0x27; /* Reg host to device */ 4553 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4554 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x3D */ 4555 fis->h.features = 0; /* FIS reserve */ 4556 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 4557 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 4558 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 4559 fis->d.device = 0x40; /* FIS LBA mode set */ 4560 fis->d.lbaLowExp = LBA[0]; /* FIS LBA (31:24) */ 4561 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 4562 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 4563 fis->d.featuresExp = 0; /* FIS reserve */ 4564 if (satOrgIOContext->LoopNum == 1) 4565 { 4566 /* last loop */ 4567 fis->d.sectorCount = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 4568 fis->d.sectorCountExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 4569 } 4570 else 4571 { 4572 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 4573 fis->d.sectorCountExp = 0xFF; /* FIS sector count (15:8) */ 4574 } 4575 fis->d.reserved4 = 0; 4576 fis->d.control = 0; /* FIS HOB bit clear */ 4577 fis->d.reserved5 = 0; 4578 4579 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 4580 4581 break; 4582 case SAT_WRITE_SECTORS_EXT: 4583 fis->h.fisType = 0x27; /* Reg host to device */ 4584 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4585 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 4586 4587 fis->h.features = 0; /* FIS reserve */ 4588 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 4589 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 4590 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 4591 fis->d.device = 0x40; /* FIS LBA mode set */ 4592 fis->d.lbaLowExp = LBA[0]; /* FIS LBA (31:24) */ 4593 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 4594 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 4595 fis->d.featuresExp = 0; /* FIS reserve */ 4596 if (satOrgIOContext->LoopNum == 1) 4597 { 4598 /* last loop */ 4599 fis->d.sectorCount = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 4600 fis->d.sectorCountExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 4601 } 4602 else 4603 { 4604 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 4605 fis->d.sectorCountExp = 0xFF; /* FIS sector count (15:8) */ 4606 } 4607 fis->d.reserved4 = 0; 4608 fis->d.control = 0; /* FIS HOB bit clear */ 4609 fis->d.reserved5 = 0; 4610 4611 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 4612 4613 break; 4614 case SAT_WRITE_FPDMA_QUEUED: 4615 fis->h.fisType = 0x27; /* Reg host to device */ 4616 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4617 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 4618 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 4619 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 4620 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 4621 4622 /* Check FUA bit */ 4623 if (scsiCmnd->cdb[1] & SCSI_WRITE10_FUA_MASK) 4624 fis->d.device = 0xC0; /* FIS FUA set */ 4625 else 4626 fis->d.device = 0x40; /* FIS FUA clear */ 4627 4628 fis->d.lbaLowExp = LBA[0];; /* FIS LBA (31:24) */ 4629 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 4630 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 4631 if (satOrgIOContext->LoopNum == 1) 4632 { 4633 /* last loop */ 4634 fis->h.features = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 4635 fis->d.featuresExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 4636 } 4637 else 4638 { 4639 fis->h.features = 0xFF; /* FIS sector count (7:0) */ 4640 fis->d.featuresExp = 0xFF; /* FIS sector count (15:8) */ 4641 } 4642 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 4643 fis->d.sectorCountExp = 0; 4644 fis->d.reserved4 = 0; 4645 fis->d.control = 0; /* FIS HOB bit clear */ 4646 fis->d.reserved5 = 0; 4647 4648 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 4649 break; 4650 4651 default: 4652 TI_DBG1(("satWrite_1: error incorrect ata command 0x%x\n", satIOContext->ATACmd)); 4653 return tiError; 4654 break; 4655 } 4656 4657 /* Initialize CB for SATA completion. 4658 */ 4659 /* chained data */ 4660 satIOContext->satCompleteCB = &satChainedDataIOCB; 4661 4662 4663 /* 4664 * Prepare SGL and send FIS to LL layer. 4665 */ 4666 satIOContext->reqType = agRequestType; /* Save it */ 4667 4668 status = sataLLIOStart( tiRoot, 4669 tiIORequest, 4670 tiDeviceHandle, 4671 tiScsiRequest, 4672 satIOContext); 4673 4674 TI_DBG5(("satWrite_1: return\n")); 4675 return (status); 4676 } 4677 4678 /*****************************************************************************/ 4679 /*! \brief SAT implementation for SCSI WRITE6. 4680 * 4681 * SAT implementation for SCSI WRITE6 and send FIS request to LL layer. 4682 * 4683 * \param tiRoot: Pointer to TISA initiator driver/port instance. 4684 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 4685 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 4686 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 4687 * \param satIOContext_t: Pointer to the SAT IO Context 4688 * 4689 * \return If command is started successfully 4690 * - \e tiSuccess: I/O request successfully initiated. 4691 * - \e tiBusy: No resources available, try again later. 4692 * - \e tiIONoDevice: Invalid device handle. 4693 * - \e tiError: Other errors. 4694 */ 4695 /*****************************************************************************/ 4696 GLOBAL bit32 satWrite6( 4697 tiRoot_t *tiRoot, 4698 tiIORequest_t *tiIORequest, 4699 tiDeviceHandle_t *tiDeviceHandle, 4700 tiScsiInitiatorRequest_t *tiScsiRequest, 4701 satIOContext_t *satIOContext) 4702 { 4703 4704 bit32 status; 4705 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 4706 satDeviceData_t *pSatDevData; 4707 scsiRspSense_t *pSense; 4708 tiIniScsiCmnd_t *scsiCmnd; 4709 agsaFisRegHostToDevice_t *fis; 4710 bit32 lba = 0; 4711 bit16 tl = 0; 4712 4713 pSense = satIOContext->pSense; 4714 pSatDevData = satIOContext->pSatDevData; 4715 scsiCmnd = &tiScsiRequest->scsiCmnd; 4716 fis = satIOContext->pFis; 4717 4718 TI_DBG5(("satWrite6: start\n")); 4719 4720 /* checking CONTROL */ 4721 /* NACA == 1 or LINK == 1*/ 4722 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 4723 { 4724 satSetSensePayload( pSense, 4725 SCSI_SNSKEY_ILLEGAL_REQUEST, 4726 0, 4727 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 4728 satIOContext); 4729 4730 ostiInitiatorIOCompleted( tiRoot, 4731 tiIORequest, 4732 tiIOSuccess, 4733 SCSI_STAT_CHECK_CONDITION, 4734 satIOContext->pTiSenseData, 4735 satIOContext->interruptContext ); 4736 4737 TI_DBG1(("satWrite6: return control\n")); 4738 return tiSuccess; 4739 } 4740 4741 4742 /* cbd6; computing LBA and transfer length */ 4743 lba = (((scsiCmnd->cdb[1]) & 0x1f) << (8*2)) 4744 + (scsiCmnd->cdb[2] << 8) + scsiCmnd->cdb[3]; 4745 tl = scsiCmnd->cdb[4]; 4746 4747 4748 /* Table 34, 9.1, p 46 */ 4749 /* 4750 note: As of 2/10/2006, no support for DMA QUEUED 4751 */ 4752 4753 /* 4754 Table 34, 9.1, p 46, b 4755 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 4756 return check condition 4757 */ 4758 if (pSatDevData->satNCQ != agTRUE && 4759 pSatDevData->sat48BitSupport != agTRUE 4760 ) 4761 { 4762 if (lba > SAT_TR_LBA_LIMIT - 1) 4763 { 4764 satSetSensePayload( pSense, 4765 SCSI_SNSKEY_ILLEGAL_REQUEST, 4766 0, 4767 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 4768 satIOContext); 4769 4770 ostiInitiatorIOCompleted( tiRoot, 4771 tiIORequest, 4772 tiIOSuccess, 4773 SCSI_STAT_CHECK_CONDITION, 4774 satIOContext->pTiSenseData, 4775 satIOContext->interruptContext ); 4776 4777 TI_DBG1(("satWrite6: return LBA out of range\n")); 4778 return tiSuccess; 4779 } 4780 } 4781 4782 /* case 1 and 2 */ 4783 if (lba + tl <= SAT_TR_LBA_LIMIT) 4784 { 4785 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 4786 { 4787 /* case 2 */ 4788 /* WRITE DMA*/ 4789 TI_DBG5(("satWrite6: case 2\n")); 4790 4791 4792 fis->h.fisType = 0x27; /* Reg host to device */ 4793 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4794 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 4795 fis->h.features = 0; /* FIS reserve */ 4796 fis->d.lbaLow = scsiCmnd->cdb[3]; /* FIS LBA (7 :0 ) */ 4797 fis->d.lbaMid = scsiCmnd->cdb[2]; /* FIS LBA (15:8 ) */ 4798 fis->d.lbaHigh = (bit8)((scsiCmnd->cdb[1]) & 0x1f); /* FIS LBA (23:16) */ 4799 fis->d.device = 0x40; /* FIS LBA mode */ 4800 fis->d.lbaLowExp = 0; 4801 fis->d.lbaMidExp = 0; 4802 fis->d.lbaHighExp = 0; 4803 fis->d.featuresExp = 0; 4804 if (tl == 0) 4805 { 4806 /* temporary fix */ 4807 fis->d.sectorCount = 0xff; /* FIS sector count (7:0) */ 4808 } 4809 else 4810 { 4811 fis->d.sectorCount = scsiCmnd->cdb[4]; /* FIS sector count (7:0) */ 4812 } 4813 fis->d.sectorCountExp = 0; 4814 fis->d.reserved4 = 0; 4815 fis->d.control = 0; /* FIS HOB bit clear */ 4816 fis->d.reserved5 = 0; 4817 4818 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 4819 } 4820 else 4821 { 4822 /* case 1 */ 4823 /* WRITE SECTORS for easier implemetation */ 4824 TI_DBG5(("satWrite6: case 1\n")); 4825 4826 fis->h.fisType = 0x27; /* Reg host to device */ 4827 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4828 fis->h.command = SAT_WRITE_SECTORS; /* 0xCA */ 4829 fis->h.features = 0; /* FIS reserve */ 4830 fis->d.lbaLow = scsiCmnd->cdb[3]; /* FIS LBA (7 :0 ) */ 4831 fis->d.lbaMid = scsiCmnd->cdb[2]; /* FIS LBA (15:8 ) */ 4832 fis->d.lbaHigh = (bit8)((scsiCmnd->cdb[1]) & 0x1f); /* FIS LBA (23:16) */ 4833 fis->d.device = 0x40; /* FIS LBA mode */ 4834 fis->d.lbaLowExp = 0; 4835 fis->d.lbaMidExp = 0; 4836 fis->d.lbaHighExp = 0; 4837 fis->d.featuresExp = 0; 4838 if (tl == 0) 4839 { 4840 /* temporary fix */ 4841 fis->d.sectorCount = 0xff; /* FIS sector count (7:0) */ 4842 } 4843 else 4844 { 4845 fis->d.sectorCount = scsiCmnd->cdb[4]; /* FIS sector count (7:0) */ 4846 } 4847 fis->d.sectorCountExp = 0; 4848 fis->d.reserved4 = 0; 4849 fis->d.control = 0; /* FIS HOB bit clear */ 4850 fis->d.reserved5 = 0; 4851 4852 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 4853 4854 } 4855 } 4856 4857 /* case 3 and 4 */ 4858 if (pSatDevData->sat48BitSupport == agTRUE) 4859 { 4860 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 4861 { 4862 /* case 3 */ 4863 /* WRITE DMA EXT only */ 4864 TI_DBG5(("satWrite6: case 3\n")); 4865 fis->h.fisType = 0x27; /* Reg host to device */ 4866 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4867 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 4868 fis->h.features = 0; /* FIS reserve */ 4869 fis->d.lbaLow = scsiCmnd->cdb[3]; /* FIS LBA (7 :0 ) */ 4870 fis->d.lbaMid = scsiCmnd->cdb[2]; /* FIS LBA (15:8 ) */ 4871 fis->d.lbaHigh = (bit8)((scsiCmnd->cdb[1]) & 0x1f); /* FIS LBA (23:16) */ 4872 fis->d.device = 0x40; /* FIS LBA mode set */ 4873 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 4874 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 4875 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 4876 fis->d.featuresExp = 0; /* FIS reserve */ 4877 if (tl == 0) 4878 { 4879 /* sector count is 256, 0x100*/ 4880 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 4881 fis->d.sectorCountExp = 0x01; /* FIS sector count (15:8) */ 4882 } 4883 else 4884 { 4885 fis->d.sectorCount = scsiCmnd->cdb[4]; /* FIS sector count (7:0) */ 4886 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 4887 } 4888 fis->d.reserved4 = 0; 4889 fis->d.control = 0; /* FIS HOB bit clear */ 4890 fis->d.reserved5 = 0; 4891 4892 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 4893 } 4894 else 4895 { 4896 /* case 4 */ 4897 /* WRITE SECTORS EXT for easier implemetation */ 4898 TI_DBG5(("satWrite6: case 4\n")); 4899 4900 fis->h.fisType = 0x27; /* Reg host to device */ 4901 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4902 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 4903 fis->h.features = 0; /* FIS reserve */ 4904 fis->d.lbaLow = scsiCmnd->cdb[3]; /* FIS LBA (7 :0 ) */ 4905 fis->d.lbaMid = scsiCmnd->cdb[2]; /* FIS LBA (15:8 ) */ 4906 fis->d.lbaHigh = (bit8)((scsiCmnd->cdb[1]) & 0x1f); /* FIS LBA (23:16) */ 4907 fis->d.device = 0x40; /* FIS LBA mode set */ 4908 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 4909 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 4910 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 4911 fis->d.featuresExp = 0; /* FIS reserve */ 4912 if (tl == 0) 4913 { 4914 /* sector count is 256, 0x100*/ 4915 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 4916 fis->d.sectorCountExp = 0x01; /* FIS sector count (15:8) */ 4917 } 4918 else 4919 { 4920 fis->d.sectorCount = scsiCmnd->cdb[4]; /* FIS sector count (7:0) */ 4921 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 4922 } 4923 fis->d.reserved4 = 0; 4924 fis->d.control = 0; /* FIS HOB bit clear */ 4925 fis->d.reserved5 = 0; 4926 4927 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 4928 } 4929 } 4930 4931 /* case 5 */ 4932 if (pSatDevData->satNCQ == agTRUE) 4933 { 4934 /* WRITE FPDMA QUEUED */ 4935 if (pSatDevData->sat48BitSupport != agTRUE) 4936 { 4937 /* sanity check */ 4938 TI_DBG5(("satWrite6: case 5 !!! error NCQ but 28 bit address support \n")); 4939 satSetSensePayload( pSense, 4940 SCSI_SNSKEY_ILLEGAL_REQUEST, 4941 0, 4942 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 4943 satIOContext); 4944 4945 ostiInitiatorIOCompleted( tiRoot, 4946 tiIORequest, 4947 tiIOSuccess, 4948 SCSI_STAT_CHECK_CONDITION, 4949 satIOContext->pTiSenseData, 4950 satIOContext->interruptContext ); 4951 return tiSuccess; 4952 } 4953 TI_DBG5(("satWrite6: case 5\n")); 4954 4955 /* Support 48-bit FPDMA addressing, use WRITE FPDMA QUEUE command */ 4956 4957 fis->h.fisType = 0x27; /* Reg host to device */ 4958 fis->h.c_pmPort = 0x80; /* C Bit is set */ 4959 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 4960 fis->d.lbaLow = scsiCmnd->cdb[3]; /* FIS LBA (7 :0 ) */ 4961 fis->d.lbaMid = scsiCmnd->cdb[2]; /* FIS LBA (15:8 ) */ 4962 fis->d.lbaHigh = (bit8)((scsiCmnd->cdb[1]) & 0x1f); /* FIS LBA (23:16) */ 4963 fis->d.device = 0x40; /* FIS FUA clear */ 4964 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 4965 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 4966 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 4967 if (tl == 0) 4968 { 4969 /* sector count is 256, 0x100*/ 4970 fis->h.features = 0; /* FIS sector count (7:0) */ 4971 fis->d.featuresExp = 0x01; /* FIS sector count (15:8) */ 4972 } 4973 else 4974 { 4975 fis->h.features = scsiCmnd->cdb[4]; /* FIS sector count (7:0) */ 4976 fis->d.featuresExp = 0; /* FIS sector count (15:8) */ 4977 } 4978 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 4979 fis->d.sectorCountExp = 0; 4980 fis->d.reserved4 = 0; 4981 fis->d.control = 0; /* FIS HOB bit clear */ 4982 fis->d.reserved5 = 0; 4983 4984 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 4985 } 4986 4987 /* Initialize CB for SATA completion. 4988 */ 4989 satIOContext->satCompleteCB = &satNonChainedDataIOCB; 4990 4991 /* 4992 * Prepare SGL and send FIS to LL layer. 4993 */ 4994 satIOContext->reqType = agRequestType; /* Save it */ 4995 4996 status = sataLLIOStart( tiRoot, 4997 tiIORequest, 4998 tiDeviceHandle, 4999 tiScsiRequest, 5000 satIOContext); 5001 return (status); 5002 } 5003 5004 5005 /*****************************************************************************/ 5006 /*! \brief SAT implementation for SCSI TEST UNIT READY. 5007 * 5008 * SAT implementation for SCSI TUR and send FIS request to LL layer. 5009 * 5010 * \param tiRoot: Pointer to TISA initiator driver/port instance. 5011 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 5012 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 5013 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 5014 * \param satIOContext_t: Pointer to the SAT IO Context 5015 * 5016 * \return If command is started successfully 5017 * - \e tiSuccess: I/O request successfully initiated. 5018 * - \e tiBusy: No resources available, try again later. 5019 * - \e tiIONoDevice: Invalid device handle. 5020 * - \e tiError: Other errors. 5021 */ 5022 /*****************************************************************************/ 5023 GLOBAL bit32 satTestUnitReady( 5024 tiRoot_t *tiRoot, 5025 tiIORequest_t *tiIORequest, 5026 tiDeviceHandle_t *tiDeviceHandle, 5027 tiScsiInitiatorRequest_t *tiScsiRequest, 5028 satIOContext_t *satIOContext) 5029 { 5030 5031 bit32 status; 5032 bit32 agRequestType; 5033 satDeviceData_t *pSatDevData; 5034 scsiRspSense_t *pSense; 5035 tiIniScsiCmnd_t *scsiCmnd; 5036 agsaFisRegHostToDevice_t *fis; 5037 5038 pSense = satIOContext->pSense; 5039 pSatDevData = satIOContext->pSatDevData; 5040 scsiCmnd = &tiScsiRequest->scsiCmnd; 5041 fis = satIOContext->pFis; 5042 5043 TI_DBG6(("satTestUnitReady: entry tiDeviceHandle=%p tiIORequest=%p\n", 5044 tiDeviceHandle, tiIORequest)); 5045 5046 /* checking CONTROL */ 5047 /* NACA == 1 or LINK == 1*/ 5048 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 5049 { 5050 satSetSensePayload( pSense, 5051 SCSI_SNSKEY_ILLEGAL_REQUEST, 5052 0, 5053 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 5054 satIOContext); 5055 5056 ostiInitiatorIOCompleted( tiRoot, 5057 tiIORequest, 5058 tiIOSuccess, 5059 SCSI_STAT_CHECK_CONDITION, 5060 satIOContext->pTiSenseData, 5061 satIOContext->interruptContext ); 5062 5063 TI_DBG1(("satTestUnitReady: return control\n")); 5064 return tiSuccess; 5065 } 5066 5067 /* SAT revision 8, 8.11.2, p42*/ 5068 if (pSatDevData->satStopState == agTRUE) 5069 { 5070 satSetSensePayload( pSense, 5071 SCSI_SNSKEY_NOT_READY, 5072 0, 5073 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_INITIALIZING_COMMAND_REQUIRED, 5074 satIOContext); 5075 5076 ostiInitiatorIOCompleted( tiRoot, 5077 tiIORequest, 5078 tiIOSuccess, 5079 SCSI_STAT_CHECK_CONDITION, 5080 satIOContext->pTiSenseData, 5081 satIOContext->interruptContext ); 5082 TI_DBG1(("satTestUnitReady: stop state\n")); 5083 return tiSuccess; 5084 } 5085 5086 /* 5087 * Check if format is in progress 5088 */ 5089 5090 if (pSatDevData->satDriveState == SAT_DEV_STATE_FORMAT_IN_PROGRESS) 5091 { 5092 TI_DBG1(("satTestUnitReady() FORMAT_IN_PROGRESS tiDeviceHandle=%p tiIORequest=%p\n", 5093 tiDeviceHandle, tiIORequest)); 5094 5095 satSetSensePayload( pSense, 5096 SCSI_SNSKEY_NOT_READY, 5097 0, 5098 SCSI_SNSCODE_LOGICAL_UNIT_NOT_READY_FORMAT_IN_PROGRESS, 5099 satIOContext); 5100 5101 ostiInitiatorIOCompleted( tiRoot, 5102 tiIORequest, 5103 tiIOSuccess, 5104 SCSI_STAT_CHECK_CONDITION, 5105 satIOContext->pTiSenseData, 5106 satIOContext->interruptContext ); 5107 TI_DBG1(("satTestUnitReady: format in progress\n")); 5108 return tiSuccess; 5109 } 5110 5111 /* 5112 check previously issued ATA command 5113 */ 5114 if (pSatDevData->satPendingIO != 0) 5115 { 5116 if (pSatDevData->satDeviceFaultState == agTRUE) 5117 { 5118 satSetSensePayload( pSense, 5119 SCSI_SNSKEY_HARDWARE_ERROR, 5120 0, 5121 SCSI_SNSCODE_LOGICAL_UNIT_FAILURE, 5122 satIOContext); 5123 5124 ostiInitiatorIOCompleted( tiRoot, 5125 tiIORequest, 5126 tiIOSuccess, 5127 SCSI_STAT_CHECK_CONDITION, 5128 satIOContext->pTiSenseData, 5129 satIOContext->interruptContext ); 5130 TI_DBG1(("satTestUnitReady: previous command ended in error\n")); 5131 return tiSuccess; 5132 } 5133 } 5134 /* 5135 check removalbe media feature set 5136 */ 5137 if(pSatDevData->satRemovableMedia && pSatDevData->satRemovableMediaEnabled) 5138 { 5139 TI_DBG5(("satTestUnitReady: sending get media status cmnd\n")); 5140 /* send GET MEDIA STATUS command */ 5141 fis->h.fisType = 0x27; /* Reg host to device */ 5142 fis->h.c_pmPort = 0x80; /* C Bit is set */ 5143 fis->h.command = SAT_GET_MEDIA_STATUS; /* 0xDA */ 5144 fis->h.features = 0; /* FIS features NA */ 5145 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 5146 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 5147 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 5148 fis->d.device = 0; /* FIS DEV is discared in SATA */ 5149 fis->d.lbaLowExp = 0; 5150 fis->d.lbaMidExp = 0; 5151 fis->d.lbaHighExp = 0; 5152 fis->d.featuresExp = 0; 5153 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 5154 fis->d.sectorCountExp = 0; 5155 fis->d.reserved4 = 0; 5156 fis->d.control = 0; /* FIS HOB bit clear */ 5157 fis->d.reserved5 = 0; 5158 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 5159 5160 /* Initialize CB for SATA completion. 5161 */ 5162 satIOContext->satCompleteCB = &satTestUnitReadyCB; 5163 5164 /* 5165 * Prepare SGL and send FIS to LL layer. 5166 */ 5167 satIOContext->reqType = agRequestType; /* Save it */ 5168 5169 status = sataLLIOStart( tiRoot, 5170 tiIORequest, 5171 tiDeviceHandle, 5172 tiScsiRequest, 5173 satIOContext); 5174 5175 return (status); 5176 } 5177 /* 5178 number 6) in SAT p42 5179 send ATA CHECK POWER MODE 5180 */ 5181 TI_DBG5(("satTestUnitReady: sending check power mode cmnd\n")); 5182 status = satTestUnitReady_1( tiRoot, 5183 tiIORequest, 5184 tiDeviceHandle, 5185 tiScsiRequest, 5186 satIOContext); 5187 return (status); 5188 } 5189 5190 5191 /*****************************************************************************/ 5192 /*! \brief SAT implementation for SCSI satTestUnitReady_1. 5193 * 5194 * SAT implementation for SCSI satTestUnitReady_1. 5195 * 5196 * \param tiRoot: Pointer to TISA initiator driver/port instance. 5197 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 5198 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 5199 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 5200 * \param satIOContext_t: Pointer to the SAT IO Context 5201 * 5202 * \return If command is started successfully 5203 * - \e tiSuccess: I/O request successfully initiated. 5204 * - \e tiBusy: No resources available, try again later. 5205 * - \e tiIONoDevice: Invalid device handle. 5206 * - \e tiError: Other errors. 5207 */ 5208 /*****************************************************************************/ 5209 GLOBAL bit32 satTestUnitReady_1( 5210 tiRoot_t *tiRoot, 5211 tiIORequest_t *tiIORequest, 5212 tiDeviceHandle_t *tiDeviceHandle, 5213 tiScsiInitiatorRequest_t *tiScsiRequest, 5214 satIOContext_t *satIOContext) 5215 { 5216 /* 5217 sends SAT_CHECK_POWER_MODE as a part of TESTUNITREADY 5218 internally generated - no directly corresponding scsi 5219 called in satIOCompleted as a part of satTestUnitReady(), SAT, revision8, 8.11.2, p42 5220 */ 5221 bit32 status; 5222 bit32 agRequestType; 5223 agsaFisRegHostToDevice_t *fis; 5224 5225 fis = satIOContext->pFis; 5226 5227 TI_DBG5(("satTestUnitReady_1: start\n")); 5228 5229 /* 5230 * Send the ATA CHECK POWER MODE command. 5231 */ 5232 fis->h.fisType = 0x27; /* Reg host to device */ 5233 fis->h.c_pmPort = 0x80; /* C Bit is set */ 5234 fis->h.command = SAT_CHECK_POWER_MODE; /* 0xE5 */ 5235 fis->h.features = 0; 5236 fis->d.lbaLow = 0; 5237 fis->d.lbaMid = 0; 5238 fis->d.lbaHigh = 0; 5239 fis->d.device = 0; 5240 fis->d.lbaLowExp = 0; 5241 fis->d.lbaMidExp = 0; 5242 fis->d.lbaHighExp = 0; 5243 fis->d.featuresExp = 0; 5244 fis->d.sectorCount = 0; 5245 fis->d.sectorCountExp = 0; 5246 fis->d.reserved4 = 0; 5247 fis->d.control = 0; /* FIS HOB bit clear */ 5248 fis->d.reserved5 = 0; 5249 5250 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 5251 5252 /* Initialize CB for SATA completion. 5253 */ 5254 satIOContext->satCompleteCB = &satTestUnitReadyCB; 5255 5256 /* 5257 * Prepare SGL and send FIS to LL layer. 5258 */ 5259 satIOContext->reqType = agRequestType; /* Save it */ 5260 5261 status = sataLLIOStart( tiRoot, 5262 tiIORequest, 5263 tiDeviceHandle, 5264 tiScsiRequest, 5265 satIOContext); 5266 5267 TI_DBG5(("satTestUnitReady_1: return\n")); 5268 5269 return status; 5270 } 5271 5272 5273 /*****************************************************************************/ 5274 /*! \brief SAT implementation for SCSI satReportLun. 5275 * 5276 * SAT implementation for SCSI satReportLun. Only LUN0 is reported. 5277 * 5278 * \param tiRoot: Pointer to TISA initiator driver/port instance. 5279 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 5280 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 5281 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 5282 * \param satIOContext_t: Pointer to the SAT IO Context 5283 * 5284 * \return If command is started successfully 5285 * - \e tiSuccess: I/O request successfully initiated. 5286 * - \e tiBusy: No resources available, try again later. 5287 * - \e tiIONoDevice: Invalid device handle. 5288 * - \e tiError: Other errors. 5289 */ 5290 /*****************************************************************************/ 5291 GLOBAL bit32 satReportLun( 5292 tiRoot_t *tiRoot, 5293 tiIORequest_t *tiIORequest, 5294 tiDeviceHandle_t *tiDeviceHandle, 5295 tiScsiInitiatorRequest_t *tiScsiRequest, 5296 satIOContext_t *satIOContext) 5297 { 5298 scsiRspSense_t *pSense; 5299 bit32 allocationLen; 5300 bit32 reportLunLen; 5301 scsiReportLun_t *pReportLun; 5302 tiIniScsiCmnd_t *scsiCmnd; 5303 5304 TI_DBG5(("satReportLun entry: tiDeviceHandle=%p tiIORequest=%p\n", 5305 tiDeviceHandle, tiIORequest)); 5306 5307 pSense = satIOContext->pSense; 5308 pReportLun = (scsiReportLun_t *) tiScsiRequest->sglVirtualAddr; 5309 scsiCmnd = &tiScsiRequest->scsiCmnd; 5310 5311 // tdhexdump("satReportLun cdb", (bit8 *)scsiCmnd, 16); 5312 5313 /* Find the buffer size allocated by Initiator */ 5314 allocationLen = (((bit32)scsiCmnd->cdb[6]) << 24) | 5315 (((bit32)scsiCmnd->cdb[7]) << 16) | 5316 (((bit32)scsiCmnd->cdb[8]) << 8 ) | 5317 (((bit32)scsiCmnd->cdb[9]) ); 5318 5319 reportLunLen = 16; /* 8 byte header and 8 bytes of LUN0 */ 5320 5321 if (allocationLen < reportLunLen) 5322 { 5323 TI_DBG1(("satReportLun *** ERROR *** insufficient len=0x%x tiDeviceHandle=%p tiIORequest=%p\n", 5324 reportLunLen, tiDeviceHandle, tiIORequest)); 5325 5326 satSetSensePayload( pSense, 5327 SCSI_SNSKEY_ILLEGAL_REQUEST, 5328 0, 5329 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 5330 satIOContext); 5331 5332 ostiInitiatorIOCompleted( tiRoot, 5333 tiIORequest, 5334 tiIOSuccess, 5335 SCSI_STAT_CHECK_CONDITION, 5336 satIOContext->pTiSenseData, 5337 satIOContext->interruptContext ); 5338 return tiSuccess; 5339 5340 } 5341 5342 /* Set length to one entry */ 5343 pReportLun->len[0] = 0; 5344 pReportLun->len[1] = 0; 5345 pReportLun->len[2] = 0; 5346 pReportLun->len[3] = sizeof (tiLUN_t); 5347 5348 pReportLun->reserved = 0; 5349 5350 /* Set to LUN 0: 5351 * - address method to 0x00: Peripheral device addressing method, 5352 * - bus identifier to 0 5353 */ 5354 pReportLun->lunList[0].lun[0] = 0; 5355 pReportLun->lunList[0].lun[1] = 0; 5356 pReportLun->lunList[0].lun[2] = 0; 5357 pReportLun->lunList[0].lun[3] = 0; 5358 pReportLun->lunList[0].lun[4] = 0; 5359 pReportLun->lunList[0].lun[5] = 0; 5360 pReportLun->lunList[0].lun[6] = 0; 5361 pReportLun->lunList[0].lun[7] = 0; 5362 5363 if (allocationLen > reportLunLen) 5364 { 5365 /* underrun */ 5366 TI_DBG1(("satReportLun reporting underrun reportLunLen=0x%x allocationLen=0x%x \n", reportLunLen, allocationLen)); 5367 5368 ostiInitiatorIOCompleted( tiRoot, 5369 tiIORequest, 5370 tiIOUnderRun, 5371 allocationLen - reportLunLen, 5372 agNULL, 5373 satIOContext->interruptContext ); 5374 5375 5376 } 5377 else 5378 { 5379 ostiInitiatorIOCompleted( tiRoot, 5380 tiIORequest, 5381 tiIOSuccess, 5382 SCSI_STAT_GOOD, 5383 agNULL, 5384 satIOContext->interruptContext); 5385 } 5386 return tiSuccess; 5387 } 5388 5389 5390 /*****************************************************************************/ 5391 /*! \brief SAT implementation for SCSI REQUEST SENSE. 5392 * 5393 * SAT implementation for SCSI REQUEST SENSE. 5394 * 5395 * \param tiRoot: Pointer to TISA initiator driver/port instance. 5396 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 5397 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 5398 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 5399 * \param satIOContext_t: Pointer to the SAT IO Context 5400 * 5401 * \return If command is started successfully 5402 * - \e tiSuccess: I/O request successfully initiated. 5403 * - \e tiBusy: No resources available, try again later. 5404 * - \e tiIONoDevice: Invalid device handle. 5405 * - \e tiError: Other errors. 5406 */ 5407 /*****************************************************************************/ 5408 GLOBAL bit32 satRequestSense( 5409 tiRoot_t *tiRoot, 5410 tiIORequest_t *tiIORequest, 5411 tiDeviceHandle_t *tiDeviceHandle, 5412 tiScsiInitiatorRequest_t *tiScsiRequest, 5413 satIOContext_t *satIOContext) 5414 { 5415 /* 5416 SAT Rev 8 p38, Table25 5417 sending SMART RETURN STATUS 5418 Checking SMART Treshold Exceeded Condition is done in satRequestSenseCB() 5419 Only fixed format sense data is support. In other words, we don't support DESC bit is set 5420 in Request Sense 5421 */ 5422 bit32 status; 5423 bit32 agRequestType; 5424 scsiRspSense_t *pSense; 5425 satDeviceData_t *pSatDevData; 5426 tiIniScsiCmnd_t *scsiCmnd; 5427 agsaFisRegHostToDevice_t *fis; 5428 tdIORequestBody_t *tdIORequestBody; 5429 satInternalIo_t *satIntIo = agNULL; 5430 satIOContext_t *satIOContext2; 5431 5432 TI_DBG4(("satRequestSense entry: tiDeviceHandle=%p tiIORequest=%p\n", 5433 tiDeviceHandle, tiIORequest)); 5434 5435 pSense = (scsiRspSense_t *) tiScsiRequest->sglVirtualAddr; 5436 pSatDevData = satIOContext->pSatDevData; 5437 scsiCmnd = &tiScsiRequest->scsiCmnd; 5438 fis = satIOContext->pFis; 5439 5440 TI_DBG4(("satRequestSense: pSatDevData=%p\n", pSatDevData)); 5441 5442 /* checking CONTROL */ 5443 /* NACA == 1 or LINK == 1*/ 5444 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 5445 { 5446 satSetSensePayload( pSense, 5447 SCSI_SNSKEY_ILLEGAL_REQUEST, 5448 0, 5449 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 5450 satIOContext); 5451 5452 ostiInitiatorIOCompleted( tiRoot, 5453 tiIORequest, 5454 tiIOSuccess, 5455 SCSI_STAT_CHECK_CONDITION, 5456 satIOContext->pTiSenseData, 5457 satIOContext->interruptContext ); 5458 5459 TI_DBG1(("satRequestSense: return control\n")); 5460 return tiSuccess; 5461 } 5462 5463 /* 5464 Only fixed format sense data is support. In other words, we don't support DESC bit is set 5465 in Request Sense 5466 */ 5467 if ( scsiCmnd->cdb[1] & ATA_REMOVABLE_MEDIA_DEVICE_MASK ) 5468 { 5469 satSetSensePayload( pSense, 5470 SCSI_SNSKEY_ILLEGAL_REQUEST, 5471 0, 5472 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 5473 satIOContext); 5474 5475 ostiInitiatorIOCompleted( tiRoot, 5476 tiIORequest, 5477 tiIOSuccess, 5478 SCSI_STAT_CHECK_CONDITION, 5479 satIOContext->pTiSenseData, 5480 satIOContext->interruptContext ); 5481 5482 TI_DBG1(("satRequestSense: DESC bit is set, which we don't support\n")); 5483 return tiSuccess; 5484 } 5485 5486 5487 if (pSatDevData->satSMARTEnabled == agTRUE) 5488 { 5489 /* sends SMART RETURN STATUS */ 5490 fis->h.fisType = 0x27; /* Reg host to device */ 5491 fis->h.c_pmPort = 0x80; /* C Bit is set */ 5492 5493 fis->h.command = SAT_SMART_RETURN_STATUS; /* 0xB0 */ 5494 fis->h.features = 0xDA; /* FIS features */ 5495 fis->d.featuresExp = 0; /* FIS reserve */ 5496 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 5497 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 5498 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 5499 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 5500 fis->d.lbaMid = 0x4F; /* FIS LBA (15:8 ) */ 5501 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 5502 fis->d.lbaHigh = 0xC2; /* FIS LBA (23:16) */ 5503 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 5504 fis->d.device = 0; /* FIS DEV is discared in SATA */ 5505 fis->d.control = 0; /* FIS HOB bit clear */ 5506 fis->d.reserved4 = 0; 5507 fis->d.reserved5 = 0; 5508 5509 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 5510 /* Initialize CB for SATA completion. 5511 */ 5512 satIOContext->satCompleteCB = &satRequestSenseCB; 5513 5514 /* 5515 * Prepare SGL and send FIS to LL layer. 5516 */ 5517 satIOContext->reqType = agRequestType; /* Save it */ 5518 5519 status = sataLLIOStart( tiRoot, 5520 tiIORequest, 5521 tiDeviceHandle, 5522 tiScsiRequest, 5523 satIOContext); 5524 5525 TI_DBG4(("satRequestSense: if return, status %d\n", status)); 5526 return (status); 5527 } 5528 else 5529 { 5530 /*allocate iocontext for xmitting xmit SAT_CHECK_POWER_MODE 5531 then call satRequestSense2 */ 5532 5533 TI_DBG4(("satRequestSense: before satIntIo %p\n", satIntIo)); 5534 /* allocate iocontext */ 5535 satIntIo = satAllocIntIoResource( tiRoot, 5536 tiIORequest, /* original request */ 5537 pSatDevData, 5538 tiScsiRequest->scsiCmnd.expDataLength, 5539 satIntIo); 5540 5541 TI_DBG4(("satRequestSense: after satIntIo %p\n", satIntIo)); 5542 5543 if (satIntIo == agNULL) 5544 { 5545 /* memory allocation failure */ 5546 satFreeIntIoResource( tiRoot, 5547 pSatDevData, 5548 satIntIo); 5549 5550 /* failed during sending SMART RETURN STATUS */ 5551 satSetSensePayload( pSense, 5552 SCSI_SNSKEY_NO_SENSE, 5553 0, 5554 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE, 5555 satIOContext); 5556 5557 ostiInitiatorIOCompleted( tiRoot, 5558 tiIORequest, 5559 tiIOSuccess, 5560 SCSI_STAT_GOOD, 5561 agNULL, 5562 satIOContext->interruptContext ); 5563 5564 TI_DBG4(("satRequestSense: else fail 1\n")); 5565 return tiSuccess; 5566 } /* end of memory allocation failure */ 5567 5568 5569 /* 5570 * Need to initialize all the fields within satIOContext except 5571 * reqType and satCompleteCB which will be set depending on cmd. 5572 */ 5573 5574 if (satIntIo == agNULL) 5575 { 5576 TI_DBG4(("satRequestSense: satIntIo is NULL\n")); 5577 } 5578 else 5579 { 5580 TI_DBG4(("satRequestSense: satIntIo is NOT NULL\n")); 5581 } 5582 /* use this --- tttttthe one the same */ 5583 5584 5585 satIntIo->satOrgTiIORequest = tiIORequest; 5586 tdIORequestBody = (tdIORequestBody_t *)satIntIo->satIntRequestBody; 5587 satIOContext2 = &(tdIORequestBody->transport.SATA.satIOContext); 5588 5589 satIOContext2->pSatDevData = pSatDevData; 5590 satIOContext2->pFis = &(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 5591 satIOContext2->pScsiCmnd = &(satIntIo->satIntTiScsiXchg.scsiCmnd); 5592 satIOContext2->pSense = &(tdIORequestBody->transport.SATA.sensePayload); 5593 satIOContext2->pTiSenseData = &(tdIORequestBody->transport.SATA.tiSenseData); 5594 satIOContext2->pTiSenseData->senseData = satIOContext2->pSense; 5595 satIOContext2->tiRequestBody = satIntIo->satIntRequestBody; 5596 satIOContext2->interruptContext = satIOContext->interruptContext; 5597 satIOContext2->satIntIoContext = satIntIo; 5598 satIOContext2->ptiDeviceHandle = tiDeviceHandle; 5599 satIOContext2->satOrgIOContext = satIOContext; 5600 5601 TI_DBG4(("satRequestSense: satIntIo->satIntTiScsiXchg.agSgl1.len %d\n", satIntIo->satIntTiScsiXchg.agSgl1.len)); 5602 5603 TI_DBG4(("satRequestSense: satIntIo->satIntTiScsiXchg.agSgl1.upper %d\n", satIntIo->satIntTiScsiXchg.agSgl1.upper)); 5604 5605 TI_DBG4(("satRequestSense: satIntIo->satIntTiScsiXchg.agSgl1.lower %d\n", satIntIo->satIntTiScsiXchg.agSgl1.lower)); 5606 5607 TI_DBG4(("satRequestSense: satIntIo->satIntTiScsiXchg.agSgl1.type %d\n", satIntIo->satIntTiScsiXchg.agSgl1.type)); 5608 5609 status = satRequestSense_1( tiRoot, 5610 &(satIntIo->satIntTiIORequest), 5611 tiDeviceHandle, 5612 &(satIntIo->satIntTiScsiXchg), 5613 satIOContext2); 5614 5615 if (status != tiSuccess) 5616 { 5617 satFreeIntIoResource( tiRoot, 5618 pSatDevData, 5619 satIntIo); 5620 5621 /* failed during sending SMART RETURN STATUS */ 5622 satSetSensePayload( pSense, 5623 SCSI_SNSKEY_NO_SENSE, 5624 0, 5625 SCSI_SNSCODE_HARDWARE_IMPENDING_FAILURE, 5626 satIOContext); 5627 5628 ostiInitiatorIOCompleted( tiRoot, 5629 tiIORequest, 5630 tiIOSuccess, 5631 SCSI_STAT_CHECK_CONDITION, 5632 agNULL, 5633 satIOContext->interruptContext ); 5634 5635 TI_DBG1(("satRequestSense: else fail 2\n")); 5636 return tiSuccess; 5637 } 5638 TI_DBG4(("satRequestSense: else return success\n")); 5639 return tiSuccess; 5640 } 5641 } 5642 5643 5644 /*****************************************************************************/ 5645 /*! \brief SAT implementation for SCSI REQUEST SENSE. 5646 * 5647 * SAT implementation for SCSI REQUEST SENSE. 5648 * Sub function of satRequestSense 5649 * 5650 * \param tiRoot: Pointer to TISA initiator driver/port instance. 5651 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 5652 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 5653 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 5654 * \param satIOContext_t: Pointer to the SAT IO Context 5655 * 5656 * \return If command is started successfully 5657 * - \e tiSuccess: I/O request successfully initiated. 5658 * - \e tiBusy: No resources available, try again later. 5659 * - \e tiIONoDevice: Invalid device handle. 5660 * - \e tiError: Other errors. 5661 */ 5662 /*****************************************************************************/ 5663 GLOBAL bit32 satRequestSense_1( 5664 tiRoot_t *tiRoot, 5665 tiIORequest_t *tiIORequest, 5666 tiDeviceHandle_t *tiDeviceHandle, 5667 tiScsiInitiatorRequest_t *tiScsiRequest, 5668 satIOContext_t *satIOContext) 5669 { 5670 /* 5671 sends SAT_CHECK_POWER_MODE 5672 */ 5673 bit32 status; 5674 bit32 agRequestType; 5675 agsaFisRegHostToDevice_t *fis; 5676 5677 TI_DBG4(("satRequestSense_1 entry: tiDeviceHandle=%p tiIORequest=%p\n", 5678 tiDeviceHandle, tiIORequest)); 5679 5680 fis = satIOContext->pFis; 5681 /* 5682 * Send the ATA CHECK POWER MODE command. 5683 */ 5684 fis->h.fisType = 0x27; /* Reg host to device */ 5685 fis->h.c_pmPort = 0x80; /* C Bit is set */ 5686 5687 fis->h.command = SAT_CHECK_POWER_MODE; /* 0xE5 */ 5688 fis->h.features = 0; 5689 fis->d.lbaLow = 0; 5690 fis->d.lbaMid = 0; 5691 fis->d.lbaHigh = 0; 5692 fis->d.device = 0; 5693 fis->d.lbaLowExp = 0; 5694 fis->d.lbaMidExp = 0; 5695 fis->d.lbaHighExp = 0; 5696 fis->d.featuresExp = 0; 5697 fis->d.sectorCount = 0; 5698 fis->d.sectorCountExp = 0; 5699 fis->d.reserved4 = 0; 5700 fis->d.control = 0; /* FIS HOB bit clear */ 5701 fis->d.reserved5 = 0; 5702 5703 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 5704 5705 /* Initialize CB for SATA completion. 5706 */ 5707 satIOContext->satCompleteCB = &satRequestSenseCB; 5708 5709 /* 5710 * Prepare SGL and send FIS to LL layer. 5711 */ 5712 satIOContext->reqType = agRequestType; /* Save it */ 5713 5714 5715 TI_DBG4(("satRequestSense_1: agSgl1.len %d\n", tiScsiRequest->agSgl1.len)); 5716 5717 TI_DBG4(("satRequestSense_1: agSgl1.upper %d\n", tiScsiRequest->agSgl1.upper)); 5718 5719 TI_DBG4(("satRequestSense_1: agSgl1.lower %d\n", tiScsiRequest->agSgl1.lower)); 5720 5721 TI_DBG4(("satRequestSense_1: agSgl1.type %d\n", tiScsiRequest->agSgl1.type)); 5722 5723 // tdhexdump("satRequestSense_1", (bit8 *)fis, sizeof(agsaFisRegHostToDevice_t)); 5724 5725 status = sataLLIOStart( tiRoot, 5726 tiIORequest, 5727 tiDeviceHandle, 5728 tiScsiRequest, 5729 satIOContext); 5730 5731 5732 5733 return status; 5734 } 5735 5736 5737 /*****************************************************************************/ 5738 /*! \brief SAT implementation for SCSI INQUIRY. 5739 * 5740 * SAT implementation for SCSI INQUIRY. 5741 * 5742 * \param tiRoot: Pointer to TISA initiator driver/port instance. 5743 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 5744 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 5745 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 5746 * \param satIOContext_t: Pointer to the SAT IO Context 5747 * 5748 * \return If command is started successfully 5749 * - \e tiSuccess: I/O request successfully initiated. 5750 * - \e tiBusy: No resources available, try again later. 5751 * - \e tiIONoDevice: Invalid device handle. 5752 * - \e tiError: Other errors. 5753 */ 5754 /*****************************************************************************/ 5755 GLOBAL bit32 satInquiry( 5756 tiRoot_t *tiRoot, 5757 tiIORequest_t *tiIORequest, 5758 tiDeviceHandle_t *tiDeviceHandle, 5759 tiScsiInitiatorRequest_t *tiScsiRequest, 5760 satIOContext_t *satIOContext) 5761 { 5762 /* 5763 CMDDT bit is obsolete in SPC-3 and this is assumed in SAT revision 8 5764 */ 5765 scsiRspSense_t *pSense; 5766 tiIniScsiCmnd_t *scsiCmnd; 5767 satDeviceData_t *pSatDevData; 5768 bit32 status; 5769 5770 TI_DBG5(("satInquiry: start\n")); 5771 TI_DBG5(("satInquiry entry: tiDeviceHandle=%p tiIORequest=%p\n", 5772 tiDeviceHandle, tiIORequest)); 5773 pSense = satIOContext->pSense; 5774 scsiCmnd = &tiScsiRequest->scsiCmnd; 5775 pSatDevData = satIOContext->pSatDevData; 5776 TI_DBG5(("satInquiry: pSatDevData=%p\n", pSatDevData)); 5777 //tdhexdump("satInquiry", (bit8 *)scsiCmnd->cdb, 6); 5778 /* checking CONTROL */ 5779 /* NACA == 1 or LINK == 1*/ 5780 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 5781 { 5782 satSetSensePayload( pSense, 5783 SCSI_SNSKEY_ILLEGAL_REQUEST, 5784 0, 5785 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 5786 satIOContext); 5787 ostiInitiatorIOCompleted( tiRoot, 5788 tiIORequest, 5789 tiIOSuccess, 5790 SCSI_STAT_CHECK_CONDITION, 5791 satIOContext->pTiSenseData, 5792 satIOContext->interruptContext ); 5793 TI_DBG2(("satInquiry: return control\n")); 5794 return tiSuccess; 5795 } 5796 5797 /* checking EVPD and Allocation Length */ 5798 /* SPC-4 spec 6.4 p141 */ 5799 /* EVPD bit == 0 && PAGE CODE != 0 */ 5800 if ( !(scsiCmnd->cdb[1] & SCSI_EVPD_MASK) && 5801 (scsiCmnd->cdb[2] != 0) 5802 ) 5803 { 5804 satSetSensePayload( pSense, 5805 SCSI_SNSKEY_ILLEGAL_REQUEST, 5806 0, 5807 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 5808 satIOContext); 5809 ostiInitiatorIOCompleted( tiRoot, 5810 tiIORequest, 5811 tiIOSuccess, 5812 SCSI_STAT_CHECK_CONDITION, 5813 satIOContext->pTiSenseData, 5814 satIOContext->interruptContext ); 5815 TI_DBG1(("satInquiry: return EVPD and PAGE CODE\n")); 5816 return tiSuccess; 5817 } 5818 TI_DBG6(("satInquiry: allocation length 0x%x %d\n", ((scsiCmnd->cdb[3]) << 8) + scsiCmnd->cdb[4], ((scsiCmnd->cdb[3]) << 8) + scsiCmnd->cdb[4])); 5819 5820 /* convert OS IO to TD internal IO */ 5821 if ( pSatDevData->IDDeviceValid == agFALSE) 5822 { 5823 status = satStartIDDev( 5824 tiRoot, 5825 tiIORequest, 5826 tiDeviceHandle, 5827 tiScsiRequest, 5828 satIOContext 5829 ); 5830 TI_DBG6(("satInquiry: end status %d\n", status)); 5831 return status; 5832 } 5833 else 5834 { 5835 TI_DBG6(("satInquiry: calling satInquiryIntCB\n")); 5836 satInquiryIntCB( 5837 tiRoot, 5838 tiIORequest, 5839 tiDeviceHandle, 5840 tiScsiRequest, 5841 satIOContext 5842 ); 5843 5844 return tiSuccess; 5845 } 5846 5847 } 5848 5849 5850 /*****************************************************************************/ 5851 /*! \brief SAT implementation for SCSI satReadCapacity10. 5852 * 5853 * SAT implementation for SCSI satReadCapacity10. 5854 * 5855 * \param tiRoot: Pointer to TISA initiator driver/port instance. 5856 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 5857 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 5858 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 5859 * \param satIOContext_t: Pointer to the SAT IO Context 5860 * 5861 * \return If command is started successfully 5862 * - \e tiSuccess: I/O request successfully initiated. 5863 * - \e tiBusy: No resources available, try again later. 5864 * - \e tiIONoDevice: Invalid device handle. 5865 * - \e tiError: Other errors. 5866 */ 5867 /*****************************************************************************/ 5868 GLOBAL bit32 satReadCapacity10( 5869 tiRoot_t *tiRoot, 5870 tiIORequest_t *tiIORequest, 5871 tiDeviceHandle_t *tiDeviceHandle, 5872 tiScsiInitiatorRequest_t *tiScsiRequest, 5873 satIOContext_t *satIOContext) 5874 { 5875 scsiRspSense_t *pSense; 5876 tiIniScsiCmnd_t *scsiCmnd; 5877 bit8 *pVirtAddr; 5878 satDeviceData_t *pSatDevData; 5879 agsaSATAIdentifyData_t *pSATAIdData; 5880 bit32 lastLba; 5881 bit32 word117_118; 5882 bit32 word117; 5883 bit32 word118; 5884 TI_DBG5(("satReadCapacity10: start: tiDeviceHandle=%p tiIORequest=%p\n", 5885 tiDeviceHandle, tiIORequest)); 5886 5887 pSense = satIOContext->pSense; 5888 pVirtAddr = (bit8 *) tiScsiRequest->sglVirtualAddr; 5889 scsiCmnd = &tiScsiRequest->scsiCmnd; 5890 pSatDevData = satIOContext->pSatDevData; 5891 pSATAIdData = &pSatDevData->satIdentifyData; 5892 5893 5894 /* checking CONTROL */ 5895 /* NACA == 1 or LINK == 1*/ 5896 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 5897 { 5898 satSetSensePayload( pSense, 5899 SCSI_SNSKEY_ILLEGAL_REQUEST, 5900 0, 5901 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 5902 satIOContext); 5903 5904 ostiInitiatorIOCompleted( tiRoot, 5905 tiIORequest, 5906 tiIOSuccess, 5907 SCSI_STAT_CHECK_CONDITION, 5908 satIOContext->pTiSenseData, 5909 satIOContext->interruptContext ); 5910 5911 TI_DBG1(("satReadCapacity10: return control\n")); 5912 return tiSuccess; 5913 } 5914 5915 5916 /* 5917 * If Logical block address is not set to zero, return error 5918 */ 5919 if ((scsiCmnd->cdb[2] || scsiCmnd->cdb[3] || scsiCmnd->cdb[4] || scsiCmnd->cdb[5])) 5920 { 5921 TI_DBG1(("satReadCapacity10 *** ERROR *** logical address non zero, tiDeviceHandle=%p tiIORequest=%p\n", 5922 tiDeviceHandle, tiIORequest)); 5923 5924 satSetSensePayload( pSense, 5925 SCSI_SNSKEY_ILLEGAL_REQUEST, 5926 0, 5927 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 5928 satIOContext); 5929 5930 ostiInitiatorIOCompleted( tiRoot, 5931 tiIORequest, 5932 tiIOSuccess, 5933 SCSI_STAT_CHECK_CONDITION, 5934 satIOContext->pTiSenseData, 5935 satIOContext->interruptContext ); 5936 return tiSuccess; 5937 5938 } 5939 5940 /* 5941 * If PMI bit is not zero, return error 5942 */ 5943 if ( ((scsiCmnd->cdb[8]) & SCSI_READ_CAPACITY10_PMI_MASK) != 0 ) 5944 { 5945 TI_DBG1(("satReadCapacity10 *** ERROR *** PMI is not zero, tiDeviceHandle=%p tiIORequest=%p\n", 5946 tiDeviceHandle, tiIORequest)); 5947 5948 satSetSensePayload( pSense, 5949 SCSI_SNSKEY_ILLEGAL_REQUEST, 5950 0, 5951 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 5952 satIOContext); 5953 5954 ostiInitiatorIOCompleted( tiRoot, 5955 tiIORequest, 5956 tiIOSuccess, 5957 SCSI_STAT_CHECK_CONDITION, 5958 satIOContext->pTiSenseData, 5959 satIOContext->interruptContext ); 5960 return tiSuccess; 5961 5962 } 5963 5964 /* 5965 filling in Read Capacity parameter data 5966 saved identify device has been already flipped 5967 See ATA spec p125 and p136 and SBC spec p54 5968 */ 5969 /* 5970 * If 48-bit addressing is supported, set capacity information from Identify 5971 * Device Word 100-103. 5972 */ 5973 if (pSatDevData->sat48BitSupport == agTRUE) 5974 { 5975 /* 5976 * Setting RETURNED LOGICAL BLOCK ADDRESS in READ CAPACITY(10) response data: 5977 * SBC-2 specifies that if the capacity exceeded the 4-byte RETURNED LOGICAL 5978 * BLOCK ADDRESS in READ CAPACITY(10) parameter data, the RETURNED LOGICAL 5979 * BLOCK ADDRESS should be set to 0xFFFFFFFF so the application client would 5980 * then issue a READ CAPACITY(16) command. 5981 */ 5982 /* ATA Identify Device information word 100 - 103 */ 5983 if ( (pSATAIdData->maxLBA32_47 != 0 ) || (pSATAIdData->maxLBA48_63 != 0)) 5984 { 5985 pVirtAddr[0] = 0xFF; /* MSB number of block */ 5986 pVirtAddr[1] = 0xFF; 5987 pVirtAddr[2] = 0xFF; 5988 pVirtAddr[3] = 0xFF; /* LSB number of block */ 5989 TI_DBG1(("satReadCapacity10: returns 0xFFFFFFFF\n")); 5990 } 5991 else /* Fit the Readcapacity10 4-bytes response length */ 5992 { 5993 lastLba = (((pSATAIdData->maxLBA16_31) << 16) ) | 5994 (pSATAIdData->maxLBA0_15); 5995 lastLba = lastLba - 1; /* LBA starts from zero */ 5996 5997 /* 5998 for testing 5999 lastLba = lastLba - (512*10) - 1; 6000 */ 6001 6002 6003 pVirtAddr[0] = (bit8)((lastLba >> 24) & 0xFF); /* MSB */ 6004 pVirtAddr[1] = (bit8)((lastLba >> 16) & 0xFF); 6005 pVirtAddr[2] = (bit8)((lastLba >> 8) & 0xFF); 6006 pVirtAddr[3] = (bit8)((lastLba ) & 0xFF); /* LSB */ 6007 6008 TI_DBG3(("satReadCapacity10: lastLba is 0x%x %d\n", lastLba, lastLba)); 6009 TI_DBG3(("satReadCapacity10: LBA 0 is 0x%x %d\n", pVirtAddr[0], pVirtAddr[0])); 6010 TI_DBG3(("satReadCapacity10: LBA 1 is 0x%x %d\n", pVirtAddr[1], pVirtAddr[1])); 6011 TI_DBG3(("satReadCapacity10: LBA 2 is 0x%x %d\n", pVirtAddr[2], pVirtAddr[2])); 6012 TI_DBG3(("satReadCapacity10: LBA 3 is 0x%x %d\n", pVirtAddr[3], pVirtAddr[3])); 6013 6014 } 6015 } 6016 6017 /* 6018 * For 28-bit addressing, set capacity information from Identify 6019 * Device Word 60-61. 6020 */ 6021 else 6022 { 6023 /* ATA Identify Device information word 60 - 61 */ 6024 lastLba = (((pSATAIdData->numOfUserAddressableSectorsHi) << 16) ) | 6025 (pSATAIdData->numOfUserAddressableSectorsLo); 6026 lastLba = lastLba - 1; /* LBA starts from zero */ 6027 6028 pVirtAddr[0] = (bit8)((lastLba >> 24) & 0xFF); /* MSB */ 6029 pVirtAddr[1] = (bit8)((lastLba >> 16) & 0xFF); 6030 pVirtAddr[2] = (bit8)((lastLba >> 8) & 0xFF); 6031 pVirtAddr[3] = (bit8)((lastLba ) & 0xFF); /* LSB */ 6032 } 6033 /* SAT Rev 8d */ 6034 if (((pSATAIdData->word104_107[2]) & 0x1000) == 0) 6035 { 6036 TI_DBG5(("satReadCapacity10: Default Block Length is 512\n")); 6037 /* 6038 * Set the block size, fixed at 512 bytes. 6039 */ 6040 pVirtAddr[4] = 0x00; /* MSB block size in bytes */ 6041 pVirtAddr[5] = 0x00; 6042 pVirtAddr[6] = 0x02; 6043 pVirtAddr[7] = 0x00; /* LSB block size in bytes */ 6044 } 6045 else 6046 { 6047 word118 = pSATAIdData->word112_126[6]; 6048 word117 = pSATAIdData->word112_126[5]; 6049 6050 word117_118 = (word118 << 16) + word117; 6051 word117_118 = word117_118 * 2; 6052 pVirtAddr[4] = (bit8)((word117_118 >> 24) & 0xFF); /* MSB block size in bytes */ 6053 pVirtAddr[5] = (bit8)((word117_118 >> 16) & 0xFF); 6054 pVirtAddr[6] = (bit8)((word117_118 >> 8) & 0xFF); 6055 pVirtAddr[7] = (bit8)(word117_118 & 0xFF); /* LSB block size in bytes */ 6056 6057 TI_DBG1(("satReadCapacity10: Nondefault word118 %d 0x%x \n", word118, word118)); 6058 TI_DBG1(("satReadCapacity10: Nondefault word117 %d 0x%x \n", word117, word117)); 6059 TI_DBG1(("satReadCapacity10: Nondefault Block Length is %d 0x%x \n",word117_118, word117_118)); 6060 6061 } 6062 6063 /* fill in MAX LBA, which is used in satSendDiagnostic_1() */ 6064 pSatDevData->satMaxLBA[0] = 0; /* MSB */ 6065 pSatDevData->satMaxLBA[1] = 0; 6066 pSatDevData->satMaxLBA[2] = 0; 6067 pSatDevData->satMaxLBA[3] = 0; 6068 pSatDevData->satMaxLBA[4] = pVirtAddr[0]; 6069 pSatDevData->satMaxLBA[5] = pVirtAddr[1]; 6070 pSatDevData->satMaxLBA[6] = pVirtAddr[2]; 6071 pSatDevData->satMaxLBA[7] = pVirtAddr[3]; /* LSB */ 6072 6073 6074 TI_DBG4(("satReadCapacity10 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x , tiDeviceHandle=%p tiIORequest=%p\n", 6075 pVirtAddr[0], pVirtAddr[1], pVirtAddr[2], pVirtAddr[3], 6076 pVirtAddr[4], pVirtAddr[5], pVirtAddr[6], pVirtAddr[7], 6077 tiDeviceHandle, tiIORequest)); 6078 6079 6080 /* 6081 * Send the completion response now. 6082 */ 6083 ostiInitiatorIOCompleted( tiRoot, 6084 tiIORequest, 6085 tiIOSuccess, 6086 SCSI_STAT_GOOD, 6087 agNULL, 6088 satIOContext->interruptContext); 6089 return tiSuccess; 6090 } 6091 6092 6093 /*****************************************************************************/ 6094 /*! \brief SAT implementation for SCSI satReadCapacity16. 6095 * 6096 * SAT implementation for SCSI satReadCapacity16. 6097 * 6098 * \param tiRoot: Pointer to TISA initiator driver/port instance. 6099 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 6100 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 6101 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 6102 * \param satIOContext_t: Pointer to the SAT IO Context 6103 * 6104 * \return If command is started successfully 6105 * - \e tiSuccess: I/O request successfully initiated. 6106 * - \e tiBusy: No resources available, try again later. 6107 * - \e tiIONoDevice: Invalid device handle. 6108 * - \e tiError: Other errors. 6109 */ 6110 /*****************************************************************************/ 6111 GLOBAL bit32 satReadCapacity16( 6112 tiRoot_t *tiRoot, 6113 tiIORequest_t *tiIORequest, 6114 tiDeviceHandle_t *tiDeviceHandle, 6115 tiScsiInitiatorRequest_t *tiScsiRequest, 6116 satIOContext_t *satIOContext) 6117 { 6118 6119 scsiRspSense_t *pSense; 6120 tiIniScsiCmnd_t *scsiCmnd; 6121 bit8 *pVirtAddr; 6122 satDeviceData_t *pSatDevData; 6123 agsaSATAIdentifyData_t *pSATAIdData; 6124 bit32 lastLbaLo; 6125 bit32 allocationLen; 6126 bit32 readCapacityLen = 32; 6127 bit32 i = 0; 6128 TI_DBG5(("satReadCapacity16 start: tiDeviceHandle=%p tiIORequest=%p\n", 6129 tiDeviceHandle, tiIORequest)); 6130 6131 pSense = satIOContext->pSense; 6132 pVirtAddr = (bit8 *) tiScsiRequest->sglVirtualAddr; 6133 scsiCmnd = &tiScsiRequest->scsiCmnd; 6134 pSatDevData = satIOContext->pSatDevData; 6135 pSATAIdData = &pSatDevData->satIdentifyData; 6136 6137 /* Find the buffer size allocated by Initiator */ 6138 allocationLen = (((bit32)scsiCmnd->cdb[10]) << 24) | 6139 (((bit32)scsiCmnd->cdb[11]) << 16) | 6140 (((bit32)scsiCmnd->cdb[12]) << 8 ) | 6141 (((bit32)scsiCmnd->cdb[13]) ); 6142 6143 6144 if (allocationLen < readCapacityLen) 6145 { 6146 TI_DBG1(("satReadCapacity16 *** ERROR *** insufficient len=0x%x readCapacityLen=0x%x\n", allocationLen, readCapacityLen)); 6147 6148 satSetSensePayload( pSense, 6149 SCSI_SNSKEY_ILLEGAL_REQUEST, 6150 0, 6151 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 6152 satIOContext); 6153 6154 ostiInitiatorIOCompleted( tiRoot, 6155 tiIORequest, 6156 tiIOSuccess, 6157 SCSI_STAT_CHECK_CONDITION, 6158 satIOContext->pTiSenseData, 6159 satIOContext->interruptContext ); 6160 return tiSuccess; 6161 6162 } 6163 6164 /* checking CONTROL */ 6165 /* NACA == 1 or LINK == 1*/ 6166 if ( (scsiCmnd->cdb[15] & SCSI_NACA_MASK) || (scsiCmnd->cdb[15] & SCSI_LINK_MASK) ) 6167 { 6168 satSetSensePayload( pSense, 6169 SCSI_SNSKEY_ILLEGAL_REQUEST, 6170 0, 6171 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 6172 satIOContext); 6173 6174 ostiInitiatorIOCompleted( tiRoot, 6175 tiIORequest, 6176 tiIOSuccess, 6177 SCSI_STAT_CHECK_CONDITION, 6178 satIOContext->pTiSenseData, 6179 satIOContext->interruptContext ); 6180 6181 TI_DBG1(("satReadCapacity16: return control\n")); 6182 return tiSuccess; 6183 } 6184 6185 /* 6186 * If Logical blcok address is not set to zero, return error 6187 */ 6188 if ((scsiCmnd->cdb[2] || scsiCmnd->cdb[3] || scsiCmnd->cdb[4] || scsiCmnd->cdb[5]) || 6189 (scsiCmnd->cdb[6] || scsiCmnd->cdb[7] || scsiCmnd->cdb[8] || scsiCmnd->cdb[9]) ) 6190 { 6191 TI_DBG1(("satReadCapacity16 *** ERROR *** logical address non zero, tiDeviceHandle=%p tiIORequest=%p\n", 6192 tiDeviceHandle, tiIORequest)); 6193 6194 satSetSensePayload( pSense, 6195 SCSI_SNSKEY_ILLEGAL_REQUEST, 6196 0, 6197 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 6198 satIOContext); 6199 6200 ostiInitiatorIOCompleted( tiRoot, 6201 tiIORequest, 6202 tiIOSuccess, 6203 SCSI_STAT_CHECK_CONDITION, 6204 satIOContext->pTiSenseData, 6205 satIOContext->interruptContext ); 6206 return tiSuccess; 6207 6208 } 6209 6210 /* 6211 * If PMI bit is not zero, return error 6212 */ 6213 if ( ((scsiCmnd->cdb[14]) & SCSI_READ_CAPACITY16_PMI_MASK) != 0 ) 6214 { 6215 TI_DBG1(("satReadCapacity16 *** ERROR *** PMI is not zero, tiDeviceHandle=%p tiIORequest=%p\n", 6216 tiDeviceHandle, tiIORequest)); 6217 6218 satSetSensePayload( pSense, 6219 SCSI_SNSKEY_ILLEGAL_REQUEST, 6220 0, 6221 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 6222 satIOContext); 6223 6224 ostiInitiatorIOCompleted( tiRoot, 6225 tiIORequest, 6226 tiIOSuccess, 6227 SCSI_STAT_CHECK_CONDITION, 6228 satIOContext->pTiSenseData, 6229 satIOContext->interruptContext ); 6230 return tiSuccess; 6231 6232 } 6233 6234 /* 6235 filling in Read Capacity parameter data 6236 */ 6237 6238 /* 6239 * If 48-bit addressing is supported, set capacity information from Identify 6240 * Device Word 100-103. 6241 */ 6242 if (pSatDevData->sat48BitSupport == agTRUE) 6243 { 6244 pVirtAddr[0] = (bit8)(((pSATAIdData->maxLBA48_63) >> 8) & 0xff); /* MSB */ 6245 pVirtAddr[1] = (bit8)((pSATAIdData->maxLBA48_63) & 0xff); 6246 pVirtAddr[2] = (bit8)(((pSATAIdData->maxLBA32_47) >> 8) & 0xff); 6247 pVirtAddr[3] = (bit8)((pSATAIdData->maxLBA32_47) & 0xff); 6248 6249 lastLbaLo = (((pSATAIdData->maxLBA16_31) << 16) ) | (pSATAIdData->maxLBA0_15); 6250 lastLbaLo = lastLbaLo - 1; /* LBA starts from zero */ 6251 6252 pVirtAddr[4] = (bit8)((lastLbaLo >> 24) & 0xFF); 6253 pVirtAddr[5] = (bit8)((lastLbaLo >> 16) & 0xFF); 6254 pVirtAddr[6] = (bit8)((lastLbaLo >> 8) & 0xFF); 6255 pVirtAddr[7] = (bit8)((lastLbaLo ) & 0xFF); /* LSB */ 6256 6257 } 6258 6259 /* 6260 * For 28-bit addressing, set capacity information from Identify 6261 * Device Word 60-61. 6262 */ 6263 else 6264 { 6265 pVirtAddr[0] = 0; /* MSB */ 6266 pVirtAddr[1] = 0; 6267 pVirtAddr[2] = 0; 6268 pVirtAddr[3] = 0; 6269 6270 lastLbaLo = (((pSATAIdData->numOfUserAddressableSectorsHi) << 16) ) | 6271 (pSATAIdData->numOfUserAddressableSectorsLo); 6272 lastLbaLo = lastLbaLo - 1; /* LBA starts from zero */ 6273 6274 pVirtAddr[4] = (bit8)((lastLbaLo >> 24) & 0xFF); 6275 pVirtAddr[5] = (bit8)((lastLbaLo >> 16) & 0xFF); 6276 pVirtAddr[6] = (bit8)((lastLbaLo >> 8) & 0xFF); 6277 pVirtAddr[7] = (bit8)((lastLbaLo ) & 0xFF); /* LSB */ 6278 6279 } 6280 6281 /* 6282 * Set the block size, fixed at 512 bytes. 6283 */ 6284 pVirtAddr[8] = 0x00; /* MSB block size in bytes */ 6285 pVirtAddr[9] = 0x00; 6286 pVirtAddr[10] = 0x02; 6287 pVirtAddr[11] = 0x00; /* LSB block size in bytes */ 6288 6289 6290 /* fill in MAX LBA, which is used in satSendDiagnostic_1() */ 6291 pSatDevData->satMaxLBA[0] = pVirtAddr[0]; /* MSB */ 6292 pSatDevData->satMaxLBA[1] = pVirtAddr[1]; 6293 pSatDevData->satMaxLBA[2] = pVirtAddr[2]; 6294 pSatDevData->satMaxLBA[3] = pVirtAddr[3]; 6295 pSatDevData->satMaxLBA[4] = pVirtAddr[4]; 6296 pSatDevData->satMaxLBA[5] = pVirtAddr[5]; 6297 pSatDevData->satMaxLBA[6] = pVirtAddr[6]; 6298 pSatDevData->satMaxLBA[7] = pVirtAddr[7]; /* LSB */ 6299 6300 TI_DBG5(("satReadCapacity16 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x , tiDeviceHandle=%p tiIORequest=%p\n", 6301 pVirtAddr[0], pVirtAddr[1], pVirtAddr[2], pVirtAddr[3], 6302 pVirtAddr[4], pVirtAddr[5], pVirtAddr[6], pVirtAddr[7], 6303 pVirtAddr[8], pVirtAddr[9], pVirtAddr[10], pVirtAddr[11], 6304 tiDeviceHandle, tiIORequest)); 6305 6306 for(i=12;i<=31;i++) 6307 { 6308 pVirtAddr[i] = 0x00; 6309 } 6310 6311 /* 6312 * Send the completion response now. 6313 */ 6314 if (allocationLen > readCapacityLen) 6315 { 6316 /* underrun */ 6317 TI_DBG1(("satReadCapacity16 reporting underrun readCapacityLen=0x%x allocationLen=0x%x \n", readCapacityLen, allocationLen)); 6318 6319 ostiInitiatorIOCompleted( tiRoot, 6320 tiIORequest, 6321 tiIOUnderRun, 6322 allocationLen - readCapacityLen, 6323 agNULL, 6324 satIOContext->interruptContext ); 6325 6326 6327 } 6328 else 6329 { 6330 ostiInitiatorIOCompleted( tiRoot, 6331 tiIORequest, 6332 tiIOSuccess, 6333 SCSI_STAT_GOOD, 6334 agNULL, 6335 satIOContext->interruptContext); 6336 } 6337 return tiSuccess; 6338 6339 } 6340 6341 6342 /*****************************************************************************/ 6343 /*! \brief SAT implementation for SCSI MODE SENSE (6). 6344 * 6345 * SAT implementation for SCSI MODE SENSE (6). 6346 * 6347 * \param tiRoot: Pointer to TISA initiator driver/port instance. 6348 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 6349 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 6350 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 6351 * \param satIOContext_t: Pointer to the SAT IO Context 6352 * 6353 * \return If command is started successfully 6354 * - \e tiSuccess: I/O request successfully initiated. 6355 * - \e tiBusy: No resources available, try again later. 6356 * - \e tiIONoDevice: Invalid device handle. 6357 * - \e tiError: Other errors. 6358 */ 6359 /*****************************************************************************/ 6360 GLOBAL bit32 satModeSense6( 6361 tiRoot_t *tiRoot, 6362 tiIORequest_t *tiIORequest, 6363 tiDeviceHandle_t *tiDeviceHandle, 6364 tiScsiInitiatorRequest_t *tiScsiRequest, 6365 satIOContext_t *satIOContext) 6366 { 6367 6368 scsiRspSense_t *pSense; 6369 bit32 requestLen; 6370 tiIniScsiCmnd_t *scsiCmnd; 6371 bit32 pageSupported; 6372 bit8 page; 6373 bit8 *pModeSense; /* Mode Sense data buffer */ 6374 satDeviceData_t *pSatDevData; 6375 bit8 PC; 6376 bit8 AllPages[MODE_SENSE6_RETURN_ALL_PAGES_LEN]; 6377 bit8 Control[MODE_SENSE6_CONTROL_PAGE_LEN]; 6378 bit8 RWErrorRecovery[MODE_SENSE6_READ_WRITE_ERROR_RECOVERY_PAGE_LEN]; 6379 bit8 Caching[MODE_SENSE6_CACHING_LEN]; 6380 bit8 InfoExceptionCtrl[MODE_SENSE6_INFORMATION_EXCEPTION_CONTROL_PAGE_LEN]; 6381 bit8 lenRead = 0; 6382 6383 6384 TI_DBG5(("satModeSense6 entry: tiDeviceHandle=%p tiIORequest=%p\n", 6385 tiDeviceHandle, tiIORequest)); 6386 6387 pSense = satIOContext->pSense; 6388 scsiCmnd = &tiScsiRequest->scsiCmnd; 6389 pModeSense = (bit8 *) tiScsiRequest->sglVirtualAddr; 6390 pSatDevData = satIOContext->pSatDevData; 6391 6392 //tdhexdump("satModeSense6", (bit8 *)scsiCmnd->cdb, 6); 6393 /* checking CONTROL */ 6394 /* NACA == 1 or LINK == 1*/ 6395 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 6396 { 6397 satSetSensePayload( pSense, 6398 SCSI_SNSKEY_ILLEGAL_REQUEST, 6399 0, 6400 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 6401 satIOContext); 6402 6403 ostiInitiatorIOCompleted( tiRoot, 6404 tiIORequest, 6405 tiIOSuccess, 6406 SCSI_STAT_CHECK_CONDITION, 6407 satIOContext->pTiSenseData, 6408 satIOContext->interruptContext ); 6409 6410 TI_DBG2(("satModeSense6: return control\n")); 6411 return tiSuccess; 6412 } 6413 6414 /* checking PC(Page Control) 6415 SAT revion 8, 8.5.3 p33 and 10.1.2, p66 6416 */ 6417 PC = (bit8)((scsiCmnd->cdb[2]) & SCSI_MODE_SENSE6_PC_MASK); 6418 if (PC != 0) 6419 { 6420 satSetSensePayload( pSense, 6421 SCSI_SNSKEY_ILLEGAL_REQUEST, 6422 0, 6423 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 6424 satIOContext); 6425 6426 ostiInitiatorIOCompleted( tiRoot, 6427 tiIORequest, 6428 tiIOSuccess, 6429 SCSI_STAT_CHECK_CONDITION, 6430 satIOContext->pTiSenseData, 6431 satIOContext->interruptContext ); 6432 6433 TI_DBG1(("satModeSense6: return due to PC value pc 0x%x\n", PC >> 6)); 6434 return tiSuccess; 6435 } 6436 6437 /* reading PAGE CODE */ 6438 page = (bit8)((scsiCmnd->cdb[2]) & SCSI_MODE_SENSE6_PAGE_CODE_MASK); 6439 6440 6441 TI_DBG5(("satModeSense6: page=0x%x, tiDeviceHandle=%p tiIORequest=%p\n", 6442 page, tiDeviceHandle, tiIORequest)); 6443 6444 requestLen = scsiCmnd->cdb[4]; 6445 6446 /* 6447 Based on page code value, returns a corresponding mode page 6448 note: no support for subpage 6449 */ 6450 6451 switch(page) 6452 { 6453 case MODESENSE_RETURN_ALL_PAGES: 6454 case MODESENSE_CONTROL_PAGE: /* control */ 6455 case MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE: /* Read-Write Error Recovery */ 6456 case MODESENSE_CACHING: /* caching */ 6457 case MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE: /* informational exceptions control*/ 6458 pageSupported = agTRUE; 6459 break; 6460 case MODESENSE_VENDOR_SPECIFIC_PAGE: /* vendor specific */ 6461 default: 6462 pageSupported = agFALSE; 6463 break; 6464 } 6465 6466 if (pageSupported == agFALSE) 6467 { 6468 6469 TI_DBG1(("satModeSense6 *** ERROR *** not supported page 0x%x tiDeviceHandle=%p tiIORequest=%p\n", 6470 page, tiDeviceHandle, tiIORequest)); 6471 6472 satSetSensePayload( pSense, 6473 SCSI_SNSKEY_ILLEGAL_REQUEST, 6474 0, 6475 SCSI_SNSCODE_INVALID_COMMAND, 6476 satIOContext); 6477 6478 ostiInitiatorIOCompleted( tiRoot, 6479 tiIORequest, 6480 tiIOSuccess, 6481 SCSI_STAT_CHECK_CONDITION, 6482 satIOContext->pTiSenseData, 6483 satIOContext->interruptContext ); 6484 return tiSuccess; 6485 } 6486 6487 switch(page) 6488 { 6489 case MODESENSE_RETURN_ALL_PAGES: 6490 lenRead = (bit8)MIN(requestLen, MODE_SENSE6_RETURN_ALL_PAGES_LEN); 6491 break; 6492 case MODESENSE_CONTROL_PAGE: /* control */ 6493 lenRead = (bit8)MIN(requestLen, MODE_SENSE6_CONTROL_PAGE_LEN); 6494 break; 6495 case MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE: /* Read-Write Error Recovery */ 6496 lenRead = (bit8)MIN(requestLen, MODE_SENSE6_READ_WRITE_ERROR_RECOVERY_PAGE_LEN); 6497 break; 6498 case MODESENSE_CACHING: /* caching */ 6499 lenRead = (bit8)MIN(requestLen, MODE_SENSE6_CACHING_LEN); 6500 break; 6501 case MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE: /* informational exceptions control*/ 6502 lenRead = (bit8)MIN(requestLen, MODE_SENSE6_INFORMATION_EXCEPTION_CONTROL_PAGE_LEN); 6503 break; 6504 default: 6505 TI_DBG1(("satModeSense6: default error page %d\n", page)); 6506 break; 6507 } 6508 6509 if (page == MODESENSE_RETURN_ALL_PAGES) 6510 { 6511 TI_DBG5(("satModeSense6: MODESENSE_RETURN_ALL_PAGES\n")); 6512 AllPages[0] = (bit8)(lenRead - 1); 6513 AllPages[1] = 0x00; /* default medium type (currently mounted medium type) */ 6514 AllPages[2] = 0x00; /* no write-protect, no support for DPO-FUA */ 6515 AllPages[3] = 0x08; /* block descriptor length */ 6516 6517 /* 6518 * Fill-up direct-access device block-descriptor, SAT, Table 19 6519 */ 6520 6521 /* density code */ 6522 AllPages[4] = 0x04; /* density-code : reserved for direct-access */ 6523 /* number of blocks */ 6524 AllPages[5] = 0x00; /* unspecified */ 6525 AllPages[6] = 0x00; /* unspecified */ 6526 AllPages[7] = 0x00; /* unspecified */ 6527 /* reserved */ 6528 AllPages[8] = 0x00; /* reserved */ 6529 /* Block size */ 6530 AllPages[9] = 0x00; 6531 AllPages[10] = 0x02; /* Block size is always 512 bytes */ 6532 AllPages[11] = 0x00; 6533 6534 /* MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE */ 6535 AllPages[12] = 0x01; /* page code */ 6536 AllPages[13] = 0x0A; /* page length */ 6537 AllPages[14] = 0x40; /* ARRE is set */ 6538 AllPages[15] = 0x00; 6539 AllPages[16] = 0x00; 6540 AllPages[17] = 0x00; 6541 AllPages[18] = 0x00; 6542 AllPages[19] = 0x00; 6543 AllPages[20] = 0x00; 6544 AllPages[21] = 0x00; 6545 AllPages[22] = 0x00; 6546 AllPages[23] = 0x00; 6547 /* MODESENSE_CACHING */ 6548 AllPages[24] = 0x08; /* page code */ 6549 AllPages[25] = 0x12; /* page length */ 6550 #ifdef NOT_YET 6551 if (pSatDevData->satWriteCacheEnabled == agTRUE) 6552 { 6553 AllPages[26] = 0x04;/* WCE bit is set */ 6554 } 6555 else 6556 { 6557 AllPages[26] = 0x00;/* WCE bit is NOT set */ 6558 } 6559 #endif 6560 AllPages[26] = 0x00;/* WCE bit is NOT set */ 6561 6562 AllPages[27] = 0x00; 6563 AllPages[28] = 0x00; 6564 AllPages[29] = 0x00; 6565 AllPages[30] = 0x00; 6566 AllPages[31] = 0x00; 6567 AllPages[32] = 0x00; 6568 AllPages[33] = 0x00; 6569 AllPages[34] = 0x00; 6570 AllPages[35] = 0x00; 6571 if (pSatDevData->satLookAheadEnabled == agTRUE) 6572 { 6573 AllPages[36] = 0x00;/* DRA bit is NOT set */ 6574 } 6575 else 6576 { 6577 AllPages[36] = 0x20;/* DRA bit is set */ 6578 } 6579 AllPages[37] = 0x00; 6580 AllPages[38] = 0x00; 6581 AllPages[39] = 0x00; 6582 AllPages[40] = 0x00; 6583 AllPages[41] = 0x00; 6584 AllPages[42] = 0x00; 6585 AllPages[43] = 0x00; 6586 /* MODESENSE_CONTROL_PAGE */ 6587 AllPages[44] = 0x0A; /* page code */ 6588 AllPages[45] = 0x0A; /* page length */ 6589 AllPages[46] = 0x02; /* only GLTSD bit is set */ 6590 if (pSatDevData->satNCQ == agTRUE) 6591 { 6592 AllPages[47] = 0x12; /* Queue Alogorithm modifier 1b and QErr 01b*/ 6593 } 6594 else 6595 { 6596 AllPages[47] = 0x02; /* Queue Alogorithm modifier 0b and QErr 01b */ 6597 } 6598 AllPages[48] = 0x00; 6599 AllPages[49] = 0x00; 6600 AllPages[50] = 0x00; /* obsolete */ 6601 AllPages[51] = 0x00; /* obsolete */ 6602 AllPages[52] = 0xFF; /* Busy Timeout Period */ 6603 AllPages[53] = 0xFF; /* Busy Timeout Period */ 6604 AllPages[54] = 0x00; /* we don't support non-000b value for the self-test code */ 6605 AllPages[55] = 0x00; /* we don't support non-000b value for the self-test code */ 6606 /* MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE */ 6607 AllPages[56] = 0x1C; /* page code */ 6608 AllPages[57] = 0x0A; /* page length */ 6609 if (pSatDevData->satSMARTEnabled == agTRUE) 6610 { 6611 AllPages[58] = 0x00;/* DEXCPT bit is NOT set */ 6612 } 6613 else 6614 { 6615 AllPages[58] = 0x08;/* DEXCPT bit is set */ 6616 } 6617 AllPages[59] = 0x00; /* We don't support MRIE */ 6618 AllPages[60] = 0x00; /* Interval timer vendor-specific */ 6619 AllPages[61] = 0x00; 6620 AllPages[62] = 0x00; 6621 AllPages[63] = 0x00; 6622 AllPages[64] = 0x00; /* REPORT-COUNT */ 6623 AllPages[65] = 0x00; 6624 AllPages[66] = 0x00; 6625 AllPages[67] = 0x00; 6626 6627 osti_memcpy(pModeSense, &AllPages, lenRead); 6628 } 6629 else if (page == MODESENSE_CONTROL_PAGE) 6630 { 6631 TI_DBG5(("satModeSense6: MODESENSE_CONTROL_PAGE\n")); 6632 Control[0] = MODE_SENSE6_CONTROL_PAGE_LEN - 1; 6633 Control[1] = 0x00; /* default medium type (currently mounted medium type) */ 6634 Control[2] = 0x00; /* no write-protect, no support for DPO-FUA */ 6635 Control[3] = 0x08; /* block descriptor length */ 6636 /* 6637 * Fill-up direct-access device block-descriptor, SAT, Table 19 6638 */ 6639 6640 /* density code */ 6641 Control[4] = 0x04; /* density-code : reserved for direct-access */ 6642 /* number of blocks */ 6643 Control[5] = 0x00; /* unspecified */ 6644 Control[6] = 0x00; /* unspecified */ 6645 Control[7] = 0x00; /* unspecified */ 6646 /* reserved */ 6647 Control[8] = 0x00; /* reserved */ 6648 /* Block size */ 6649 Control[9] = 0x00; 6650 Control[10] = 0x02; /* Block size is always 512 bytes */ 6651 Control[11] = 0x00; 6652 /* 6653 * Fill-up control mode page, SAT, Table 65 6654 */ 6655 Control[12] = 0x0A; /* page code */ 6656 Control[13] = 0x0A; /* page length */ 6657 Control[14] = 0x02; /* only GLTSD bit is set */ 6658 if (pSatDevData->satNCQ == agTRUE) 6659 { 6660 Control[15] = 0x12; /* Queue Alogorithm modifier 1b and QErr 01b*/ 6661 } 6662 else 6663 { 6664 Control[15] = 0x02; /* Queue Alogorithm modifier 0b and QErr 01b */ 6665 } 6666 Control[16] = 0x00; 6667 Control[17] = 0x00; 6668 Control[18] = 0x00; /* obsolete */ 6669 Control[19] = 0x00; /* obsolete */ 6670 Control[20] = 0xFF; /* Busy Timeout Period */ 6671 Control[21] = 0xFF; /* Busy Timeout Period */ 6672 Control[22] = 0x00; /* we don't support non-000b value for the self-test code */ 6673 Control[23] = 0x00; /* we don't support non-000b value for the self-test code */ 6674 6675 osti_memcpy(pModeSense, &Control, lenRead); 6676 6677 } 6678 else if (page == MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE) 6679 { 6680 TI_DBG5(("satModeSense6: MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE\n")); 6681 RWErrorRecovery[0] = MODE_SENSE6_READ_WRITE_ERROR_RECOVERY_PAGE_LEN - 1; 6682 RWErrorRecovery[1] = 0x00; /* default medium type (currently mounted medium type) */ 6683 RWErrorRecovery[2] = 0x00; /* no write-protect, no support for DPO-FUA */ 6684 RWErrorRecovery[3] = 0x08; /* block descriptor length */ 6685 /* 6686 * Fill-up direct-access device block-descriptor, SAT, Table 19 6687 */ 6688 6689 /* density code */ 6690 RWErrorRecovery[4] = 0x04; /* density-code : reserved for direct-access */ 6691 /* number of blocks */ 6692 RWErrorRecovery[5] = 0x00; /* unspecified */ 6693 RWErrorRecovery[6] = 0x00; /* unspecified */ 6694 RWErrorRecovery[7] = 0x00; /* unspecified */ 6695 /* reserved */ 6696 RWErrorRecovery[8] = 0x00; /* reserved */ 6697 /* Block size */ 6698 RWErrorRecovery[9] = 0x00; 6699 RWErrorRecovery[10] = 0x02; /* Block size is always 512 bytes */ 6700 RWErrorRecovery[11] = 0x00; 6701 /* 6702 * Fill-up Read-Write Error Recovery mode page, SAT, Table 66 6703 */ 6704 RWErrorRecovery[12] = 0x01; /* page code */ 6705 RWErrorRecovery[13] = 0x0A; /* page length */ 6706 RWErrorRecovery[14] = 0x40; /* ARRE is set */ 6707 RWErrorRecovery[15] = 0x00; 6708 RWErrorRecovery[16] = 0x00; 6709 RWErrorRecovery[17] = 0x00; 6710 RWErrorRecovery[18] = 0x00; 6711 RWErrorRecovery[19] = 0x00; 6712 RWErrorRecovery[20] = 0x00; 6713 RWErrorRecovery[21] = 0x00; 6714 RWErrorRecovery[22] = 0x00; 6715 RWErrorRecovery[23] = 0x00; 6716 6717 osti_memcpy(pModeSense, &RWErrorRecovery, lenRead); 6718 6719 } 6720 else if (page == MODESENSE_CACHING) 6721 { 6722 TI_DBG5(("satModeSense6: MODESENSE_CACHING\n")); 6723 /* special case */ 6724 if (requestLen == 4 && page == MODESENSE_CACHING) 6725 { 6726 TI_DBG5(("satModeSense6: linux 2.6.8.24 support\n")); 6727 6728 pModeSense[0] = 0x20 - 1; /* 32 - 1 */ 6729 pModeSense[1] = 0x00; /* default medium type (currently mounted medium type) */ 6730 pModeSense[2] = 0x00; /* no write-protect, no support for DPO-FUA */ 6731 pModeSense[3] = 0x08; /* block descriptor length */ 6732 ostiInitiatorIOCompleted( tiRoot, 6733 tiIORequest, 6734 tiIOSuccess, 6735 SCSI_STAT_GOOD, 6736 agNULL, 6737 satIOContext->interruptContext); 6738 return tiSuccess; 6739 } 6740 Caching[0] = MODE_SENSE6_CACHING_LEN - 1; 6741 Caching[1] = 0x00; /* default medium type (currently mounted medium type) */ 6742 Caching[2] = 0x00; /* no write-protect, no support for DPO-FUA */ 6743 Caching[3] = 0x08; /* block descriptor length */ 6744 /* 6745 * Fill-up direct-access device block-descriptor, SAT, Table 19 6746 */ 6747 6748 /* density code */ 6749 Caching[4] = 0x04; /* density-code : reserved for direct-access */ 6750 /* number of blocks */ 6751 Caching[5] = 0x00; /* unspecified */ 6752 Caching[6] = 0x00; /* unspecified */ 6753 Caching[7] = 0x00; /* unspecified */ 6754 /* reserved */ 6755 Caching[8] = 0x00; /* reserved */ 6756 /* Block size */ 6757 Caching[9] = 0x00; 6758 Caching[10] = 0x02; /* Block size is always 512 bytes */ 6759 Caching[11] = 0x00; 6760 /* 6761 * Fill-up Caching mode page, SAT, Table 67 6762 */ 6763 /* length 20 */ 6764 Caching[12] = 0x08; /* page code */ 6765 Caching[13] = 0x12; /* page length */ 6766 #ifdef NOT_YET 6767 if (pSatDevData->satWriteCacheEnabled == agTRUE) 6768 { 6769 Caching[14] = 0x04;/* WCE bit is set */ 6770 } 6771 else 6772 { 6773 Caching[14] = 0x00;/* WCE bit is NOT set */ 6774 } 6775 #endif 6776 Caching[14] = 0x00;/* WCE bit is NOT set */ 6777 6778 Caching[15] = 0x00; 6779 Caching[16] = 0x00; 6780 Caching[17] = 0x00; 6781 Caching[18] = 0x00; 6782 Caching[19] = 0x00; 6783 Caching[20] = 0x00; 6784 Caching[21] = 0x00; 6785 Caching[22] = 0x00; 6786 Caching[23] = 0x00; 6787 if (pSatDevData->satLookAheadEnabled == agTRUE) 6788 { 6789 Caching[24] = 0x00;/* DRA bit is NOT set */ 6790 } 6791 else 6792 { 6793 Caching[24] = 0x20;/* DRA bit is set */ 6794 } 6795 Caching[25] = 0x00; 6796 Caching[26] = 0x00; 6797 Caching[27] = 0x00; 6798 Caching[28] = 0x00; 6799 Caching[29] = 0x00; 6800 Caching[30] = 0x00; 6801 Caching[31] = 0x00; 6802 6803 osti_memcpy(pModeSense, &Caching, lenRead); 6804 6805 } 6806 else if (page == MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE) 6807 { 6808 TI_DBG5(("satModeSense6: MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE\n")); 6809 InfoExceptionCtrl[0] = MODE_SENSE6_INFORMATION_EXCEPTION_CONTROL_PAGE_LEN - 1; 6810 InfoExceptionCtrl[1] = 0x00; /* default medium type (currently mounted medium type) */ 6811 InfoExceptionCtrl[2] = 0x00; /* no write-protect, no support for DPO-FUA */ 6812 InfoExceptionCtrl[3] = 0x08; /* block descriptor length */ 6813 /* 6814 * Fill-up direct-access device block-descriptor, SAT, Table 19 6815 */ 6816 6817 /* density code */ 6818 InfoExceptionCtrl[4] = 0x04; /* density-code : reserved for direct-access */ 6819 /* number of blocks */ 6820 InfoExceptionCtrl[5] = 0x00; /* unspecified */ 6821 InfoExceptionCtrl[6] = 0x00; /* unspecified */ 6822 InfoExceptionCtrl[7] = 0x00; /* unspecified */ 6823 /* reserved */ 6824 InfoExceptionCtrl[8] = 0x00; /* reserved */ 6825 /* Block size */ 6826 InfoExceptionCtrl[9] = 0x00; 6827 InfoExceptionCtrl[10] = 0x02; /* Block size is always 512 bytes */ 6828 InfoExceptionCtrl[11] = 0x00; 6829 /* 6830 * Fill-up informational-exceptions control mode page, SAT, Table 68 6831 */ 6832 InfoExceptionCtrl[12] = 0x1C; /* page code */ 6833 InfoExceptionCtrl[13] = 0x0A; /* page length */ 6834 if (pSatDevData->satSMARTEnabled == agTRUE) 6835 { 6836 InfoExceptionCtrl[14] = 0x00;/* DEXCPT bit is NOT set */ 6837 } 6838 else 6839 { 6840 InfoExceptionCtrl[14] = 0x08;/* DEXCPT bit is set */ 6841 } 6842 InfoExceptionCtrl[15] = 0x00; /* We don't support MRIE */ 6843 InfoExceptionCtrl[16] = 0x00; /* Interval timer vendor-specific */ 6844 InfoExceptionCtrl[17] = 0x00; 6845 InfoExceptionCtrl[18] = 0x00; 6846 InfoExceptionCtrl[19] = 0x00; 6847 InfoExceptionCtrl[20] = 0x00; /* REPORT-COUNT */ 6848 InfoExceptionCtrl[21] = 0x00; 6849 InfoExceptionCtrl[22] = 0x00; 6850 InfoExceptionCtrl[23] = 0x00; 6851 osti_memcpy(pModeSense, &InfoExceptionCtrl, lenRead); 6852 6853 } 6854 else 6855 { 6856 /* Error */ 6857 TI_DBG1(("satModeSense6: Error page %d\n", page)); 6858 satSetSensePayload( pSense, 6859 SCSI_SNSKEY_ILLEGAL_REQUEST, 6860 0, 6861 SCSI_SNSCODE_INVALID_COMMAND, 6862 satIOContext); 6863 6864 ostiInitiatorIOCompleted( tiRoot, 6865 tiIORequest, 6866 tiIOSuccess, 6867 SCSI_STAT_CHECK_CONDITION, 6868 satIOContext->pTiSenseData, 6869 satIOContext->interruptContext ); 6870 return tiSuccess; 6871 } 6872 6873 /* there can be only underrun not overrun in error case */ 6874 if (requestLen > lenRead) 6875 { 6876 TI_DBG6(("satModeSense6 reporting underrun lenRead=0x%x requestLen=0x%x tiIORequest=%p\n", lenRead, requestLen, tiIORequest)); 6877 6878 ostiInitiatorIOCompleted( tiRoot, 6879 tiIORequest, 6880 tiIOUnderRun, 6881 requestLen - lenRead, 6882 agNULL, 6883 satIOContext->interruptContext ); 6884 6885 6886 } 6887 else 6888 { 6889 ostiInitiatorIOCompleted( tiRoot, 6890 tiIORequest, 6891 tiIOSuccess, 6892 SCSI_STAT_GOOD, 6893 agNULL, 6894 satIOContext->interruptContext); 6895 } 6896 6897 return tiSuccess; 6898 6899 } 6900 6901 /*****************************************************************************/ 6902 /*! \brief SAT implementation for SCSI MODE SENSE (10). 6903 * 6904 * SAT implementation for SCSI MODE SENSE (10). 6905 * 6906 * \param tiRoot: Pointer to TISA initiator driver/port instance. 6907 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 6908 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 6909 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 6910 * \param satIOContext_t: Pointer to the SAT IO Context 6911 * 6912 * \return If command is started successfully 6913 * - \e tiSuccess: I/O request successfully initiated. 6914 * - \e tiBusy: No resources available, try again later. 6915 * - \e tiIONoDevice: Invalid device handle. 6916 * - \e tiError: Other errors. 6917 */ 6918 /*****************************************************************************/ 6919 GLOBAL bit32 satModeSense10( 6920 tiRoot_t *tiRoot, 6921 tiIORequest_t *tiIORequest, 6922 tiDeviceHandle_t *tiDeviceHandle, 6923 tiScsiInitiatorRequest_t *tiScsiRequest, 6924 satIOContext_t *satIOContext) 6925 { 6926 6927 scsiRspSense_t *pSense; 6928 bit32 requestLen; 6929 tiIniScsiCmnd_t *scsiCmnd; 6930 bit32 pageSupported; 6931 bit8 page; 6932 bit8 *pModeSense; /* Mode Sense data buffer */ 6933 satDeviceData_t *pSatDevData; 6934 bit8 PC; /* page control */ 6935 bit8 LLBAA; /* Long LBA Accepted */ 6936 bit32 index; 6937 bit8 AllPages[MODE_SENSE10_RETURN_ALL_PAGES_LLBAA_LEN]; 6938 bit8 Control[MODE_SENSE10_CONTROL_PAGE_LLBAA_LEN]; 6939 bit8 RWErrorRecovery[MODE_SENSE10_READ_WRITE_ERROR_RECOVERY_PAGE_LLBAA_LEN]; 6940 bit8 Caching[MODE_SENSE10_CACHING_LLBAA_LEN]; 6941 bit8 InfoExceptionCtrl[MODE_SENSE10_INFORMATION_EXCEPTION_CONTROL_PAGE_LLBAA_LEN]; 6942 bit8 lenRead = 0; 6943 6944 TI_DBG5(("satModeSense10 entry: tiDeviceHandle=%p tiIORequest=%p\n", 6945 tiDeviceHandle, tiIORequest)); 6946 6947 pSense = satIOContext->pSense; 6948 scsiCmnd = &tiScsiRequest->scsiCmnd; 6949 pModeSense = (bit8 *) tiScsiRequest->sglVirtualAddr; 6950 pSatDevData = satIOContext->pSatDevData; 6951 6952 /* checking CONTROL */ 6953 /* NACA == 1 or LINK == 1*/ 6954 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 6955 { 6956 satSetSensePayload( pSense, 6957 SCSI_SNSKEY_ILLEGAL_REQUEST, 6958 0, 6959 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 6960 satIOContext); 6961 6962 ostiInitiatorIOCompleted( tiRoot, 6963 tiIORequest, 6964 tiIOSuccess, 6965 SCSI_STAT_CHECK_CONDITION, 6966 satIOContext->pTiSenseData, 6967 satIOContext->interruptContext ); 6968 6969 TI_DBG2(("satModeSense10: return control\n")); 6970 return tiSuccess; 6971 } 6972 6973 /* checking PC(Page Control) 6974 SAT revion 8, 8.5.3 p33 and 10.1.2, p66 6975 */ 6976 PC = (bit8)((scsiCmnd->cdb[2]) & SCSI_MODE_SENSE10_PC_MASK); 6977 if (PC != 0) 6978 { 6979 satSetSensePayload( pSense, 6980 SCSI_SNSKEY_ILLEGAL_REQUEST, 6981 0, 6982 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 6983 satIOContext); 6984 6985 ostiInitiatorIOCompleted( tiRoot, 6986 tiIORequest, 6987 tiIOSuccess, 6988 SCSI_STAT_CHECK_CONDITION, 6989 satIOContext->pTiSenseData, 6990 satIOContext->interruptContext ); 6991 6992 TI_DBG1(("satModeSense10: return due to PC value pc 0x%x\n", PC)); 6993 return tiSuccess; 6994 } 6995 /* finding LLBAA bit */ 6996 LLBAA = (bit8)((scsiCmnd->cdb[1]) & SCSI_MODE_SENSE10_LLBAA_MASK); 6997 /* reading PAGE CODE */ 6998 page = (bit8)((scsiCmnd->cdb[2]) & SCSI_MODE_SENSE10_PAGE_CODE_MASK); 6999 7000 TI_DBG5(("satModeSense10: page=0x%x, tiDeviceHandle=%p tiIORequest=%p\n", 7001 page, tiDeviceHandle, tiIORequest)); 7002 requestLen = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 7003 7004 /* 7005 Based on page code value, returns a corresponding mode page 7006 note: no support for subpage 7007 */ 7008 switch(page) 7009 { 7010 case MODESENSE_RETURN_ALL_PAGES: /* return all pages */ 7011 case MODESENSE_CONTROL_PAGE: /* control */ 7012 case MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE: /* Read-Write Error Recovery */ 7013 case MODESENSE_CACHING: /* caching */ 7014 case MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE: /* informational exceptions control*/ 7015 pageSupported = agTRUE; 7016 break; 7017 case MODESENSE_VENDOR_SPECIFIC_PAGE: /* vendor specific */ 7018 default: 7019 pageSupported = agFALSE; 7020 break; 7021 } 7022 7023 if (pageSupported == agFALSE) 7024 { 7025 7026 TI_DBG1(("satModeSense10 *** ERROR *** not supported page 0x%x tiDeviceHandle=%p tiIORequest=%p\n", 7027 page, tiDeviceHandle, tiIORequest)); 7028 7029 satSetSensePayload( pSense, 7030 SCSI_SNSKEY_ILLEGAL_REQUEST, 7031 0, 7032 SCSI_SNSCODE_INVALID_COMMAND, 7033 satIOContext); 7034 7035 ostiInitiatorIOCompleted( tiRoot, 7036 tiIORequest, 7037 tiIOSuccess, 7038 SCSI_STAT_CHECK_CONDITION, 7039 satIOContext->pTiSenseData, 7040 satIOContext->interruptContext ); 7041 return tiSuccess; 7042 } 7043 7044 switch(page) 7045 { 7046 case MODESENSE_RETURN_ALL_PAGES: 7047 if (LLBAA) 7048 { 7049 lenRead = (bit8)MIN(requestLen, MODE_SENSE10_RETURN_ALL_PAGES_LLBAA_LEN); 7050 } 7051 else 7052 { 7053 lenRead = (bit8)MIN(requestLen, MODE_SENSE10_RETURN_ALL_PAGES_LEN); 7054 } 7055 break; 7056 case MODESENSE_CONTROL_PAGE: /* control */ 7057 if (LLBAA) 7058 { 7059 lenRead = (bit8)MIN(requestLen, MODE_SENSE10_CONTROL_PAGE_LLBAA_LEN); 7060 } 7061 else 7062 { 7063 lenRead = (bit8)MIN(requestLen, MODE_SENSE10_CONTROL_PAGE_LEN); 7064 } 7065 break; 7066 case MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE: /* Read-Write Error Recovery */ 7067 if (LLBAA) 7068 { 7069 lenRead = (bit8)MIN(requestLen, MODE_SENSE10_READ_WRITE_ERROR_RECOVERY_PAGE_LLBAA_LEN); 7070 } 7071 else 7072 { 7073 lenRead = (bit8)MIN(requestLen, MODE_SENSE10_READ_WRITE_ERROR_RECOVERY_PAGE_LEN); 7074 } 7075 break; 7076 case MODESENSE_CACHING: /* caching */ 7077 if (LLBAA) 7078 { 7079 lenRead = (bit8)MIN(requestLen, MODE_SENSE10_CACHING_LLBAA_LEN); 7080 } 7081 else 7082 { 7083 lenRead = (bit8)MIN(requestLen, MODE_SENSE10_CACHING_LEN); 7084 } 7085 break; 7086 case MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE: /* informational exceptions control*/ 7087 if (LLBAA) 7088 { 7089 lenRead = (bit8)MIN(requestLen, MODE_SENSE10_INFORMATION_EXCEPTION_CONTROL_PAGE_LLBAA_LEN); 7090 } 7091 else 7092 { 7093 lenRead = (bit8)MIN(requestLen, MODE_SENSE10_INFORMATION_EXCEPTION_CONTROL_PAGE_LEN); 7094 } 7095 break; 7096 default: 7097 TI_DBG1(("satModeSense10: default error page %d\n", page)); 7098 break; 7099 } 7100 7101 if (page == MODESENSE_RETURN_ALL_PAGES) 7102 { 7103 TI_DBG5(("satModeSense10: MODESENSE_RETURN_ALL_PAGES\n")); 7104 AllPages[0] = 0; 7105 AllPages[1] = (bit8)(lenRead - 2); 7106 AllPages[2] = 0x00; /* medium type: default medium type (currently mounted medium type) */ 7107 AllPages[3] = 0x00; /* device-specific param: no write-protect, no support for DPO-FUA */ 7108 if (LLBAA) 7109 { 7110 AllPages[4] = 0x00; /* reserved and LONGLBA */ 7111 AllPages[4] = (bit8)(AllPages[4] | 0x1); /* LONGLBA is set */ 7112 } 7113 else 7114 { 7115 AllPages[4] = 0x00; /* reserved and LONGLBA: LONGLBA is not set */ 7116 } 7117 AllPages[5] = 0x00; /* reserved */ 7118 AllPages[6] = 0x00; /* block descriptot length */ 7119 if (LLBAA) 7120 { 7121 AllPages[7] = 0x10; /* block descriptor length: LONGLBA is set. So, length is 16 */ 7122 } 7123 else 7124 { 7125 AllPages[7] = 0x08; /* block descriptor length: LONGLBA is NOT set. So, length is 8 */ 7126 } 7127 7128 /* 7129 * Fill-up direct-access device block-descriptor, SAT, Table 19 7130 */ 7131 7132 if (LLBAA) 7133 { 7134 /* density code */ 7135 AllPages[8] = 0x04; /* density-code : reserved for direct-access */ 7136 /* number of blocks */ 7137 AllPages[9] = 0x00; /* unspecified */ 7138 AllPages[10] = 0x00; /* unspecified */ 7139 AllPages[11] = 0x00; /* unspecified */ 7140 AllPages[12] = 0x00; /* unspecified */ 7141 AllPages[13] = 0x00; /* unspecified */ 7142 AllPages[14] = 0x00; /* unspecified */ 7143 AllPages[15] = 0x00; /* unspecified */ 7144 /* reserved */ 7145 AllPages[16] = 0x00; /* reserved */ 7146 AllPages[17] = 0x00; /* reserved */ 7147 AllPages[18] = 0x00; /* reserved */ 7148 AllPages[19] = 0x00; /* reserved */ 7149 /* Block size */ 7150 AllPages[20] = 0x00; 7151 AllPages[21] = 0x00; 7152 AllPages[22] = 0x02; /* Block size is always 512 bytes */ 7153 AllPages[23] = 0x00; 7154 } 7155 else 7156 { 7157 /* density code */ 7158 AllPages[8] = 0x04; /* density-code : reserved for direct-access */ 7159 /* number of blocks */ 7160 AllPages[9] = 0x00; /* unspecified */ 7161 AllPages[10] = 0x00; /* unspecified */ 7162 AllPages[11] = 0x00; /* unspecified */ 7163 /* reserved */ 7164 AllPages[12] = 0x00; /* reserved */ 7165 /* Block size */ 7166 AllPages[13] = 0x00; 7167 AllPages[14] = 0x02; /* Block size is always 512 bytes */ 7168 AllPages[15] = 0x00; 7169 } 7170 7171 if (LLBAA) 7172 { 7173 index = 24; 7174 } 7175 else 7176 { 7177 index = 16; 7178 } 7179 /* MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE */ 7180 AllPages[index+0] = 0x01; /* page code */ 7181 AllPages[index+1] = 0x0A; /* page length */ 7182 AllPages[index+2] = 0x40; /* ARRE is set */ 7183 AllPages[index+3] = 0x00; 7184 AllPages[index+4] = 0x00; 7185 AllPages[index+5] = 0x00; 7186 AllPages[index+6] = 0x00; 7187 AllPages[index+7] = 0x00; 7188 AllPages[index+8] = 0x00; 7189 AllPages[index+9] = 0x00; 7190 AllPages[index+10] = 0x00; 7191 AllPages[index+11] = 0x00; 7192 7193 /* MODESENSE_CACHING */ 7194 /* 7195 * Fill-up Caching mode page, SAT, Table 67 7196 */ 7197 /* length 20 */ 7198 AllPages[index+12] = 0x08; /* page code */ 7199 AllPages[index+13] = 0x12; /* page length */ 7200 #ifdef NOT_YET 7201 if (pSatDevData->satWriteCacheEnabled == agTRUE) 7202 { 7203 AllPages[index+14] = 0x04;/* WCE bit is set */ 7204 } 7205 else 7206 { 7207 AllPages[index+14] = 0x00;/* WCE bit is NOT set */ 7208 } 7209 #endif 7210 AllPages[index+14] = 0x00;/* WCE bit is NOT set */ 7211 AllPages[index+15] = 0x00; 7212 AllPages[index+16] = 0x00; 7213 AllPages[index+17] = 0x00; 7214 AllPages[index+18] = 0x00; 7215 AllPages[index+19] = 0x00; 7216 AllPages[index+20] = 0x00; 7217 AllPages[index+21] = 0x00; 7218 AllPages[index+22] = 0x00; 7219 AllPages[index+23] = 0x00; 7220 if (pSatDevData->satLookAheadEnabled == agTRUE) 7221 { 7222 AllPages[index+24] = 0x00;/* DRA bit is NOT set */ 7223 } 7224 else 7225 { 7226 AllPages[index+24] = 0x20;/* DRA bit is set */ 7227 } 7228 AllPages[index+25] = 0x00; 7229 AllPages[index+26] = 0x00; 7230 AllPages[index+27] = 0x00; 7231 AllPages[index+28] = 0x00; 7232 AllPages[index+29] = 0x00; 7233 AllPages[index+30] = 0x00; 7234 AllPages[index+31] = 0x00; 7235 7236 /* MODESENSE_CONTROL_PAGE */ 7237 /* 7238 * Fill-up control mode page, SAT, Table 65 7239 */ 7240 AllPages[index+32] = 0x0A; /* page code */ 7241 AllPages[index+33] = 0x0A; /* page length */ 7242 AllPages[index+34] = 0x02; /* only GLTSD bit is set */ 7243 if (pSatDevData->satNCQ == agTRUE) 7244 { 7245 AllPages[index+35] = 0x12; /* Queue Alogorithm modifier 1b and QErr 01b*/ 7246 } 7247 else 7248 { 7249 AllPages[index+35] = 0x02; /* Queue Alogorithm modifier 0b and QErr 01b */ 7250 } 7251 AllPages[index+36] = 0x00; 7252 AllPages[index+37] = 0x00; 7253 AllPages[index+38] = 0x00; /* obsolete */ 7254 AllPages[index+39] = 0x00; /* obsolete */ 7255 AllPages[index+40] = 0xFF; /* Busy Timeout Period */ 7256 AllPages[index+41] = 0xFF; /* Busy Timeout Period */ 7257 AllPages[index+42] = 0x00; /* we don't support non-000b value for the self-test code */ 7258 AllPages[index+43] = 0x00; /* we don't support non-000b value for the self-test code */ 7259 7260 /* MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE */ 7261 /* 7262 * Fill-up informational-exceptions control mode page, SAT, Table 68 7263 */ 7264 AllPages[index+44] = 0x1C; /* page code */ 7265 AllPages[index+45] = 0x0A; /* page length */ 7266 if (pSatDevData->satSMARTEnabled == agTRUE) 7267 { 7268 AllPages[index+46] = 0x00;/* DEXCPT bit is NOT set */ 7269 } 7270 else 7271 { 7272 AllPages[index+46] = 0x08;/* DEXCPT bit is set */ 7273 } 7274 AllPages[index+47] = 0x00; /* We don't support MRIE */ 7275 AllPages[index+48] = 0x00; /* Interval timer vendor-specific */ 7276 AllPages[index+49] = 0x00; 7277 AllPages[index+50] = 0x00; 7278 AllPages[index+51] = 0x00; 7279 AllPages[index+52] = 0x00; /* REPORT-COUNT */ 7280 AllPages[index+53] = 0x00; 7281 AllPages[index+54] = 0x00; 7282 AllPages[index+55] = 0x00; 7283 7284 osti_memcpy(pModeSense, &AllPages, lenRead); 7285 } 7286 else if (page == MODESENSE_CONTROL_PAGE) 7287 { 7288 TI_DBG5(("satModeSense10: MODESENSE_CONTROL_PAGE\n")); 7289 Control[0] = 0; 7290 Control[1] = (bit8)(lenRead - 2); 7291 Control[2] = 0x00; /* medium type: default medium type (currently mounted medium type) */ 7292 Control[3] = 0x00; /* device-specific param: no write-protect, no support for DPO-FUA */ 7293 if (LLBAA) 7294 { 7295 Control[4] = 0x00; /* reserved and LONGLBA */ 7296 Control[4] = (bit8)(Control[4] | 0x1); /* LONGLBA is set */ 7297 } 7298 else 7299 { 7300 Control[4] = 0x00; /* reserved and LONGLBA: LONGLBA is not set */ 7301 } 7302 Control[5] = 0x00; /* reserved */ 7303 Control[6] = 0x00; /* block descriptot length */ 7304 if (LLBAA) 7305 { 7306 Control[7] = 0x10; /* block descriptor length: LONGLBA is set. So, length is 16 */ 7307 } 7308 else 7309 { 7310 Control[7] = 0x08; /* block descriptor length: LONGLBA is NOT set. So, length is 8 */ 7311 } 7312 7313 /* 7314 * Fill-up direct-access device block-descriptor, SAT, Table 19 7315 */ 7316 7317 if (LLBAA) 7318 { 7319 /* density code */ 7320 Control[8] = 0x04; /* density-code : reserved for direct-access */ 7321 /* number of blocks */ 7322 Control[9] = 0x00; /* unspecified */ 7323 Control[10] = 0x00; /* unspecified */ 7324 Control[11] = 0x00; /* unspecified */ 7325 Control[12] = 0x00; /* unspecified */ 7326 Control[13] = 0x00; /* unspecified */ 7327 Control[14] = 0x00; /* unspecified */ 7328 Control[15] = 0x00; /* unspecified */ 7329 /* reserved */ 7330 Control[16] = 0x00; /* reserved */ 7331 Control[17] = 0x00; /* reserved */ 7332 Control[18] = 0x00; /* reserved */ 7333 Control[19] = 0x00; /* reserved */ 7334 /* Block size */ 7335 Control[20] = 0x00; 7336 Control[21] = 0x00; 7337 Control[22] = 0x02; /* Block size is always 512 bytes */ 7338 Control[23] = 0x00; 7339 } 7340 else 7341 { 7342 /* density code */ 7343 Control[8] = 0x04; /* density-code : reserved for direct-access */ 7344 /* number of blocks */ 7345 Control[9] = 0x00; /* unspecified */ 7346 Control[10] = 0x00; /* unspecified */ 7347 Control[11] = 0x00; /* unspecified */ 7348 /* reserved */ 7349 Control[12] = 0x00; /* reserved */ 7350 /* Block size */ 7351 Control[13] = 0x00; 7352 Control[14] = 0x02; /* Block size is always 512 bytes */ 7353 Control[15] = 0x00; 7354 } 7355 7356 if (LLBAA) 7357 { 7358 index = 24; 7359 } 7360 else 7361 { 7362 index = 16; 7363 } 7364 /* 7365 * Fill-up control mode page, SAT, Table 65 7366 */ 7367 Control[index+0] = 0x0A; /* page code */ 7368 Control[index+1] = 0x0A; /* page length */ 7369 Control[index+2] = 0x02; /* only GLTSD bit is set */ 7370 if (pSatDevData->satNCQ == agTRUE) 7371 { 7372 Control[index+3] = 0x12; /* Queue Alogorithm modifier 1b and QErr 01b*/ 7373 } 7374 else 7375 { 7376 Control[index+3] = 0x02; /* Queue Alogorithm modifier 0b and QErr 01b */ 7377 } 7378 Control[index+4] = 0x00; 7379 Control[index+5] = 0x00; 7380 Control[index+6] = 0x00; /* obsolete */ 7381 Control[index+7] = 0x00; /* obsolete */ 7382 Control[index+8] = 0xFF; /* Busy Timeout Period */ 7383 Control[index+9] = 0xFF; /* Busy Timeout Period */ 7384 Control[index+10] = 0x00; /* we don't support non-000b value for the self-test code */ 7385 Control[index+11] = 0x00; /* we don't support non-000b value for the self-test code */ 7386 7387 osti_memcpy(pModeSense, &Control, lenRead); 7388 } 7389 else if (page == MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE) 7390 { 7391 TI_DBG5(("satModeSense10: MODESENSE_READ_WRITE_ERROR_RECOVERY_PAGE\n")); 7392 RWErrorRecovery[0] = 0; 7393 RWErrorRecovery[1] = (bit8)(lenRead - 2); 7394 RWErrorRecovery[2] = 0x00; /* medium type: default medium type (currently mounted medium type) */ 7395 RWErrorRecovery[3] = 0x00; /* device-specific param: no write-protect, no support for DPO-FUA */ 7396 if (LLBAA) 7397 { 7398 RWErrorRecovery[4] = 0x00; /* reserved and LONGLBA */ 7399 RWErrorRecovery[4] = (bit8)(RWErrorRecovery[4] | 0x1); /* LONGLBA is set */ 7400 } 7401 else 7402 { 7403 RWErrorRecovery[4] = 0x00; /* reserved and LONGLBA: LONGLBA is not set */ 7404 } 7405 RWErrorRecovery[5] = 0x00; /* reserved */ 7406 RWErrorRecovery[6] = 0x00; /* block descriptot length */ 7407 if (LLBAA) 7408 { 7409 RWErrorRecovery[7] = 0x10; /* block descriptor length: LONGLBA is set. So, length is 16 */ 7410 } 7411 else 7412 { 7413 RWErrorRecovery[7] = 0x08; /* block descriptor length: LONGLBA is NOT set. So, length is 8 */ 7414 } 7415 7416 /* 7417 * Fill-up direct-access device block-descriptor, SAT, Table 19 7418 */ 7419 7420 if (LLBAA) 7421 { 7422 /* density code */ 7423 RWErrorRecovery[8] = 0x04; /* density-code : reserved for direct-access */ 7424 /* number of blocks */ 7425 RWErrorRecovery[9] = 0x00; /* unspecified */ 7426 RWErrorRecovery[10] = 0x00; /* unspecified */ 7427 RWErrorRecovery[11] = 0x00; /* unspecified */ 7428 RWErrorRecovery[12] = 0x00; /* unspecified */ 7429 RWErrorRecovery[13] = 0x00; /* unspecified */ 7430 RWErrorRecovery[14] = 0x00; /* unspecified */ 7431 RWErrorRecovery[15] = 0x00; /* unspecified */ 7432 /* reserved */ 7433 RWErrorRecovery[16] = 0x00; /* reserved */ 7434 RWErrorRecovery[17] = 0x00; /* reserved */ 7435 RWErrorRecovery[18] = 0x00; /* reserved */ 7436 RWErrorRecovery[19] = 0x00; /* reserved */ 7437 /* Block size */ 7438 RWErrorRecovery[20] = 0x00; 7439 RWErrorRecovery[21] = 0x00; 7440 RWErrorRecovery[22] = 0x02; /* Block size is always 512 bytes */ 7441 RWErrorRecovery[23] = 0x00; 7442 } 7443 else 7444 { 7445 /* density code */ 7446 RWErrorRecovery[8] = 0x04; /* density-code : reserved for direct-access */ 7447 /* number of blocks */ 7448 RWErrorRecovery[9] = 0x00; /* unspecified */ 7449 RWErrorRecovery[10] = 0x00; /* unspecified */ 7450 RWErrorRecovery[11] = 0x00; /* unspecified */ 7451 /* reserved */ 7452 RWErrorRecovery[12] = 0x00; /* reserved */ 7453 /* Block size */ 7454 RWErrorRecovery[13] = 0x00; 7455 RWErrorRecovery[14] = 0x02; /* Block size is always 512 bytes */ 7456 RWErrorRecovery[15] = 0x00; 7457 } 7458 7459 if (LLBAA) 7460 { 7461 index = 24; 7462 } 7463 else 7464 { 7465 index = 16; 7466 } 7467 /* 7468 * Fill-up Read-Write Error Recovery mode page, SAT, Table 66 7469 */ 7470 RWErrorRecovery[index+0] = 0x01; /* page code */ 7471 RWErrorRecovery[index+1] = 0x0A; /* page length */ 7472 RWErrorRecovery[index+2] = 0x40; /* ARRE is set */ 7473 RWErrorRecovery[index+3] = 0x00; 7474 RWErrorRecovery[index+4] = 0x00; 7475 RWErrorRecovery[index+5] = 0x00; 7476 RWErrorRecovery[index+6] = 0x00; 7477 RWErrorRecovery[index+7] = 0x00; 7478 RWErrorRecovery[index+8] = 0x00; 7479 RWErrorRecovery[index+9] = 0x00; 7480 RWErrorRecovery[index+10] = 0x00; 7481 RWErrorRecovery[index+11] = 0x00; 7482 7483 osti_memcpy(pModeSense, &RWErrorRecovery, lenRead); 7484 } 7485 else if (page == MODESENSE_CACHING) 7486 { 7487 TI_DBG5(("satModeSense10: MODESENSE_CACHING\n")); 7488 Caching[0] = 0; 7489 Caching[1] = (bit8)(lenRead - 2); 7490 Caching[2] = 0x00; /* medium type: default medium type (currently mounted medium type) */ 7491 Caching[3] = 0x00; /* device-specific param: no write-protect, no support for DPO-FUA */ 7492 if (LLBAA) 7493 { 7494 Caching[4] = 0x00; /* reserved and LONGLBA */ 7495 Caching[4] = (bit8)(Caching[4] | 0x1); /* LONGLBA is set */ 7496 } 7497 else 7498 { 7499 Caching[4] = 0x00; /* reserved and LONGLBA: LONGLBA is not set */ 7500 } 7501 Caching[5] = 0x00; /* reserved */ 7502 Caching[6] = 0x00; /* block descriptot length */ 7503 if (LLBAA) 7504 { 7505 Caching[7] = 0x10; /* block descriptor length: LONGLBA is set. So, length is 16 */ 7506 } 7507 else 7508 { 7509 Caching[7] = 0x08; /* block descriptor length: LONGLBA is NOT set. So, length is 8 */ 7510 } 7511 7512 /* 7513 * Fill-up direct-access device block-descriptor, SAT, Table 19 7514 */ 7515 7516 if (LLBAA) 7517 { 7518 /* density code */ 7519 Caching[8] = 0x04; /* density-code : reserved for direct-access */ 7520 /* number of blocks */ 7521 Caching[9] = 0x00; /* unspecified */ 7522 Caching[10] = 0x00; /* unspecified */ 7523 Caching[11] = 0x00; /* unspecified */ 7524 Caching[12] = 0x00; /* unspecified */ 7525 Caching[13] = 0x00; /* unspecified */ 7526 Caching[14] = 0x00; /* unspecified */ 7527 Caching[15] = 0x00; /* unspecified */ 7528 /* reserved */ 7529 Caching[16] = 0x00; /* reserved */ 7530 Caching[17] = 0x00; /* reserved */ 7531 Caching[18] = 0x00; /* reserved */ 7532 Caching[19] = 0x00; /* reserved */ 7533 /* Block size */ 7534 Caching[20] = 0x00; 7535 Caching[21] = 0x00; 7536 Caching[22] = 0x02; /* Block size is always 512 bytes */ 7537 Caching[23] = 0x00; 7538 } 7539 else 7540 { 7541 /* density code */ 7542 Caching[8] = 0x04; /* density-code : reserved for direct-access */ 7543 /* number of blocks */ 7544 Caching[9] = 0x00; /* unspecified */ 7545 Caching[10] = 0x00; /* unspecified */ 7546 Caching[11] = 0x00; /* unspecified */ 7547 /* reserved */ 7548 Caching[12] = 0x00; /* reserved */ 7549 /* Block size */ 7550 Caching[13] = 0x00; 7551 Caching[14] = 0x02; /* Block size is always 512 bytes */ 7552 Caching[15] = 0x00; 7553 } 7554 7555 if (LLBAA) 7556 { 7557 index = 24; 7558 } 7559 else 7560 { 7561 index = 16; 7562 } 7563 /* 7564 * Fill-up Caching mode page, SAT, Table 67 7565 */ 7566 /* length 20 */ 7567 Caching[index+0] = 0x08; /* page code */ 7568 Caching[index+1] = 0x12; /* page length */ 7569 #ifdef NOT_YET 7570 if (pSatDevData->satWriteCacheEnabled == agTRUE) 7571 { 7572 Caching[index+2] = 0x04;/* WCE bit is set */ 7573 } 7574 else 7575 { 7576 Caching[index+2] = 0x00;/* WCE bit is NOT set */ 7577 } 7578 #endif 7579 Caching[index+2] = 0x00;/* WCE bit is NOT set */ 7580 Caching[index+3] = 0x00; 7581 Caching[index+4] = 0x00; 7582 Caching[index+5] = 0x00; 7583 Caching[index+6] = 0x00; 7584 Caching[index+7] = 0x00; 7585 Caching[index+8] = 0x00; 7586 Caching[index+9] = 0x00; 7587 Caching[index+10] = 0x00; 7588 Caching[index+11] = 0x00; 7589 if (pSatDevData->satLookAheadEnabled == agTRUE) 7590 { 7591 Caching[index+12] = 0x00;/* DRA bit is NOT set */ 7592 } 7593 else 7594 { 7595 Caching[index+12] = 0x20;/* DRA bit is set */ 7596 } 7597 Caching[index+13] = 0x00; 7598 Caching[index+14] = 0x00; 7599 Caching[index+15] = 0x00; 7600 Caching[index+16] = 0x00; 7601 Caching[index+17] = 0x00; 7602 Caching[index+18] = 0x00; 7603 Caching[index+19] = 0x00; 7604 osti_memcpy(pModeSense, &Caching, lenRead); 7605 7606 } 7607 else if (page == MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE) 7608 { 7609 TI_DBG5(("satModeSense10: MODESENSE_INFORMATION_EXCEPTION_CONTROL_PAGE\n")); 7610 InfoExceptionCtrl[0] = 0; 7611 InfoExceptionCtrl[1] = (bit8)(lenRead - 2); 7612 InfoExceptionCtrl[2] = 0x00; /* medium type: default medium type (currently mounted medium type) */ 7613 InfoExceptionCtrl[3] = 0x00; /* device-specific param: no write-protect, no support for DPO-FUA */ 7614 if (LLBAA) 7615 { 7616 InfoExceptionCtrl[4] = 0x00; /* reserved and LONGLBA */ 7617 InfoExceptionCtrl[4] = (bit8)(InfoExceptionCtrl[4] | 0x1); /* LONGLBA is set */ 7618 } 7619 else 7620 { 7621 InfoExceptionCtrl[4] = 0x00; /* reserved and LONGLBA: LONGLBA is not set */ 7622 } 7623 InfoExceptionCtrl[5] = 0x00; /* reserved */ 7624 InfoExceptionCtrl[6] = 0x00; /* block descriptot length */ 7625 if (LLBAA) 7626 { 7627 InfoExceptionCtrl[7] = 0x10; /* block descriptor length: LONGLBA is set. So, length is 16 */ 7628 } 7629 else 7630 { 7631 InfoExceptionCtrl[7] = 0x08; /* block descriptor length: LONGLBA is NOT set. So, length is 8 */ 7632 } 7633 7634 /* 7635 * Fill-up direct-access device block-descriptor, SAT, Table 19 7636 */ 7637 7638 if (LLBAA) 7639 { 7640 /* density code */ 7641 InfoExceptionCtrl[8] = 0x04; /* density-code : reserved for direct-access */ 7642 /* number of blocks */ 7643 InfoExceptionCtrl[9] = 0x00; /* unspecified */ 7644 InfoExceptionCtrl[10] = 0x00; /* unspecified */ 7645 InfoExceptionCtrl[11] = 0x00; /* unspecified */ 7646 InfoExceptionCtrl[12] = 0x00; /* unspecified */ 7647 InfoExceptionCtrl[13] = 0x00; /* unspecified */ 7648 InfoExceptionCtrl[14] = 0x00; /* unspecified */ 7649 InfoExceptionCtrl[15] = 0x00; /* unspecified */ 7650 /* reserved */ 7651 InfoExceptionCtrl[16] = 0x00; /* reserved */ 7652 InfoExceptionCtrl[17] = 0x00; /* reserved */ 7653 InfoExceptionCtrl[18] = 0x00; /* reserved */ 7654 InfoExceptionCtrl[19] = 0x00; /* reserved */ 7655 /* Block size */ 7656 InfoExceptionCtrl[20] = 0x00; 7657 InfoExceptionCtrl[21] = 0x00; 7658 InfoExceptionCtrl[22] = 0x02; /* Block size is always 512 bytes */ 7659 InfoExceptionCtrl[23] = 0x00; 7660 } 7661 else 7662 { 7663 /* density code */ 7664 InfoExceptionCtrl[8] = 0x04; /* density-code : reserved for direct-access */ 7665 /* number of blocks */ 7666 InfoExceptionCtrl[9] = 0x00; /* unspecified */ 7667 InfoExceptionCtrl[10] = 0x00; /* unspecified */ 7668 InfoExceptionCtrl[11] = 0x00; /* unspecified */ 7669 /* reserved */ 7670 InfoExceptionCtrl[12] = 0x00; /* reserved */ 7671 /* Block size */ 7672 InfoExceptionCtrl[13] = 0x00; 7673 InfoExceptionCtrl[14] = 0x02; /* Block size is always 512 bytes */ 7674 InfoExceptionCtrl[15] = 0x00; 7675 } 7676 7677 if (LLBAA) 7678 { 7679 index = 24; 7680 } 7681 else 7682 { 7683 index = 16; 7684 } 7685 /* 7686 * Fill-up informational-exceptions control mode page, SAT, Table 68 7687 */ 7688 InfoExceptionCtrl[index+0] = 0x1C; /* page code */ 7689 InfoExceptionCtrl[index+1] = 0x0A; /* page length */ 7690 if (pSatDevData->satSMARTEnabled == agTRUE) 7691 { 7692 InfoExceptionCtrl[index+2] = 0x00;/* DEXCPT bit is NOT set */ 7693 } 7694 else 7695 { 7696 InfoExceptionCtrl[index+2] = 0x08;/* DEXCPT bit is set */ 7697 } 7698 InfoExceptionCtrl[index+3] = 0x00; /* We don't support MRIE */ 7699 InfoExceptionCtrl[index+4] = 0x00; /* Interval timer vendor-specific */ 7700 InfoExceptionCtrl[index+5] = 0x00; 7701 InfoExceptionCtrl[index+6] = 0x00; 7702 InfoExceptionCtrl[index+7] = 0x00; 7703 InfoExceptionCtrl[index+8] = 0x00; /* REPORT-COUNT */ 7704 InfoExceptionCtrl[index+9] = 0x00; 7705 InfoExceptionCtrl[index+10] = 0x00; 7706 InfoExceptionCtrl[index+11] = 0x00; 7707 osti_memcpy(pModeSense, &InfoExceptionCtrl, lenRead); 7708 7709 } 7710 else 7711 { 7712 /* Error */ 7713 TI_DBG1(("satModeSense10: Error page %d\n", page)); 7714 satSetSensePayload( pSense, 7715 SCSI_SNSKEY_ILLEGAL_REQUEST, 7716 0, 7717 SCSI_SNSCODE_INVALID_COMMAND, 7718 satIOContext); 7719 7720 ostiInitiatorIOCompleted( tiRoot, 7721 tiIORequest, 7722 tiIOSuccess, 7723 SCSI_STAT_CHECK_CONDITION, 7724 satIOContext->pTiSenseData, 7725 satIOContext->interruptContext ); 7726 return tiSuccess; 7727 } 7728 7729 if (requestLen > lenRead) 7730 { 7731 TI_DBG1(("satModeSense10 reporting underrun lenRead=0x%x requestLen=0x%x tiIORequest=%p\n", lenRead, requestLen, tiIORequest)); 7732 7733 ostiInitiatorIOCompleted( tiRoot, 7734 tiIORequest, 7735 tiIOUnderRun, 7736 requestLen - lenRead, 7737 agNULL, 7738 satIOContext->interruptContext ); 7739 7740 7741 } 7742 else 7743 { 7744 ostiInitiatorIOCompleted( tiRoot, 7745 tiIORequest, 7746 tiIOSuccess, 7747 SCSI_STAT_GOOD, 7748 agNULL, 7749 satIOContext->interruptContext); 7750 } 7751 7752 return tiSuccess; 7753 } 7754 7755 7756 /*****************************************************************************/ 7757 /*! \brief SAT implementation for SCSI VERIFY (10). 7758 * 7759 * SAT implementation for SCSI VERIFY (10). 7760 * 7761 * \param tiRoot: Pointer to TISA initiator driver/port instance. 7762 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 7763 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 7764 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 7765 * \param satIOContext_t: Pointer to the SAT IO Context 7766 * 7767 * \return If command is started successfully 7768 * - \e tiSuccess: I/O request successfully initiated. 7769 * - \e tiBusy: No resources available, try again later. 7770 * - \e tiIONoDevice: Invalid device handle. 7771 * - \e tiError: Other errors. 7772 */ 7773 /*****************************************************************************/ 7774 GLOBAL bit32 satVerify10( 7775 tiRoot_t *tiRoot, 7776 tiIORequest_t *tiIORequest, 7777 tiDeviceHandle_t *tiDeviceHandle, 7778 tiScsiInitiatorRequest_t *tiScsiRequest, 7779 satIOContext_t *satIOContext) 7780 { 7781 /* 7782 For simple implementation, 7783 no byte comparison supported as of 4/5/06 7784 */ 7785 scsiRspSense_t *pSense; 7786 tiIniScsiCmnd_t *scsiCmnd; 7787 satDeviceData_t *pSatDevData; 7788 agsaFisRegHostToDevice_t *fis; 7789 bit32 status; 7790 bit32 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 7791 bit32 lba = 0; 7792 bit32 tl = 0; 7793 bit32 LoopNum = 1; 7794 bit8 LBA[4]; 7795 bit8 TL[4]; 7796 bit32 rangeChk = agFALSE; /* lba and tl range check */ 7797 7798 7799 TI_DBG5(("satVerify10 entry: tiDeviceHandle=%p tiIORequest=%p\n", 7800 tiDeviceHandle, tiIORequest)); 7801 7802 pSense = satIOContext->pSense; 7803 scsiCmnd = &tiScsiRequest->scsiCmnd; 7804 pSatDevData = satIOContext->pSatDevData; 7805 fis = satIOContext->pFis; 7806 7807 /* checking BYTCHK */ 7808 if (scsiCmnd->cdb[1] & SCSI_VERIFY_BYTCHK_MASK) 7809 { 7810 /* 7811 should do the byte check 7812 but not supported in this version 7813 */ 7814 satSetSensePayload( pSense, 7815 SCSI_SNSKEY_ILLEGAL_REQUEST, 7816 0, 7817 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 7818 satIOContext); 7819 7820 ostiInitiatorIOCompleted( tiRoot, 7821 tiIORequest, 7822 tiIOSuccess, 7823 SCSI_STAT_CHECK_CONDITION, 7824 satIOContext->pTiSenseData, 7825 satIOContext->interruptContext ); 7826 7827 TI_DBG1(("satVerify10: no byte checking \n")); 7828 return tiSuccess; 7829 } 7830 7831 /* checking CONTROL */ 7832 /* NACA == 1 or LINK == 1*/ 7833 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 7834 { 7835 satSetSensePayload( pSense, 7836 SCSI_SNSKEY_ILLEGAL_REQUEST, 7837 0, 7838 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 7839 satIOContext); 7840 7841 ostiInitiatorIOCompleted( tiRoot, 7842 tiIORequest, 7843 tiIOSuccess, 7844 SCSI_STAT_CHECK_CONDITION, 7845 satIOContext->pTiSenseData, 7846 satIOContext->interruptContext ); 7847 7848 TI_DBG2(("satVerify10: return control\n")); 7849 return tiSuccess; 7850 } 7851 7852 osti_memset(LBA, 0, sizeof(LBA)); 7853 osti_memset(TL, 0, sizeof(TL)); 7854 7855 /* do not use memcpy due to indexing in LBA and TL */ 7856 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 7857 LBA[1] = scsiCmnd->cdb[3]; 7858 LBA[2] = scsiCmnd->cdb[4]; 7859 LBA[3] = scsiCmnd->cdb[5]; /* LSB */ 7860 7861 TL[0] = 0; 7862 TL[1] = 0; 7863 TL[2] = scsiCmnd->cdb[7]; /* MSB */ 7864 TL[3] = scsiCmnd->cdb[8]; /* LSB */ 7865 7866 rangeChk = satAddNComparebit32(LBA, TL); 7867 7868 /* cbd10; computing LBA and transfer length */ 7869 lba = (scsiCmnd->cdb[2] << (8*3)) + (scsiCmnd->cdb[3] << (8*2)) 7870 + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 7871 tl = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 7872 7873 if (pSatDevData->satNCQ != agTRUE && 7874 pSatDevData->sat48BitSupport != agTRUE 7875 ) 7876 { 7877 if (lba > SAT_TR_LBA_LIMIT - 1) 7878 { 7879 satSetSensePayload( pSense, 7880 SCSI_SNSKEY_ILLEGAL_REQUEST, 7881 0, 7882 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 7883 satIOContext); 7884 7885 ostiInitiatorIOCompleted( tiRoot, 7886 tiIORequest, 7887 tiIOSuccess, 7888 SCSI_STAT_CHECK_CONDITION, 7889 satIOContext->pTiSenseData, 7890 satIOContext->interruptContext ); 7891 7892 TI_DBG1(("satVerify10: return LBA out of range, not EXT\n")); 7893 TI_DBG1(("satVerify10: cdb 0x%x 0x%x 0x%x 0x%x\n",scsiCmnd->cdb[2], scsiCmnd->cdb[3], 7894 scsiCmnd->cdb[4], scsiCmnd->cdb[5])); 7895 TI_DBG1(("satVerify10: lba 0x%x SAT_TR_LBA_LIMIT 0x%x\n", lba, SAT_TR_LBA_LIMIT)); 7896 return tiSuccess; 7897 } 7898 7899 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 7900 { 7901 TI_DBG1(("satVerify10: return LBA+TL out of range, not EXT\n")); 7902 satSetSensePayload( pSense, 7903 SCSI_SNSKEY_ILLEGAL_REQUEST, 7904 0, 7905 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 7906 satIOContext); 7907 7908 ostiInitiatorIOCompleted( tiRoot, 7909 tiIORequest, 7910 tiIOSuccess, 7911 SCSI_STAT_CHECK_CONDITION, 7912 satIOContext->pTiSenseData, 7913 satIOContext->interruptContext ); 7914 7915 return tiSuccess; 7916 } 7917 } 7918 7919 if (pSatDevData->sat48BitSupport == agTRUE) 7920 { 7921 TI_DBG5(("satVerify10: SAT_READ_VERIFY_SECTORS_EXT\n")); 7922 fis->h.fisType = 0x27; /* Reg host to device */ 7923 fis->h.c_pmPort = 0x80; /* C Bit is set */ 7924 7925 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 7926 fis->h.features = 0; /* FIS reserve */ 7927 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 7928 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 7929 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 7930 fis->d.device = 0x40; /* FIS LBA mode set 01000000 */ 7931 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 7932 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 7933 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 7934 fis->d.featuresExp = 0; /* FIS reserve */ 7935 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 7936 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 7937 7938 fis->d.reserved4 = 0; 7939 fis->d.control = 0; /* FIS HOB bit clear */ 7940 fis->d.reserved5 = 0; 7941 7942 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 7943 satIOContext->ATACmd = SAT_READ_VERIFY_SECTORS_EXT; 7944 } 7945 else 7946 { 7947 TI_DBG5(("satVerify10: SAT_READ_VERIFY_SECTORS\n")); 7948 fis->h.fisType = 0x27; /* Reg host to device */ 7949 fis->h.c_pmPort = 0x80; /* C bit is set */ 7950 fis->h.command = SAT_READ_VERIFY_SECTORS; /* 0x40 */ 7951 fis->h.features = 0; /* FIS reserve */ 7952 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 7953 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 7954 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 7955 /* FIS LBA mode set LBA (27:24) */ 7956 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 7957 fis->d.lbaLowExp = 0; 7958 fis->d.lbaMidExp = 0; 7959 fis->d.lbaHighExp = 0; 7960 fis->d.featuresExp = 0; 7961 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 7962 fis->d.sectorCountExp = 0; 7963 fis->d.reserved4 = 0; 7964 fis->d.control = 0; /* FIS HOB bit clear */ 7965 fis->d.reserved5 = 0; 7966 7967 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 7968 satIOContext->ATACmd = SAT_READ_VERIFY_SECTORS; 7969 7970 } 7971 7972 satIOContext->currentLBA = lba; 7973 satIOContext->OrgTL = tl; 7974 7975 /* 7976 computing number of loop and remainder for tl 7977 0xFF in case not ext 7978 0xFFFF in case EXT 7979 */ 7980 if (fis->h.command == SAT_READ_VERIFY_SECTORS) 7981 { 7982 LoopNum = satComputeLoopNum(tl, 0xFF); 7983 } 7984 else if (fis->h.command == SAT_READ_VERIFY_SECTORS_EXT) 7985 { 7986 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 7987 LoopNum = satComputeLoopNum(tl, 0xFFFF); 7988 } 7989 else 7990 { 7991 TI_DBG1(("satVerify10: error case 1!!!\n")); 7992 LoopNum = 1; 7993 } 7994 7995 satIOContext->LoopNum = LoopNum; 7996 7997 if (LoopNum == 1) 7998 { 7999 TI_DBG5(("satVerify10: NON CHAINED data\n")); 8000 /* Initialize CB for SATA completion. 8001 */ 8002 satIOContext->satCompleteCB = &satNonChainedVerifyCB; 8003 } 8004 else 8005 { 8006 TI_DBG1(("satVerify10: CHAINED data\n")); 8007 /* re-setting tl */ 8008 if (fis->h.command == SAT_READ_VERIFY_SECTORS) 8009 { 8010 fis->d.sectorCount = 0xFF; 8011 } 8012 else if (fis->h.command == SAT_READ_VERIFY_SECTORS_EXT) 8013 { 8014 fis->d.sectorCount = 0xFF; 8015 fis->d.sectorCountExp = 0xFF; 8016 } 8017 else 8018 { 8019 TI_DBG1(("satVerify10: error case 2!!!\n")); 8020 } 8021 8022 /* Initialize CB for SATA completion. 8023 */ 8024 satIOContext->satCompleteCB = &satChainedVerifyCB; 8025 } 8026 8027 8028 /* 8029 * Prepare SGL and send FIS to LL layer. 8030 */ 8031 satIOContext->reqType = agRequestType; /* Save it */ 8032 8033 status = sataLLIOStart( tiRoot, 8034 tiIORequest, 8035 tiDeviceHandle, 8036 tiScsiRequest, 8037 satIOContext); 8038 return (status); 8039 } 8040 8041 GLOBAL bit32 satChainedVerify( 8042 tiRoot_t *tiRoot, 8043 tiIORequest_t *tiIORequest, 8044 tiDeviceHandle_t *tiDeviceHandle, 8045 tiScsiInitiatorRequest_t *tiScsiRequest, 8046 satIOContext_t *satIOContext) 8047 { 8048 bit32 status; 8049 satIOContext_t *satOrgIOContext = agNULL; 8050 agsaFisRegHostToDevice_t *fis; 8051 bit32 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 8052 bit32 lba = 0; 8053 bit32 DenomTL = 0xFF; 8054 bit32 Remainder = 0; 8055 bit8 LBA[4]; /* 0 MSB, 3 LSB */ 8056 8057 TI_DBG2(("satChainedVerify: start\n")); 8058 8059 fis = satIOContext->pFis; 8060 satOrgIOContext = satIOContext->satOrgIOContext; 8061 osti_memset(LBA,0, sizeof(LBA)); 8062 8063 switch (satOrgIOContext->ATACmd) 8064 { 8065 case SAT_READ_VERIFY_SECTORS: 8066 DenomTL = 0xFF; 8067 break; 8068 case SAT_READ_VERIFY_SECTORS_EXT: 8069 DenomTL = 0xFFFF; 8070 break; 8071 default: 8072 TI_DBG1(("satChainedVerify: error incorrect ata command 0x%x\n", satIOContext->ATACmd)); 8073 return tiError; 8074 break; 8075 } 8076 8077 Remainder = satOrgIOContext->OrgTL % DenomTL; 8078 satOrgIOContext->currentLBA = satOrgIOContext->currentLBA + DenomTL; 8079 lba = satOrgIOContext->currentLBA; 8080 8081 LBA[0] = (bit8)((lba & 0xF000) >> (8 * 3)); /* MSB */ 8082 LBA[1] = (bit8)((lba & 0xF00) >> (8 * 2)); 8083 LBA[2] = (bit8)((lba & 0xF0) >> 8); 8084 LBA[3] = (bit8)(lba & 0xF); /* LSB */ 8085 8086 switch (satOrgIOContext->ATACmd) 8087 { 8088 case SAT_READ_VERIFY_SECTORS: 8089 fis->h.fisType = 0x27; /* Reg host to device */ 8090 fis->h.c_pmPort = 0x80; /* C bit is set */ 8091 fis->h.command = SAT_READ_VERIFY_SECTORS; /* 0x40 */ 8092 fis->h.features = 0; /* FIS reserve */ 8093 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 8094 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 8095 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 8096 8097 /* FIS LBA mode set LBA (27:24) */ 8098 fis->d.device = (bit8)((0x4 << 4) | (LBA[0] & 0xF)); 8099 8100 fis->d.lbaLowExp = 0; 8101 fis->d.lbaMidExp = 0; 8102 fis->d.lbaHighExp = 0; 8103 fis->d.featuresExp = 0; 8104 if (satOrgIOContext->LoopNum == 1) 8105 { 8106 /* last loop */ 8107 fis->d.sectorCount = (bit8)Remainder; /* FIS sector count (7:0) */ 8108 } 8109 else 8110 { 8111 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 8112 } 8113 fis->d.sectorCountExp = 0; 8114 fis->d.reserved4 = 0; 8115 fis->d.control = 0; /* FIS HOB bit clear */ 8116 fis->d.reserved5 = 0; 8117 8118 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 8119 8120 break; 8121 case SAT_READ_VERIFY_SECTORS_EXT: 8122 fis->h.fisType = 0x27; /* Reg host to device */ 8123 fis->h.c_pmPort = 0x80; /* C Bit is set */ 8124 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT; /* 0x42 */ 8125 fis->h.features = 0; /* FIS reserve */ 8126 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 8127 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 8128 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 8129 fis->d.device = 0x40; /* FIS LBA mode set */ 8130 fis->d.lbaLowExp = LBA[0]; /* FIS LBA (31:24) */ 8131 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 8132 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 8133 fis->d.featuresExp = 0; /* FIS reserve */ 8134 if (satOrgIOContext->LoopNum == 1) 8135 { 8136 /* last loop */ 8137 fis->d.sectorCount = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 8138 fis->d.sectorCountExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 8139 } 8140 else 8141 { 8142 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 8143 fis->d.sectorCountExp = 0xFF; /* FIS sector count (15:8) */ 8144 } 8145 fis->d.reserved4 = 0; 8146 fis->d.control = 0; /* FIS HOB bit clear */ 8147 fis->d.reserved5 = 0; 8148 8149 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 8150 8151 break; 8152 8153 default: 8154 TI_DBG1(("satChainedVerify: error incorrect ata command 0x%x\n", satIOContext->ATACmd)); 8155 return tiError; 8156 break; 8157 } 8158 8159 /* Initialize CB for SATA completion. 8160 */ 8161 /* chained data */ 8162 satIOContext->satCompleteCB = &satChainedVerifyCB; 8163 8164 8165 /* 8166 * Prepare SGL and send FIS to LL layer. 8167 */ 8168 satIOContext->reqType = agRequestType; /* Save it */ 8169 8170 status = sataLLIOStart( tiRoot, 8171 tiIORequest, 8172 tiDeviceHandle, 8173 tiScsiRequest, 8174 satIOContext); 8175 8176 TI_DBG5(("satChainedVerify: return\n")); 8177 return (status); 8178 8179 } 8180 8181 8182 /*****************************************************************************/ 8183 /*! \brief SAT implementation for SCSI VERIFY (12). 8184 * 8185 * SAT implementation for SCSI VERIFY (12). 8186 * 8187 * \param tiRoot: Pointer to TISA initiator driver/port instance. 8188 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 8189 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 8190 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 8191 * \param satIOContext_t: Pointer to the SAT IO Context 8192 * 8193 * \return If command is started successfully 8194 * - \e tiSuccess: I/O request successfully initiated. 8195 * - \e tiBusy: No resources available, try again later. 8196 * - \e tiIONoDevice: Invalid device handle. 8197 * - \e tiError: Other errors. 8198 */ 8199 /*****************************************************************************/ 8200 GLOBAL bit32 satVerify12( 8201 tiRoot_t *tiRoot, 8202 tiIORequest_t *tiIORequest, 8203 tiDeviceHandle_t *tiDeviceHandle, 8204 tiScsiInitiatorRequest_t *tiScsiRequest, 8205 satIOContext_t *satIOContext) 8206 { 8207 /* 8208 For simple implementation, 8209 no byte comparison supported as of 4/5/06 8210 */ 8211 scsiRspSense_t *pSense; 8212 tiIniScsiCmnd_t *scsiCmnd; 8213 satDeviceData_t *pSatDevData; 8214 agsaFisRegHostToDevice_t *fis; 8215 bit32 status; 8216 bit32 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 8217 bit32 lba = 0; 8218 bit32 tl = 0; 8219 bit32 LoopNum = 1; 8220 bit8 LBA[4]; 8221 bit8 TL[4]; 8222 bit32 rangeChk = agFALSE; /* lba and tl range check */ 8223 8224 TI_DBG5(("satVerify12 entry: tiDeviceHandle=%p tiIORequest=%p\n", 8225 tiDeviceHandle, tiIORequest)); 8226 8227 pSense = satIOContext->pSense; 8228 scsiCmnd = &tiScsiRequest->scsiCmnd; 8229 pSatDevData = satIOContext->pSatDevData; 8230 fis = satIOContext->pFis; 8231 8232 8233 /* checking BYTCHK */ 8234 if (scsiCmnd->cdb[1] & SCSI_VERIFY_BYTCHK_MASK) 8235 { 8236 /* 8237 should do the byte check 8238 but not supported in this version 8239 */ 8240 satSetSensePayload( pSense, 8241 SCSI_SNSKEY_ILLEGAL_REQUEST, 8242 0, 8243 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 8244 satIOContext); 8245 8246 ostiInitiatorIOCompleted( tiRoot, 8247 tiIORequest, 8248 tiIOSuccess, 8249 SCSI_STAT_CHECK_CONDITION, 8250 satIOContext->pTiSenseData, 8251 satIOContext->interruptContext ); 8252 8253 TI_DBG1(("satVerify12: no byte checking \n")); 8254 return tiSuccess; 8255 } 8256 8257 /* checking CONTROL */ 8258 /* NACA == 1 or LINK == 1*/ 8259 if ( (scsiCmnd->cdb[11] & SCSI_NACA_MASK) || (scsiCmnd->cdb[11] & SCSI_LINK_MASK) ) 8260 { 8261 satSetSensePayload( pSense, 8262 SCSI_SNSKEY_ILLEGAL_REQUEST, 8263 0, 8264 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 8265 satIOContext); 8266 8267 ostiInitiatorIOCompleted( tiRoot, 8268 tiIORequest, 8269 tiIOSuccess, 8270 SCSI_STAT_CHECK_CONDITION, 8271 satIOContext->pTiSenseData, 8272 satIOContext->interruptContext ); 8273 8274 TI_DBG1(("satVerify12: return control\n")); 8275 return tiSuccess; 8276 } 8277 8278 osti_memset(LBA, 0, sizeof(LBA)); 8279 osti_memset(TL, 0, sizeof(TL)); 8280 8281 /* do not use memcpy due to indexing in LBA and TL */ 8282 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 8283 LBA[1] = scsiCmnd->cdb[3]; 8284 LBA[2] = scsiCmnd->cdb[4]; 8285 LBA[3] = scsiCmnd->cdb[5]; /* LSB */ 8286 8287 TL[0] = scsiCmnd->cdb[6]; /* MSB */ 8288 TL[1] = scsiCmnd->cdb[7]; 8289 TL[2] = scsiCmnd->cdb[7]; 8290 TL[3] = scsiCmnd->cdb[8]; /* LSB */ 8291 8292 rangeChk = satAddNComparebit32(LBA, TL); 8293 8294 lba = satComputeCDB12LBA(satIOContext); 8295 tl = satComputeCDB12TL(satIOContext); 8296 8297 if (pSatDevData->satNCQ != agTRUE && 8298 pSatDevData->sat48BitSupport != agTRUE 8299 ) 8300 { 8301 if (lba > SAT_TR_LBA_LIMIT - 1) 8302 { 8303 satSetSensePayload( pSense, 8304 SCSI_SNSKEY_ILLEGAL_REQUEST, 8305 0, 8306 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 8307 satIOContext); 8308 8309 ostiInitiatorIOCompleted( tiRoot, 8310 tiIORequest, 8311 tiIOSuccess, 8312 SCSI_STAT_CHECK_CONDITION, 8313 satIOContext->pTiSenseData, 8314 satIOContext->interruptContext ); 8315 8316 TI_DBG1(("satVerify12: return LBA out of range, not EXT\n")); 8317 TI_DBG1(("satVerify12: cdb 0x%x 0x%x 0x%x 0x%x\n",scsiCmnd->cdb[2], scsiCmnd->cdb[3], 8318 scsiCmnd->cdb[4], scsiCmnd->cdb[5])); 8319 TI_DBG1(("satVerify12: lba 0x%x SAT_TR_LBA_LIMIT 0x%x\n", lba, SAT_TR_LBA_LIMIT)); 8320 return tiSuccess; 8321 } 8322 8323 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 8324 { 8325 TI_DBG1(("satVerify12: return LBA+TL out of range, not EXT\n")); 8326 satSetSensePayload( pSense, 8327 SCSI_SNSKEY_ILLEGAL_REQUEST, 8328 0, 8329 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 8330 satIOContext); 8331 8332 ostiInitiatorIOCompleted( tiRoot, 8333 tiIORequest, 8334 tiIOSuccess, 8335 SCSI_STAT_CHECK_CONDITION, 8336 satIOContext->pTiSenseData, 8337 satIOContext->interruptContext ); 8338 8339 return tiSuccess; 8340 } 8341 } 8342 8343 if (pSatDevData->sat48BitSupport == agTRUE) 8344 { 8345 TI_DBG5(("satVerify12: SAT_READ_VERIFY_SECTORS_EXT\n")); 8346 fis->h.fisType = 0x27; /* Reg host to device */ 8347 fis->h.c_pmPort = 0x80; /* C Bit is set */ 8348 8349 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 8350 fis->h.features = 0; /* FIS reserve */ 8351 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 8352 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 8353 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 8354 fis->d.device = 0x40; /* FIS LBA mode set 01000000 */ 8355 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 8356 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 8357 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 8358 fis->d.featuresExp = 0; /* FIS reserve */ 8359 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 8360 fis->d.sectorCountExp = scsiCmnd->cdb[8]; /* FIS sector count (15:8) */ 8361 8362 fis->d.reserved4 = 0; 8363 fis->d.control = 0; /* FIS HOB bit clear */ 8364 fis->d.reserved5 = 0; 8365 8366 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 8367 satIOContext->ATACmd = SAT_READ_VERIFY_SECTORS_EXT; 8368 } 8369 else 8370 { 8371 TI_DBG5(("satVerify12: SAT_READ_VERIFY_SECTORS\n")); 8372 fis->h.fisType = 0x27; /* Reg host to device */ 8373 fis->h.c_pmPort = 0x80; /* C bit is set */ 8374 fis->h.command = SAT_READ_VERIFY_SECTORS; /* 0x40 */ 8375 fis->h.features = 0; /* FIS reserve */ 8376 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 8377 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 8378 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 8379 /* FIS LBA mode set LBA (27:24) */ 8380 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 8381 fis->d.lbaLowExp = 0; 8382 fis->d.lbaMidExp = 0; 8383 fis->d.lbaHighExp = 0; 8384 fis->d.featuresExp = 0; 8385 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 8386 fis->d.sectorCountExp = 0; 8387 fis->d.reserved4 = 0; 8388 fis->d.control = 0; /* FIS HOB bit clear */ 8389 fis->d.reserved5 = 0; 8390 8391 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 8392 satIOContext->ATACmd = SAT_READ_VERIFY_SECTORS; 8393 8394 } 8395 8396 satIOContext->currentLBA = lba; 8397 satIOContext->OrgTL = tl; 8398 8399 /* 8400 computing number of loop and remainder for tl 8401 0xFF in case not ext 8402 0xFFFF in case EXT 8403 */ 8404 if (fis->h.command == SAT_READ_VERIFY_SECTORS) 8405 { 8406 LoopNum = satComputeLoopNum(tl, 0xFF); 8407 } 8408 else if (fis->h.command == SAT_READ_VERIFY_SECTORS_EXT) 8409 { 8410 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 8411 LoopNum = satComputeLoopNum(tl, 0xFFFF); 8412 } 8413 else 8414 { 8415 TI_DBG1(("satVerify12: error case 1!!!\n")); 8416 LoopNum = 1; 8417 } 8418 8419 satIOContext->LoopNum = LoopNum; 8420 8421 if (LoopNum == 1) 8422 { 8423 TI_DBG5(("satVerify12: NON CHAINED data\n")); 8424 /* Initialize CB for SATA completion. 8425 */ 8426 satIOContext->satCompleteCB = &satNonChainedVerifyCB; 8427 } 8428 else 8429 { 8430 TI_DBG1(("satVerify12: CHAINED data\n")); 8431 /* re-setting tl */ 8432 if (fis->h.command == SAT_READ_VERIFY_SECTORS) 8433 { 8434 fis->d.sectorCount = 0xFF; 8435 } 8436 else if (fis->h.command == SAT_READ_VERIFY_SECTORS_EXT) 8437 { 8438 fis->d.sectorCount = 0xFF; 8439 fis->d.sectorCountExp = 0xFF; 8440 } 8441 else 8442 { 8443 TI_DBG1(("satVerify10: error case 2!!!\n")); 8444 } 8445 8446 /* Initialize CB for SATA completion. 8447 */ 8448 satIOContext->satCompleteCB = &satChainedVerifyCB; 8449 } 8450 8451 8452 /* 8453 * Prepare SGL and send FIS to LL layer. 8454 */ 8455 satIOContext->reqType = agRequestType; /* Save it */ 8456 8457 status = sataLLIOStart( tiRoot, 8458 tiIORequest, 8459 tiDeviceHandle, 8460 tiScsiRequest, 8461 satIOContext); 8462 return (status); 8463 } 8464 /*****************************************************************************/ 8465 /*! \brief SAT implementation for SCSI VERIFY (16). 8466 * 8467 * SAT implementation for SCSI VERIFY (16). 8468 * 8469 * \param tiRoot: Pointer to TISA initiator driver/port instance. 8470 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 8471 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 8472 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 8473 * \param satIOContext_t: Pointer to the SAT IO Context 8474 * 8475 * \return If command is started successfully 8476 * - \e tiSuccess: I/O request successfully initiated. 8477 * - \e tiBusy: No resources available, try again later. 8478 * - \e tiIONoDevice: Invalid device handle. 8479 * - \e tiError: Other errors. 8480 */ 8481 /*****************************************************************************/ 8482 GLOBAL bit32 satVerify16( 8483 tiRoot_t *tiRoot, 8484 tiIORequest_t *tiIORequest, 8485 tiDeviceHandle_t *tiDeviceHandle, 8486 tiScsiInitiatorRequest_t *tiScsiRequest, 8487 satIOContext_t *satIOContext) 8488 { 8489 /* 8490 For simple implementation, 8491 no byte comparison supported as of 4/5/06 8492 */ 8493 scsiRspSense_t *pSense; 8494 tiIniScsiCmnd_t *scsiCmnd; 8495 satDeviceData_t *pSatDevData; 8496 agsaFisRegHostToDevice_t *fis; 8497 bit32 status; 8498 bit32 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 8499 bit32 lba = 0; 8500 bit32 tl = 0; 8501 bit32 LoopNum = 1; 8502 bit8 LBA[8]; 8503 bit8 TL[8]; 8504 bit32 rangeChk = agFALSE; /* lba and tl range check */ 8505 bit32 limitChk = agFALSE; /* lba and tl range check */ 8506 8507 TI_DBG5(("satVerify16 entry: tiDeviceHandle=%p tiIORequest=%p\n", 8508 tiDeviceHandle, tiIORequest)); 8509 8510 pSense = satIOContext->pSense; 8511 scsiCmnd = &tiScsiRequest->scsiCmnd; 8512 pSatDevData = satIOContext->pSatDevData; 8513 fis = satIOContext->pFis; 8514 8515 /* checking BYTCHK */ 8516 if (scsiCmnd->cdb[1] & SCSI_VERIFY_BYTCHK_MASK) 8517 { 8518 /* 8519 should do the byte check 8520 but not supported in this version 8521 */ 8522 satSetSensePayload( pSense, 8523 SCSI_SNSKEY_ILLEGAL_REQUEST, 8524 0, 8525 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 8526 satIOContext); 8527 8528 ostiInitiatorIOCompleted( tiRoot, 8529 tiIORequest, 8530 tiIOSuccess, 8531 SCSI_STAT_CHECK_CONDITION, 8532 satIOContext->pTiSenseData, 8533 satIOContext->interruptContext ); 8534 8535 TI_DBG1(("satVerify16: no byte checking \n")); 8536 return tiSuccess; 8537 } 8538 8539 /* checking CONTROL */ 8540 /* NACA == 1 or LINK == 1*/ 8541 if ( (scsiCmnd->cdb[15] & SCSI_NACA_MASK) || (scsiCmnd->cdb[15] & SCSI_LINK_MASK) ) 8542 { 8543 satSetSensePayload( pSense, 8544 SCSI_SNSKEY_ILLEGAL_REQUEST, 8545 0, 8546 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 8547 satIOContext); 8548 8549 ostiInitiatorIOCompleted( tiRoot, 8550 tiIORequest, 8551 tiIOSuccess, 8552 SCSI_STAT_CHECK_CONDITION, 8553 satIOContext->pTiSenseData, 8554 satIOContext->interruptContext ); 8555 8556 TI_DBG2(("satVerify16: return control\n")); 8557 return tiSuccess; 8558 } 8559 8560 osti_memset(LBA, 0, sizeof(LBA)); 8561 osti_memset(TL, 0, sizeof(TL)); 8562 8563 8564 /* do not use memcpy due to indexing in LBA and TL */ 8565 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 8566 LBA[1] = scsiCmnd->cdb[3]; 8567 LBA[2] = scsiCmnd->cdb[4]; 8568 LBA[3] = scsiCmnd->cdb[5]; 8569 LBA[4] = scsiCmnd->cdb[6]; 8570 LBA[5] = scsiCmnd->cdb[7]; 8571 LBA[6] = scsiCmnd->cdb[8]; 8572 LBA[7] = scsiCmnd->cdb[9]; /* LSB */ 8573 8574 TL[0] = 0; 8575 TL[1] = 0; 8576 TL[2] = 0; 8577 TL[3] = 0; 8578 TL[4] = scsiCmnd->cdb[10]; /* MSB */ 8579 TL[5] = scsiCmnd->cdb[11]; 8580 TL[6] = scsiCmnd->cdb[12]; 8581 TL[7] = scsiCmnd->cdb[13]; /* LSB */ 8582 8583 rangeChk = satAddNComparebit64(LBA, TL); 8584 8585 limitChk = satCompareLBALimitbit(LBA); 8586 8587 lba = satComputeCDB16LBA(satIOContext); 8588 tl = satComputeCDB16TL(satIOContext); 8589 8590 if (pSatDevData->satNCQ != agTRUE && 8591 pSatDevData->sat48BitSupport != agTRUE 8592 ) 8593 { 8594 if (limitChk) 8595 { 8596 TI_DBG1(("satVerify16: return LBA out of range, not EXT\n")); 8597 satSetSensePayload( pSense, 8598 SCSI_SNSKEY_ILLEGAL_REQUEST, 8599 0, 8600 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 8601 satIOContext); 8602 8603 ostiInitiatorIOCompleted( tiRoot, 8604 tiIORequest, 8605 tiIOSuccess, 8606 SCSI_STAT_CHECK_CONDITION, 8607 satIOContext->pTiSenseData, 8608 satIOContext->interruptContext ); 8609 8610 return tiSuccess; 8611 } 8612 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 8613 { 8614 TI_DBG1(("satVerify16: return LBA+TL out of range, not EXT\n")); 8615 satSetSensePayload( pSense, 8616 SCSI_SNSKEY_ILLEGAL_REQUEST, 8617 0, 8618 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 8619 satIOContext); 8620 8621 ostiInitiatorIOCompleted( tiRoot, 8622 tiIORequest, 8623 tiIOSuccess, 8624 SCSI_STAT_CHECK_CONDITION, 8625 satIOContext->pTiSenseData, 8626 satIOContext->interruptContext ); 8627 8628 return tiSuccess; 8629 } 8630 } 8631 8632 if (pSatDevData->sat48BitSupport == agTRUE) 8633 { 8634 TI_DBG5(("satVerify16: SAT_READ_VERIFY_SECTORS_EXT\n")); 8635 fis->h.fisType = 0x27; /* Reg host to device */ 8636 fis->h.c_pmPort = 0x80; /* C Bit is set */ 8637 8638 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 8639 fis->h.features = 0; /* FIS reserve */ 8640 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 8641 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 8642 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 8643 fis->d.device = 0x40; /* FIS LBA mode set 01000000 */ 8644 fis->d.lbaLowExp = scsiCmnd->cdb[6]; /* FIS LBA (31:24) */ 8645 fis->d.lbaMidExp = scsiCmnd->cdb[5]; /* FIS LBA (39:32) */ 8646 fis->d.lbaHighExp = scsiCmnd->cdb[4]; /* FIS LBA (47:40) */ 8647 fis->d.featuresExp = 0; /* FIS reserve */ 8648 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 8649 fis->d.sectorCountExp = scsiCmnd->cdb[12]; /* FIS sector count (15:8) */ 8650 8651 fis->d.reserved4 = 0; 8652 fis->d.control = 0; /* FIS HOB bit clear */ 8653 fis->d.reserved5 = 0; 8654 8655 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 8656 satIOContext->ATACmd = SAT_READ_VERIFY_SECTORS_EXT; 8657 } 8658 else 8659 { 8660 TI_DBG5(("satVerify12: SAT_READ_VERIFY_SECTORS\n")); 8661 fis->h.fisType = 0x27; /* Reg host to device */ 8662 fis->h.c_pmPort = 0x80; /* C bit is set */ 8663 fis->h.command = SAT_READ_VERIFY_SECTORS; /* 0x40 */ 8664 fis->h.features = 0; /* FIS reserve */ 8665 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 8666 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 8667 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 8668 /* FIS LBA mode set LBA (27:24) */ 8669 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[6] & 0xF)); 8670 fis->d.lbaLowExp = 0; 8671 fis->d.lbaMidExp = 0; 8672 fis->d.lbaHighExp = 0; 8673 fis->d.featuresExp = 0; 8674 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 8675 fis->d.sectorCountExp = 0; 8676 fis->d.reserved4 = 0; 8677 fis->d.control = 0; /* FIS HOB bit clear */ 8678 fis->d.reserved5 = 0; 8679 8680 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 8681 satIOContext->ATACmd = SAT_READ_VERIFY_SECTORS; 8682 8683 } 8684 8685 satIOContext->currentLBA = lba; 8686 satIOContext->OrgTL = tl; 8687 8688 /* 8689 computing number of loop and remainder for tl 8690 0xFF in case not ext 8691 0xFFFF in case EXT 8692 */ 8693 if (fis->h.command == SAT_READ_VERIFY_SECTORS) 8694 { 8695 LoopNum = satComputeLoopNum(tl, 0xFF); 8696 } 8697 else if (fis->h.command == SAT_READ_VERIFY_SECTORS_EXT) 8698 { 8699 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 8700 LoopNum = satComputeLoopNum(tl, 0xFFFF); 8701 } 8702 else 8703 { 8704 TI_DBG1(("satVerify12: error case 1!!!\n")); 8705 LoopNum = 1; 8706 } 8707 8708 satIOContext->LoopNum = LoopNum; 8709 8710 if (LoopNum == 1) 8711 { 8712 TI_DBG5(("satVerify12: NON CHAINED data\n")); 8713 /* Initialize CB for SATA completion. 8714 */ 8715 satIOContext->satCompleteCB = &satNonChainedVerifyCB; 8716 } 8717 else 8718 { 8719 TI_DBG1(("satVerify12: CHAINED data\n")); 8720 /* re-setting tl */ 8721 if (fis->h.command == SAT_READ_VERIFY_SECTORS) 8722 { 8723 fis->d.sectorCount = 0xFF; 8724 } 8725 else if (fis->h.command == SAT_READ_VERIFY_SECTORS_EXT) 8726 { 8727 fis->d.sectorCount = 0xFF; 8728 fis->d.sectorCountExp = 0xFF; 8729 } 8730 else 8731 { 8732 TI_DBG1(("satVerify10: error case 2!!!\n")); 8733 } 8734 8735 /* Initialize CB for SATA completion. 8736 */ 8737 satIOContext->satCompleteCB = &satChainedVerifyCB; 8738 } 8739 8740 8741 /* 8742 * Prepare SGL and send FIS to LL layer. 8743 */ 8744 satIOContext->reqType = agRequestType; /* Save it */ 8745 8746 status = sataLLIOStart( tiRoot, 8747 tiIORequest, 8748 tiDeviceHandle, 8749 tiScsiRequest, 8750 satIOContext); 8751 return (status); 8752 } 8753 /*****************************************************************************/ 8754 /*! \brief SAT implementation for SCSI satFormatUnit. 8755 * 8756 * SAT implementation for SCSI satFormatUnit. 8757 * 8758 * \param tiRoot: Pointer to TISA initiator driver/port instance. 8759 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 8760 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 8761 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 8762 * \param satIOContext_t: Pointer to the SAT IO Context 8763 * 8764 * \return If command is started successfully 8765 * - \e tiSuccess: I/O request successfully initiated. 8766 * - \e tiBusy: No resources available, try again later. 8767 * - \e tiIONoDevice: Invalid device handle. 8768 * - \e tiError: Other errors. 8769 */ 8770 /*****************************************************************************/ 8771 GLOBAL bit32 satFormatUnit( 8772 tiRoot_t *tiRoot, 8773 tiIORequest_t *tiIORequest, 8774 tiDeviceHandle_t *tiDeviceHandle, 8775 tiScsiInitiatorRequest_t *tiScsiRequest, 8776 satIOContext_t *satIOContext) 8777 { 8778 /* 8779 note: we don't support media certification in this version and IP bit 8780 satDevData->satFormatState will be agFalse since SAT does not actually sends 8781 any ATA command 8782 */ 8783 8784 scsiRspSense_t *pSense; 8785 tiIniScsiCmnd_t *scsiCmnd; 8786 bit32 index = 0; 8787 8788 pSense = satIOContext->pSense; 8789 scsiCmnd = &tiScsiRequest->scsiCmnd; 8790 8791 TI_DBG5(("satFormatUnit:start\n")); 8792 8793 /* 8794 checking opcode 8795 1. FMTDATA bit == 0(no defect list header) 8796 2. FMTDATA bit == 1 and DCRT bit == 1(defect list header is provided 8797 with DCRT bit set) 8798 */ 8799 if ( ((scsiCmnd->cdb[1] & SCSI_FORMAT_UNIT_FMTDATA_MASK) == 0) || 8800 ((scsiCmnd->cdb[1] & SCSI_FORMAT_UNIT_FMTDATA_MASK) && 8801 (scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_DCRT_MASK)) 8802 ) 8803 { 8804 ostiInitiatorIOCompleted( tiRoot, 8805 tiIORequest, 8806 tiIOSuccess, 8807 SCSI_STAT_GOOD, 8808 agNULL, 8809 satIOContext->interruptContext); 8810 8811 TI_DBG2(("satFormatUnit: return opcode\n")); 8812 return tiSuccess; 8813 } 8814 8815 /* 8816 checking DEFECT LIST FORMAT and defect list length 8817 */ 8818 if ( (((scsiCmnd->cdb[1] & SCSI_FORMAT_UNIT_DEFECT_LIST_FORMAT_MASK) == 0x00) || 8819 ((scsiCmnd->cdb[1] & SCSI_FORMAT_UNIT_DEFECT_LIST_FORMAT_MASK) == 0x06)) ) 8820 { 8821 /* short parameter header */ 8822 if ((scsiCmnd->cdb[2] & SCSI_FORMAT_UNIT_LONGLIST_MASK) == 0x00) 8823 { 8824 index = 8; 8825 } 8826 /* long parameter header */ 8827 if ((scsiCmnd->cdb[2] & SCSI_FORMAT_UNIT_LONGLIST_MASK) == 0x01) 8828 { 8829 index = 10; 8830 } 8831 /* defect list length */ 8832 if ((scsiCmnd->cdb[index] != 0) || (scsiCmnd->cdb[index+1] != 0)) 8833 { 8834 satSetSensePayload( pSense, 8835 SCSI_SNSKEY_ILLEGAL_REQUEST, 8836 0, 8837 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 8838 satIOContext); 8839 8840 ostiInitiatorIOCompleted( tiRoot, 8841 tiIORequest, 8842 tiIOSuccess, 8843 SCSI_STAT_CHECK_CONDITION, 8844 satIOContext->pTiSenseData, 8845 satIOContext->interruptContext ); 8846 8847 TI_DBG1(("satFormatUnit: return defect list format\n")); 8848 return tiSuccess; 8849 } 8850 } 8851 8852 /* FMTDATA == 1 && CMPLIST == 1*/ 8853 if ( (scsiCmnd->cdb[1] & SCSI_FORMAT_UNIT_FMTDATA_MASK) && 8854 (scsiCmnd->cdb[1] & SCSI_FORMAT_UNIT_CMPLIST_MASK) ) 8855 { 8856 satSetSensePayload( pSense, 8857 SCSI_SNSKEY_ILLEGAL_REQUEST, 8858 0, 8859 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 8860 satIOContext); 8861 8862 ostiInitiatorIOCompleted( tiRoot, 8863 tiIORequest, 8864 tiIOSuccess, 8865 SCSI_STAT_CHECK_CONDITION, 8866 satIOContext->pTiSenseData, 8867 satIOContext->interruptContext ); 8868 8869 TI_DBG1(("satFormatUnit: return cmplist\n")); 8870 return tiSuccess; 8871 8872 } 8873 8874 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 8875 { 8876 satSetSensePayload( pSense, 8877 SCSI_SNSKEY_ILLEGAL_REQUEST, 8878 0, 8879 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 8880 satIOContext); 8881 8882 ostiInitiatorIOCompleted( tiRoot, 8883 tiIORequest, 8884 tiIOSuccess, 8885 SCSI_STAT_CHECK_CONDITION, 8886 satIOContext->pTiSenseData, 8887 satIOContext->interruptContext ); 8888 8889 TI_DBG1(("satFormatUnit: return control\n")); 8890 return tiSuccess; 8891 } 8892 8893 /* defect list header filed, if exists, SAT rev8, Table 37, p48 */ 8894 if (scsiCmnd->cdb[1] & SCSI_FORMAT_UNIT_FMTDATA_MASK) 8895 { 8896 /* case 1,2,3 */ 8897 /* IMMED 1; FOV 0; FOV 1, DCRT 1, IP 0 */ 8898 if ( (scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_IMMED_MASK) || 8899 ( !(scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_FOV_MASK)) || 8900 ( (scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_FOV_MASK) && 8901 (scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_DCRT_MASK) && 8902 !(scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_IP_MASK)) 8903 ) 8904 { 8905 ostiInitiatorIOCompleted( tiRoot, 8906 tiIORequest, 8907 tiIOSuccess, 8908 SCSI_STAT_GOOD, 8909 agNULL, 8910 satIOContext->interruptContext); 8911 8912 TI_DBG5(("satFormatUnit: return defect list case 1\n")); 8913 return tiSuccess; 8914 } 8915 /* case 4,5,6 */ 8916 /* 8917 1. IMMED 0, FOV 1, DCRT 0, IP 0 8918 2. IMMED 0, FOV 1, DCRT 0, IP 1 8919 3. IMMED 0, FOV 1, DCRT 1, IP 1 8920 */ 8921 8922 if ( ( !(scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_IMMED_MASK) && 8923 (scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_FOV_MASK) && 8924 !(scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_DCRT_MASK) && 8925 !(scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_IP_MASK) ) 8926 || 8927 ( !(scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_IMMED_MASK) && 8928 (scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_FOV_MASK) && 8929 !(scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_DCRT_MASK) && 8930 (scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_IP_MASK) ) 8931 || 8932 ( !(scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_IMMED_MASK) && 8933 (scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_FOV_MASK) && 8934 (scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_DCRT_MASK) && 8935 (scsiCmnd->cdb[7] & SCSI_FORMAT_UNIT_IP_MASK) ) 8936 ) 8937 { 8938 8939 satSetSensePayload( pSense, 8940 SCSI_SNSKEY_ILLEGAL_REQUEST, 8941 0, 8942 SCSI_SNSCODE_INVALID_FIELD_PARAMETER_LIST, 8943 satIOContext); 8944 8945 ostiInitiatorIOCompleted( tiRoot, 8946 tiIORequest, 8947 tiIOSuccess, 8948 SCSI_STAT_CHECK_CONDITION, 8949 satIOContext->pTiSenseData, 8950 satIOContext->interruptContext ); 8951 8952 TI_DBG5(("satFormatUnit: return defect list case 2\n")); 8953 return tiSuccess; 8954 8955 } 8956 } 8957 8958 8959 /* 8960 * Send the completion response now. 8961 */ 8962 ostiInitiatorIOCompleted( tiRoot, 8963 tiIORequest, 8964 tiIOSuccess, 8965 SCSI_STAT_GOOD, 8966 agNULL, 8967 satIOContext->interruptContext); 8968 8969 TI_DBG5(("satFormatUnit: return last\n")); 8970 return tiSuccess; 8971 } 8972 8973 8974 /*****************************************************************************/ 8975 /*! \brief SAT implementation for SCSI satSendDiagnostic. 8976 * 8977 * SAT implementation for SCSI satSendDiagnostic. 8978 * 8979 * \param tiRoot: Pointer to TISA initiator driver/port instance. 8980 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 8981 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 8982 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 8983 * \param satIOContext_t: Pointer to the SAT IO Context 8984 * 8985 * \return If command is started successfully 8986 * - \e tiSuccess: I/O request successfully initiated. 8987 * - \e tiBusy: No resources available, try again later. 8988 * - \e tiIONoDevice: Invalid device handle. 8989 * - \e tiError: Other errors. 8990 */ 8991 /*****************************************************************************/ 8992 GLOBAL bit32 satSendDiagnostic( 8993 tiRoot_t *tiRoot, 8994 tiIORequest_t *tiIORequest, 8995 tiDeviceHandle_t *tiDeviceHandle, 8996 tiScsiInitiatorRequest_t *tiScsiRequest, 8997 satIOContext_t *satIOContext) 8998 { 8999 bit32 status; 9000 bit32 agRequestType; 9001 satDeviceData_t *pSatDevData; 9002 scsiRspSense_t *pSense; 9003 tiIniScsiCmnd_t *scsiCmnd; 9004 agsaFisRegHostToDevice_t *fis; 9005 bit32 parmLen; 9006 9007 pSense = satIOContext->pSense; 9008 pSatDevData = satIOContext->pSatDevData; 9009 scsiCmnd = &tiScsiRequest->scsiCmnd; 9010 fis = satIOContext->pFis; 9011 9012 TI_DBG5(("satSendDiagnostic:start\n")); 9013 9014 /* reset satVerifyState */ 9015 pSatDevData->satVerifyState = 0; 9016 /* no pending diagnostic in background */ 9017 pSatDevData->satBGPendingDiag = agFALSE; 9018 9019 /* table 27, 8.10 p39 SAT Rev8 */ 9020 /* 9021 1. checking PF == 1 9022 2. checking DEVOFFL == 1 9023 3. checking UNITOFFL == 1 9024 4. checking PARAMETER LIST LENGTH != 0 9025 9026 */ 9027 if ( (scsiCmnd->cdb[1] & SCSI_PF_MASK) || 9028 (scsiCmnd->cdb[1] & SCSI_DEVOFFL_MASK) || 9029 (scsiCmnd->cdb[1] & SCSI_UNITOFFL_MASK) || 9030 ( (scsiCmnd->cdb[3] != 0) || (scsiCmnd->cdb[4] != 0) ) 9031 ) 9032 { 9033 satSetSensePayload( pSense, 9034 SCSI_SNSKEY_ILLEGAL_REQUEST, 9035 0, 9036 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 9037 satIOContext); 9038 9039 ostiInitiatorIOCompleted( tiRoot, 9040 tiIORequest, 9041 tiIOSuccess, 9042 SCSI_STAT_CHECK_CONDITION, 9043 satIOContext->pTiSenseData, 9044 satIOContext->interruptContext ); 9045 9046 TI_DBG1(("satSendDiagnostic: return PF, DEVOFFL, UNITOFFL, PARAM LIST\n")); 9047 return tiSuccess; 9048 } 9049 9050 /* checking CONTROL */ 9051 /* NACA == 1 or LINK == 1*/ 9052 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 9053 { 9054 satSetSensePayload( pSense, 9055 SCSI_SNSKEY_ILLEGAL_REQUEST, 9056 0, 9057 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 9058 satIOContext); 9059 9060 ostiInitiatorIOCompleted( tiRoot, 9061 tiIORequest, 9062 tiIOSuccess, 9063 SCSI_STAT_CHECK_CONDITION, 9064 satIOContext->pTiSenseData, 9065 satIOContext->interruptContext ); 9066 9067 TI_DBG2(("satSendDiagnostic: return control\n")); 9068 return tiSuccess; 9069 } 9070 9071 parmLen = (scsiCmnd->cdb[3] << 8) + scsiCmnd->cdb[4]; 9072 9073 /* checking SELFTEST bit*/ 9074 /* table 29, 8.10.3, p41 SAT Rev8 */ 9075 /* case 1 */ 9076 if ( !(scsiCmnd->cdb[1] & SCSI_SEND_DIAGNOSTIC_SELFTEST_MASK) && 9077 (pSatDevData->satSMARTSelfTest == agFALSE) 9078 ) 9079 { 9080 satSetSensePayload( pSense, 9081 SCSI_SNSKEY_ILLEGAL_REQUEST, 9082 0, 9083 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 9084 satIOContext); 9085 9086 ostiInitiatorIOCompleted( tiRoot, 9087 tiIORequest, 9088 tiIOSuccess, 9089 SCSI_STAT_CHECK_CONDITION, 9090 satIOContext->pTiSenseData, 9091 satIOContext->interruptContext ); 9092 9093 TI_DBG1(("satSendDiagnostic: return Table 29 case 1\n")); 9094 return tiSuccess; 9095 } 9096 9097 /* case 2 */ 9098 if ( !(scsiCmnd->cdb[1] & SCSI_SEND_DIAGNOSTIC_SELFTEST_MASK) && 9099 (pSatDevData->satSMARTSelfTest == agTRUE) && 9100 (pSatDevData->satSMARTEnabled == agFALSE) 9101 ) 9102 { 9103 satSetSensePayload( pSense, 9104 SCSI_SNSKEY_ABORTED_COMMAND, 9105 0, 9106 SCSI_SNSCODE_ATA_DEVICE_FEATURE_NOT_ENABLED, 9107 satIOContext); 9108 9109 ostiInitiatorIOCompleted( tiRoot, 9110 tiIORequest, 9111 tiIOSuccess, 9112 SCSI_STAT_CHECK_CONDITION, 9113 satIOContext->pTiSenseData, 9114 satIOContext->interruptContext ); 9115 9116 TI_DBG5(("satSendDiagnostic: return Table 29 case 2\n")); 9117 return tiSuccess; 9118 } 9119 /* 9120 case 3 9121 see SELF TEST CODE later 9122 */ 9123 9124 9125 9126 /* case 4 */ 9127 9128 /* 9129 sends three ATA verify commands 9130 9131 */ 9132 if ( ((scsiCmnd->cdb[1] & SCSI_SEND_DIAGNOSTIC_SELFTEST_MASK) && 9133 (pSatDevData->satSMARTSelfTest == agFALSE)) 9134 || 9135 ((scsiCmnd->cdb[1] & SCSI_SEND_DIAGNOSTIC_SELFTEST_MASK) && 9136 (pSatDevData->satSMARTSelfTest == agTRUE) && 9137 (pSatDevData->satSMARTEnabled == agFALSE)) 9138 ) 9139 { 9140 /* 9141 sector count 1, LBA 0 9142 sector count 1, LBA MAX 9143 sector count 1, LBA random 9144 */ 9145 if (pSatDevData->sat48BitSupport == agTRUE) 9146 { 9147 /* sends READ VERIFY SECTOR(S) EXT*/ 9148 fis->h.fisType = 0x27; /* Reg host to device */ 9149 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9150 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 9151 fis->h.features = 0; /* FIS reserve */ 9152 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 9153 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 9154 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 9155 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 9156 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 9157 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 9158 fis->d.featuresExp = 0; /* FIS reserve */ 9159 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 9160 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 9161 fis->d.reserved4 = 0; 9162 fis->d.device = 0x40; /* 01000000 */ 9163 fis->d.control = 0; /* FIS HOB bit clear */ 9164 fis->d.reserved5 = 0; 9165 9166 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9167 } 9168 else 9169 { 9170 /* READ VERIFY SECTOR(S)*/ 9171 fis->h.fisType = 0x27; /* Reg host to device */ 9172 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9173 fis->h.command = SAT_READ_VERIFY_SECTORS;/* 0x40 */ 9174 fis->h.features = 0; /* FIS features NA */ 9175 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 9176 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 9177 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 9178 fis->d.lbaLowExp = 0; 9179 fis->d.lbaMidExp = 0; 9180 fis->d.lbaHighExp = 0; 9181 fis->d.featuresExp = 0; 9182 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 9183 fis->d.sectorCountExp = 0; 9184 fis->d.reserved4 = 0; 9185 fis->d.device = 0x40; /* 01000000 */ 9186 fis->d.control = 0; /* FIS HOB bit clear */ 9187 fis->d.reserved5 = 0; 9188 9189 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9190 } 9191 9192 /* Initialize CB for SATA completion. 9193 */ 9194 satIOContext->satCompleteCB = &satSendDiagnosticCB; 9195 9196 /* 9197 * Prepare SGL and send FIS to LL layer. 9198 */ 9199 satIOContext->reqType = agRequestType; /* Save it */ 9200 9201 status = sataLLIOStart( tiRoot, 9202 tiIORequest, 9203 tiDeviceHandle, 9204 tiScsiRequest, 9205 satIOContext); 9206 9207 9208 TI_DBG5(("satSendDiagnostic: return Table 29 case 4\n")); 9209 return (status); 9210 } 9211 /* case 5 */ 9212 if ( (scsiCmnd->cdb[1] & SCSI_SEND_DIAGNOSTIC_SELFTEST_MASK) && 9213 (pSatDevData->satSMARTSelfTest == agTRUE) && 9214 (pSatDevData->satSMARTEnabled == agTRUE) 9215 ) 9216 { 9217 /* sends SMART EXECUTE OFF-LINE IMMEDIATE */ 9218 fis->h.fisType = 0x27; /* Reg host to device */ 9219 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9220 fis->h.command = SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE;/* 0xB0 */ 9221 fis->h.features = 0xD4; /* FIS features NA */ 9222 fis->d.lbaLow = 0x81; /* FIS LBA (7 :0 ) */ 9223 fis->d.lbaMid = 0x4F; /* FIS LBA (15:8 ) */ 9224 fis->d.lbaHigh = 0xC2; /* FIS LBA (23:16) */ 9225 fis->d.lbaLowExp = 0; 9226 fis->d.lbaMidExp = 0; 9227 fis->d.lbaHighExp = 0; 9228 fis->d.featuresExp = 0; 9229 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 9230 fis->d.sectorCountExp = 0; 9231 fis->d.reserved4 = 0; 9232 fis->d.device = 0; /* FIS DEV is discared in SATA */ 9233 fis->d.control = 0; /* FIS HOB bit clear */ 9234 fis->d.reserved5 = 0; 9235 9236 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9237 9238 /* Initialize CB for SATA completion. 9239 */ 9240 satIOContext->satCompleteCB = &satSendDiagnosticCB; 9241 9242 /* 9243 * Prepare SGL and send FIS to LL layer. 9244 */ 9245 satIOContext->reqType = agRequestType; /* Save it */ 9246 9247 status = sataLLIOStart( tiRoot, 9248 tiIORequest, 9249 tiDeviceHandle, 9250 tiScsiRequest, 9251 satIOContext); 9252 9253 9254 TI_DBG5(("satSendDiagnostic: return Table 29 case 5\n")); 9255 return (status); 9256 } 9257 9258 9259 9260 9261 /* SAT rev8 Table29 p41 case 3*/ 9262 /* checking SELF TEST CODE*/ 9263 if ( !(scsiCmnd->cdb[1] & SCSI_SEND_DIAGNOSTIC_SELFTEST_MASK) && 9264 (pSatDevData->satSMARTSelfTest == agTRUE) && 9265 (pSatDevData->satSMARTEnabled == agTRUE) 9266 ) 9267 { 9268 /* SAT rev8 Table28 p40 */ 9269 /* finding self-test code */ 9270 switch ((scsiCmnd->cdb[1] & SCSI_SEND_DIAGNOSTIC_TEST_CODE_MASK) >> 5) 9271 { 9272 case 1: 9273 pSatDevData->satBGPendingDiag = agTRUE; 9274 9275 ostiInitiatorIOCompleted( tiRoot, 9276 tiIORequest, 9277 tiIOSuccess, 9278 SCSI_STAT_GOOD, 9279 agNULL, 9280 satIOContext->interruptContext ); 9281 /* sends SMART EXECUTE OFF-LINE IMMEDIATE */ 9282 fis->h.fisType = 0x27; /* Reg host to device */ 9283 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9284 fis->h.command = SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE;/* 0x40 */ 9285 fis->h.features = 0xD4; /* FIS features NA */ 9286 fis->d.lbaLow = 0x01; /* FIS LBA (7 :0 ) */ 9287 fis->d.lbaMid = 0x4F; /* FIS LBA (15:8 ) */ 9288 fis->d.lbaHigh = 0xC2; /* FIS LBA (23:16) */ 9289 9290 fis->d.lbaLowExp = 0; 9291 fis->d.lbaMidExp = 0; 9292 fis->d.lbaHighExp = 0; 9293 fis->d.featuresExp = 0; 9294 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 9295 fis->d.sectorCountExp = 0; 9296 fis->d.reserved4 = 0; 9297 fis->d.device = 0; /* FIS DEV is discared in SATA */ 9298 fis->d.control = 0; /* FIS HOB bit clear */ 9299 fis->d.reserved5 = 0; 9300 9301 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9302 9303 /* Initialize CB for SATA completion. 9304 */ 9305 satIOContext->satCompleteCB = &satSendDiagnosticCB; 9306 9307 /* 9308 * Prepare SGL and send FIS to LL layer. 9309 */ 9310 satIOContext->reqType = agRequestType; /* Save it */ 9311 9312 status = sataLLIOStart( tiRoot, 9313 tiIORequest, 9314 tiDeviceHandle, 9315 tiScsiRequest, 9316 satIOContext); 9317 9318 9319 TI_DBG5(("satSendDiagnostic: return Table 28 case 1\n")); 9320 return (status); 9321 case 2: 9322 pSatDevData->satBGPendingDiag = agTRUE; 9323 9324 ostiInitiatorIOCompleted( tiRoot, 9325 tiIORequest, 9326 tiIOSuccess, 9327 SCSI_STAT_GOOD, 9328 agNULL, 9329 satIOContext->interruptContext ); 9330 9331 9332 /* issuing SMART EXECUTE OFF-LINE IMMEDIATE */ 9333 fis->h.fisType = 0x27; /* Reg host to device */ 9334 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9335 fis->h.command = SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE;/* 0x40 */ 9336 fis->h.features = 0xD4; /* FIS features NA */ 9337 fis->d.lbaLow = 0x02; /* FIS LBA (7 :0 ) */ 9338 fis->d.lbaMid = 0x4F; /* FIS LBA (15:8 ) */ 9339 fis->d.lbaHigh = 0xC2; /* FIS LBA (23:16) */ 9340 fis->d.lbaLowExp = 0; 9341 fis->d.lbaMidExp = 0; 9342 fis->d.lbaHighExp = 0; 9343 fis->d.featuresExp = 0; 9344 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 9345 fis->d.sectorCountExp = 0; 9346 fis->d.reserved4 = 0; 9347 fis->d.device = 0; /* FIS DEV is discared in SATA */ 9348 fis->d.control = 0; /* FIS HOB bit clear */ 9349 fis->d.reserved5 = 0; 9350 9351 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9352 9353 /* Initialize CB for SATA completion. 9354 */ 9355 satIOContext->satCompleteCB = &satSendDiagnosticCB; 9356 9357 /* 9358 * Prepare SGL and send FIS to LL layer. 9359 */ 9360 satIOContext->reqType = agRequestType; /* Save it */ 9361 9362 status = sataLLIOStart( tiRoot, 9363 tiIORequest, 9364 tiDeviceHandle, 9365 tiScsiRequest, 9366 satIOContext); 9367 9368 9369 TI_DBG5(("satSendDiagnostic: return Table 28 case 2\n")); 9370 return (status); 9371 case 4: 9372 /* For simplicity, no abort is supported 9373 Returns good status 9374 need a flag in device data for previously sent background Send Diagnostic 9375 */ 9376 if (parmLen != 0) 9377 { 9378 /* check condition */ 9379 satSetSensePayload( pSense, 9380 SCSI_SNSKEY_ILLEGAL_REQUEST, 9381 0, 9382 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 9383 satIOContext); 9384 9385 ostiInitiatorIOCompleted( tiRoot, 9386 tiIORequest, 9387 tiIOSuccess, 9388 SCSI_STAT_CHECK_CONDITION, 9389 satIOContext->pTiSenseData, 9390 satIOContext->interruptContext ); 9391 9392 TI_DBG1(("satSendDiagnostic: case 4, non zero ParmLen %d\n", parmLen)); 9393 return tiSuccess; 9394 } 9395 if (pSatDevData->satBGPendingDiag == agTRUE) 9396 { 9397 /* sends SMART EXECUTE OFF-LINE IMMEDIATE abort */ 9398 fis->h.fisType = 0x27; /* Reg host to device */ 9399 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9400 fis->h.command = SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE;/* 0x40 */ 9401 fis->h.features = 0xD4; /* FIS features NA */ 9402 fis->d.lbaLow = 0x7F; /* FIS LBA (7 :0 ) */ 9403 fis->d.lbaMid = 0x4F; /* FIS LBA (15:8 ) */ 9404 fis->d.lbaHigh = 0xC2; /* FIS LBA (23:16) */ 9405 9406 fis->d.lbaLowExp = 0; 9407 fis->d.lbaMidExp = 0; 9408 fis->d.lbaHighExp = 0; 9409 fis->d.featuresExp = 0; 9410 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 9411 fis->d.sectorCountExp = 0; 9412 fis->d.reserved4 = 0; 9413 fis->d.device = 0; /* FIS DEV is discared in SATA */ 9414 fis->d.control = 0; /* FIS HOB bit clear */ 9415 fis->d.reserved5 = 0; 9416 9417 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9418 9419 /* Initialize CB for SATA completion. 9420 */ 9421 satIOContext->satCompleteCB = &satSendDiagnosticCB; 9422 9423 /* 9424 * Prepare SGL and send FIS to LL layer. 9425 */ 9426 satIOContext->reqType = agRequestType; /* Save it */ 9427 9428 status = sataLLIOStart( tiRoot, 9429 tiIORequest, 9430 tiDeviceHandle, 9431 tiScsiRequest, 9432 satIOContext); 9433 9434 9435 TI_DBG5(("satSendDiagnostic: send SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE case 3\n")); 9436 TI_DBG5(("satSendDiagnostic: Table 28 case 4\n")); 9437 return (status); 9438 } 9439 else 9440 { 9441 /* check condition */ 9442 satSetSensePayload( pSense, 9443 SCSI_SNSKEY_ILLEGAL_REQUEST, 9444 0, 9445 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 9446 satIOContext); 9447 9448 ostiInitiatorIOCompleted( tiRoot, 9449 tiIORequest, 9450 tiIOSuccess, 9451 SCSI_STAT_CHECK_CONDITION, 9452 satIOContext->pTiSenseData, 9453 satIOContext->interruptContext ); 9454 9455 TI_DBG1(("satSendDiagnostic: case 4, no pending diagnostic in background\n")); 9456 TI_DBG5(("satSendDiagnostic: Table 28 case 4\n")); 9457 return tiSuccess; 9458 } 9459 break; 9460 case 5: 9461 /* issuing SMART EXECUTE OFF-LINE IMMEDIATE */ 9462 fis->h.fisType = 0x27; /* Reg host to device */ 9463 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9464 fis->h.command = SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE;/* 0x40 */ 9465 fis->h.features = 0xD4; /* FIS features NA */ 9466 fis->d.lbaLow = 0x81; /* FIS LBA (7 :0 ) */ 9467 fis->d.lbaMid = 0x4F; /* FIS LBA (15:8 ) */ 9468 fis->d.lbaHigh = 0xC2; /* FIS LBA (23:16) */ 9469 fis->d.lbaLowExp = 0; 9470 fis->d.lbaMidExp = 0; 9471 fis->d.lbaHighExp = 0; 9472 fis->d.featuresExp = 0; 9473 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 9474 fis->d.sectorCountExp = 0; 9475 fis->d.reserved4 = 0; 9476 fis->d.device = 0; /* FIS DEV is discared in SATA */ 9477 fis->d.control = 0; /* FIS HOB bit clear */ 9478 fis->d.reserved5 = 0; 9479 9480 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9481 9482 /* Initialize CB for SATA completion. 9483 */ 9484 satIOContext->satCompleteCB = &satSendDiagnosticCB; 9485 9486 /* 9487 * Prepare SGL and send FIS to LL layer. 9488 */ 9489 satIOContext->reqType = agRequestType; /* Save it */ 9490 9491 status = sataLLIOStart( tiRoot, 9492 tiIORequest, 9493 tiDeviceHandle, 9494 tiScsiRequest, 9495 satIOContext); 9496 9497 9498 TI_DBG5(("satSendDiagnostic: return Table 28 case 5\n")); 9499 return (status); 9500 case 6: 9501 /* issuing SMART EXECUTE OFF-LINE IMMEDIATE */ 9502 fis->h.fisType = 0x27; /* Reg host to device */ 9503 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9504 fis->h.command = SAT_SMART_EXEUTE_OFF_LINE_IMMEDIATE;/* 0x40 */ 9505 fis->h.features = 0xD4; /* FIS features NA */ 9506 fis->d.lbaLow = 0x82; /* FIS LBA (7 :0 ) */ 9507 fis->d.lbaMid = 0x4F; /* FIS LBA (15:8 ) */ 9508 fis->d.lbaHigh = 0xC2; /* FIS LBA (23:16) */ 9509 fis->d.lbaLowExp = 0; 9510 fis->d.lbaMidExp = 0; 9511 fis->d.lbaHighExp = 0; 9512 fis->d.featuresExp = 0; 9513 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 9514 fis->d.sectorCountExp = 0; 9515 fis->d.reserved4 = 0; 9516 fis->d.device = 0; /* FIS DEV is discared in SATA */ 9517 fis->d.control = 0; /* FIS HOB bit clear */ 9518 fis->d.reserved5 = 0; 9519 9520 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9521 9522 /* Initialize CB for SATA completion. 9523 */ 9524 satIOContext->satCompleteCB = &satSendDiagnosticCB; 9525 9526 /* 9527 * Prepare SGL and send FIS to LL layer. 9528 */ 9529 satIOContext->reqType = agRequestType; /* Save it */ 9530 9531 status = sataLLIOStart( tiRoot, 9532 tiIORequest, 9533 tiDeviceHandle, 9534 tiScsiRequest, 9535 satIOContext); 9536 9537 9538 TI_DBG5(("satSendDiagnostic: return Table 28 case 6\n")); 9539 return (status); 9540 case 0: 9541 case 3: /* fall through */ 9542 case 7: /* fall through */ 9543 default: 9544 break; 9545 }/* switch */ 9546 9547 /* returns the results of default self-testing, which is good */ 9548 ostiInitiatorIOCompleted( tiRoot, 9549 tiIORequest, 9550 tiIOSuccess, 9551 SCSI_STAT_GOOD, 9552 agNULL, 9553 satIOContext->interruptContext ); 9554 9555 TI_DBG5(("satSendDiagnostic: return Table 28 case 0,3,7 and default\n")); 9556 return tiSuccess; 9557 } 9558 9559 9560 ostiInitiatorIOCompleted( tiRoot, 9561 tiIORequest, 9562 tiIOSuccess, 9563 SCSI_STAT_GOOD, 9564 agNULL, 9565 satIOContext->interruptContext ); 9566 9567 9568 TI_DBG5(("satSendDiagnostic: return last\n")); 9569 return tiSuccess; 9570 } 9571 9572 /*****************************************************************************/ 9573 /*! \brief SAT implementation for SCSI satSendDiagnostic_1. 9574 * 9575 * SAT implementation for SCSI satSendDiagnostic_1. 9576 * Sub function of satSendDiagnostic. 9577 * 9578 * \param tiRoot: Pointer to TISA initiator driver/port instance. 9579 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 9580 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 9581 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 9582 * \param satIOContext_t: Pointer to the SAT IO Context 9583 * 9584 * \return If command is started successfully 9585 * - \e tiSuccess: I/O request successfully initiated. 9586 * - \e tiBusy: No resources available, try again later. 9587 * - \e tiIONoDevice: Invalid device handle. 9588 * - \e tiError: Other errors. 9589 */ 9590 /*****************************************************************************/ 9591 GLOBAL bit32 satSendDiagnostic_1( 9592 tiRoot_t *tiRoot, 9593 tiIORequest_t *tiIORequest, 9594 tiDeviceHandle_t *tiDeviceHandle, 9595 tiScsiInitiatorRequest_t *tiScsiRequest, 9596 satIOContext_t *satIOContext) 9597 { 9598 /* 9599 SAT Rev9, Table29, p41 9600 send 2nd SAT_READ_VERIFY_SECTORS(_EXT) 9601 */ 9602 bit32 status; 9603 bit32 agRequestType; 9604 satDeviceData_t *pSatDevData; 9605 agsaFisRegHostToDevice_t *fis; 9606 9607 TI_DBG5(("satSendDiagnostic_1 entry: tiDeviceHandle=%p tiIORequest=%p\n", 9608 tiDeviceHandle, tiIORequest)); 9609 9610 pSatDevData = satIOContext->pSatDevData; 9611 fis = satIOContext->pFis; 9612 9613 /* 9614 sector count 1, LBA MAX 9615 */ 9616 if (pSatDevData->sat48BitSupport == agTRUE) 9617 { 9618 /* sends READ VERIFY SECTOR(S) EXT*/ 9619 fis->h.fisType = 0x27; /* Reg host to device */ 9620 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9621 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 9622 fis->h.features = 0; /* FIS reserve */ 9623 fis->d.lbaLow = pSatDevData->satMaxLBA[7]; /* FIS LBA (7 :0 ) */ 9624 fis->d.lbaMid = pSatDevData->satMaxLBA[6]; /* FIS LBA (15:8 ) */ 9625 fis->d.lbaHigh = pSatDevData->satMaxLBA[5]; /* FIS LBA (23:16) */ 9626 fis->d.lbaLowExp = pSatDevData->satMaxLBA[4]; /* FIS LBA (31:24) */ 9627 fis->d.lbaMidExp = pSatDevData->satMaxLBA[3]; /* FIS LBA (39:32) */ 9628 fis->d.lbaHighExp = pSatDevData->satMaxLBA[2]; /* FIS LBA (47:40) */ 9629 fis->d.featuresExp = 0; /* FIS reserve */ 9630 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 9631 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 9632 fis->d.reserved4 = 0; 9633 fis->d.device = 0x40; /* 01000000 */ 9634 fis->d.control = 0; /* FIS HOB bit clear */ 9635 fis->d.reserved5 = 0; 9636 9637 } 9638 else 9639 { 9640 /* READ VERIFY SECTOR(S)*/ 9641 fis->h.fisType = 0x27; /* Reg host to device */ 9642 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9643 fis->h.command = SAT_READ_VERIFY_SECTORS;/* 0x40 */ 9644 fis->h.features = 0; /* FIS features NA */ 9645 fis->d.lbaLow = pSatDevData->satMaxLBA[7]; /* FIS LBA (7 :0 ) */ 9646 fis->d.lbaMid = pSatDevData->satMaxLBA[6]; /* FIS LBA (15:8 ) */ 9647 fis->d.lbaHigh = pSatDevData->satMaxLBA[5]; /* FIS LBA (23:16) */ 9648 fis->d.lbaLowExp = 0; 9649 fis->d.lbaMidExp = 0; 9650 fis->d.lbaHighExp = 0; 9651 fis->d.featuresExp = 0; 9652 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 9653 fis->d.sectorCountExp = 0; 9654 fis->d.reserved4 = 0; 9655 fis->d.device = (bit8)((0x4 << 4) | (pSatDevData->satMaxLBA[4] & 0xF)); 9656 /* DEV and LBA 27:24 */ 9657 fis->d.control = 0; /* FIS HOB bit clear */ 9658 fis->d.reserved5 = 0; 9659 9660 } 9661 9662 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9663 9664 /* Initialize CB for SATA completion. 9665 */ 9666 satIOContext->satCompleteCB = &satSendDiagnosticCB; 9667 9668 /* 9669 * Prepare SGL and send FIS to LL layer. 9670 */ 9671 satIOContext->reqType = agRequestType; /* Save it */ 9672 9673 status = sataLLIOStart( tiRoot, 9674 tiIORequest, 9675 tiDeviceHandle, 9676 tiScsiRequest, 9677 satIOContext); 9678 9679 9680 return status; 9681 } 9682 9683 /*****************************************************************************/ 9684 /*! \brief SAT implementation for SCSI satSendDiagnostic_2. 9685 * 9686 * SAT implementation for SCSI satSendDiagnostic_2. 9687 * Sub function of satSendDiagnostic. 9688 * 9689 * \param tiRoot: Pointer to TISA initiator driver/port instance. 9690 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 9691 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 9692 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 9693 * \param satIOContext_t: Pointer to the SAT IO Context 9694 * 9695 * \return If command is started successfully 9696 * - \e tiSuccess: I/O request successfully initiated. 9697 * - \e tiBusy: No resources available, try again later. 9698 * - \e tiIONoDevice: Invalid device handle. 9699 * - \e tiError: Other errors. 9700 */ 9701 /*****************************************************************************/ 9702 GLOBAL bit32 satSendDiagnostic_2( 9703 tiRoot_t *tiRoot, 9704 tiIORequest_t *tiIORequest, 9705 tiDeviceHandle_t *tiDeviceHandle, 9706 tiScsiInitiatorRequest_t *tiScsiRequest, 9707 satIOContext_t *satIOContext) 9708 { 9709 /* 9710 SAT Rev9, Table29, p41 9711 send 3rd SAT_READ_VERIFY_SECTORS(_EXT) 9712 */ 9713 bit32 status; 9714 bit32 agRequestType; 9715 satDeviceData_t *pSatDevData; 9716 agsaFisRegHostToDevice_t *fis; 9717 9718 TI_DBG5(("satSendDiagnostic_2 entry: tiDeviceHandle=%p tiIORequest=%p\n", 9719 tiDeviceHandle, tiIORequest)); 9720 9721 pSatDevData = satIOContext->pSatDevData; 9722 fis = satIOContext->pFis; 9723 9724 /* 9725 sector count 1, LBA Random 9726 */ 9727 if (pSatDevData->sat48BitSupport == agTRUE) 9728 { 9729 /* sends READ VERIFY SECTOR(S) EXT*/ 9730 fis->h.fisType = 0x27; /* Reg host to device */ 9731 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9732 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 9733 fis->h.features = 0; /* FIS reserve */ 9734 fis->d.lbaLow = 0x7F; /* FIS LBA (7 :0 ) */ 9735 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 9736 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 9737 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 9738 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 9739 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 9740 fis->d.featuresExp = 0; /* FIS reserve */ 9741 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 9742 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 9743 fis->d.reserved4 = 0; 9744 fis->d.device = 0x40; /* 01000000 */ 9745 fis->d.control = 0; /* FIS HOB bit clear */ 9746 fis->d.reserved5 = 0; 9747 9748 } 9749 else 9750 { 9751 /* READ VERIFY SECTOR(S)*/ 9752 fis->h.fisType = 0x27; /* Reg host to device */ 9753 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9754 fis->h.command = SAT_READ_VERIFY_SECTORS;/* 0x40 */ 9755 fis->h.features = 0; /* FIS features NA */ 9756 fis->d.lbaLow = 0x7F; /* FIS LBA (7 :0 ) */ 9757 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 9758 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 9759 fis->d.lbaLowExp = 0; 9760 fis->d.lbaMidExp = 0; 9761 fis->d.lbaHighExp = 0; 9762 fis->d.featuresExp = 0; 9763 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 9764 fis->d.sectorCountExp = 0; 9765 fis->d.reserved4 = 0; 9766 fis->d.device = 0x40; /* FIS LBA mode set 01000000 */ 9767 fis->d.control = 0; /* FIS HOB bit clear */ 9768 fis->d.reserved5 = 0; 9769 9770 } 9771 9772 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9773 9774 /* Initialize CB for SATA completion. 9775 */ 9776 satIOContext->satCompleteCB = &satSendDiagnosticCB; 9777 9778 /* 9779 * Prepare SGL and send FIS to LL layer. 9780 */ 9781 satIOContext->reqType = agRequestType; /* Save it */ 9782 9783 status = sataLLIOStart( tiRoot, 9784 tiIORequest, 9785 tiDeviceHandle, 9786 tiScsiRequest, 9787 satIOContext); 9788 9789 9790 return status; 9791 } 9792 /*****************************************************************************/ 9793 /*! \brief SAT implementation for SCSI satStartStopUnit. 9794 * 9795 * SAT implementation for SCSI satStartStopUnit. 9796 * 9797 * \param tiRoot: Pointer to TISA initiator driver/port instance. 9798 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 9799 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 9800 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 9801 * \param satIOContext_t: Pointer to the SAT IO Context 9802 * 9803 * \return If command is started successfully 9804 * - \e tiSuccess: I/O request successfully initiated. 9805 * - \e tiBusy: No resources available, try again later. 9806 * - \e tiIONoDevice: Invalid device handle. 9807 * - \e tiError: Other errors. 9808 */ 9809 /*****************************************************************************/ 9810 GLOBAL bit32 satStartStopUnit( 9811 tiRoot_t *tiRoot, 9812 tiIORequest_t *tiIORequest, 9813 tiDeviceHandle_t *tiDeviceHandle, 9814 tiScsiInitiatorRequest_t *tiScsiRequest, 9815 satIOContext_t *satIOContext) 9816 { 9817 bit32 status; 9818 bit32 agRequestType; 9819 satDeviceData_t *pSatDevData; 9820 scsiRspSense_t *pSense; 9821 tiIniScsiCmnd_t *scsiCmnd; 9822 agsaFisRegHostToDevice_t *fis; 9823 9824 pSense = satIOContext->pSense; 9825 pSatDevData = satIOContext->pSatDevData; 9826 scsiCmnd = &tiScsiRequest->scsiCmnd; 9827 fis = satIOContext->pFis; 9828 9829 TI_DBG5(("satStartStopUnit:start\n")); 9830 9831 /* checking CONTROL */ 9832 /* NACA == 1 or LINK == 1*/ 9833 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 9834 { 9835 satSetSensePayload( pSense, 9836 SCSI_SNSKEY_ILLEGAL_REQUEST, 9837 0, 9838 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 9839 satIOContext); 9840 9841 ostiInitiatorIOCompleted( tiRoot, 9842 tiIORequest, 9843 tiIOSuccess, 9844 SCSI_STAT_CHECK_CONDITION, 9845 satIOContext->pTiSenseData, 9846 satIOContext->interruptContext ); 9847 9848 TI_DBG1(("satStartStopUnit: return control\n")); 9849 return tiSuccess; 9850 } 9851 9852 /* Spec p55, Table 48 checking START and LOEJ bit */ 9853 /* case 1 */ 9854 if ( !(scsiCmnd->cdb[4] & SCSI_START_MASK) && !(scsiCmnd->cdb[4] & SCSI_LOEJ_MASK) ) 9855 { 9856 if ( (scsiCmnd->cdb[1] & SCSI_IMMED_MASK) ) 9857 { 9858 /* immed bit , SAT rev 8, 9.11.2.1 p 54*/ 9859 ostiInitiatorIOCompleted( tiRoot, 9860 tiIORequest, 9861 tiIOSuccess, 9862 SCSI_STAT_GOOD, 9863 agNULL, 9864 satIOContext->interruptContext ); 9865 TI_DBG5(("satStartStopUnit: return table48 case 1-1\n")); 9866 return tiSuccess; 9867 } 9868 /* sends FLUSH CACHE or FLUSH CACHE EXT */ 9869 if (pSatDevData->sat48BitSupport == agTRUE) 9870 { 9871 /* FLUSH CACHE EXT */ 9872 fis->h.fisType = 0x27; /* Reg host to device */ 9873 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9874 9875 fis->h.command = SAT_FLUSH_CACHE_EXT; /* 0xEA */ 9876 fis->h.features = 0; /* FIS reserve */ 9877 fis->d.featuresExp = 0; /* FIS reserve */ 9878 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 9879 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 9880 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 9881 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 9882 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 9883 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 9884 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 9885 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 9886 fis->d.device = 0; /* FIS DEV is discared in SATA */ 9887 fis->d.control = 0; /* FIS HOB bit clear */ 9888 fis->d.reserved4 = 0; 9889 fis->d.reserved5 = 0; 9890 9891 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9892 } 9893 else 9894 { 9895 /* FLUSH CACHE */ 9896 fis->h.fisType = 0x27; /* Reg host to device */ 9897 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9898 9899 fis->h.command = SAT_FLUSH_CACHE; /* 0xE7 */ 9900 fis->h.features = 0; /* FIS features NA */ 9901 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 9902 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 9903 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 9904 fis->d.lbaLowExp = 0; 9905 fis->d.lbaMidExp = 0; 9906 fis->d.lbaHighExp = 0; 9907 fis->d.featuresExp = 0; 9908 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 9909 fis->d.sectorCountExp = 0; 9910 fis->d.device = 0; /* FIS DEV is discared in SATA */ 9911 fis->d.control = 0; /* FIS HOB bit clear */ 9912 fis->d.reserved4 = 0; 9913 fis->d.reserved5 = 0; 9914 9915 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 9916 } 9917 9918 /* Initialize CB for SATA completion. 9919 */ 9920 satIOContext->satCompleteCB = &satStartStopUnitCB; 9921 9922 /* 9923 * Prepare SGL and send FIS to LL layer. 9924 */ 9925 satIOContext->reqType = agRequestType; /* Save it */ 9926 9927 status = sataLLIOStart( tiRoot, 9928 tiIORequest, 9929 tiDeviceHandle, 9930 tiScsiRequest, 9931 satIOContext); 9932 9933 9934 TI_DBG5(("satStartStopUnit: return table48 case 1\n")); 9935 return (status); 9936 } 9937 /* case 2 */ 9938 else if ( (scsiCmnd->cdb[4] & SCSI_START_MASK) && !(scsiCmnd->cdb[4] & SCSI_LOEJ_MASK) ) 9939 { 9940 /* immed bit , SAT rev 8, 9.11.2.1 p 54*/ 9941 if ( (scsiCmnd->cdb[1] & SCSI_IMMED_MASK) ) 9942 { 9943 ostiInitiatorIOCompleted( tiRoot, 9944 tiIORequest, 9945 tiIOSuccess, 9946 SCSI_STAT_GOOD, 9947 agNULL, 9948 satIOContext->interruptContext ); 9949 9950 TI_DBG5(("satStartStopUnit: return table48 case 2 1\n")); 9951 return tiSuccess; 9952 } 9953 /* 9954 sends READ_VERIFY_SECTORS(_EXT) 9955 sector count 1, any LBA between zero to Maximum 9956 */ 9957 if (pSatDevData->sat48BitSupport == agTRUE) 9958 { 9959 /* READ VERIFY SECTOR(S) EXT*/ 9960 fis->h.fisType = 0x27; /* Reg host to device */ 9961 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9962 9963 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 9964 fis->h.features = 0; /* FIS reserve */ 9965 fis->d.lbaLow = 0x01; /* FIS LBA (7 :0 ) */ 9966 fis->d.lbaMid = 0x00; /* FIS LBA (15:8 ) */ 9967 fis->d.lbaHigh = 0x00; /* FIS LBA (23:16) */ 9968 fis->d.lbaLowExp = 0x00; /* FIS LBA (31:24) */ 9969 fis->d.lbaMidExp = 0x00; /* FIS LBA (39:32) */ 9970 fis->d.lbaHighExp = 0x00; /* FIS LBA (47:40) */ 9971 fis->d.featuresExp = 0; /* FIS reserve */ 9972 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 9973 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 9974 fis->d.reserved4 = 0; 9975 fis->d.device = 0x40; /* 01000000 */ 9976 fis->d.control = 0; /* FIS HOB bit clear */ 9977 fis->d.reserved5 = 0; 9978 9979 } 9980 else 9981 { 9982 /* READ VERIFY SECTOR(S)*/ 9983 fis->h.fisType = 0x27; /* Reg host to device */ 9984 fis->h.c_pmPort = 0x80; /* C Bit is set */ 9985 9986 fis->h.command = SAT_READ_VERIFY_SECTORS;/* 0x40 */ 9987 fis->h.features = 0; /* FIS features NA */ 9988 fis->d.lbaLow = 0x01; /* FIS LBA (7 :0 ) */ 9989 fis->d.lbaMid = 0x00; /* FIS LBA (15:8 ) */ 9990 fis->d.lbaHigh = 0x00; /* FIS LBA (23:16) */ 9991 fis->d.lbaLowExp = 0; 9992 fis->d.lbaMidExp = 0; 9993 fis->d.lbaHighExp = 0; 9994 fis->d.featuresExp = 0; 9995 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 9996 fis->d.sectorCountExp = 0; 9997 fis->d.reserved4 = 0; 9998 fis->d.device = 0x40; /* 01000000 */ 9999 fis->d.control = 0; /* FIS HOB bit clear */ 10000 fis->d.reserved5 = 0; 10001 10002 } 10003 10004 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 10005 10006 /* Initialize CB for SATA completion. 10007 */ 10008 satIOContext->satCompleteCB = &satStartStopUnitCB; 10009 10010 /* 10011 * Prepare SGL and send FIS to LL layer. 10012 */ 10013 satIOContext->reqType = agRequestType; /* Save it */ 10014 10015 status = sataLLIOStart( tiRoot, 10016 tiIORequest, 10017 tiDeviceHandle, 10018 tiScsiRequest, 10019 satIOContext); 10020 10021 TI_DBG5(("satStartStopUnit: return table48 case 2 2\n")); 10022 return status; 10023 } 10024 /* case 3 */ 10025 else if ( !(scsiCmnd->cdb[4] & SCSI_START_MASK) && (scsiCmnd->cdb[4] & SCSI_LOEJ_MASK) ) 10026 { 10027 if(pSatDevData->satRemovableMedia && pSatDevData->satRemovableMediaEnabled) 10028 { 10029 /* support for removal media */ 10030 /* immed bit , SAT rev 8, 9.11.2.1 p 54*/ 10031 if ( (scsiCmnd->cdb[1] & SCSI_IMMED_MASK) ) 10032 { 10033 ostiInitiatorIOCompleted( tiRoot, 10034 tiIORequest, 10035 tiIOSuccess, 10036 SCSI_STAT_GOOD, 10037 agNULL, 10038 satIOContext->interruptContext ); 10039 10040 TI_DBG5(("satStartStopUnit: return table48 case 3 1\n")); 10041 return tiSuccess; 10042 } 10043 /* 10044 sends MEDIA EJECT 10045 */ 10046 /* Media Eject fis */ 10047 fis->h.fisType = 0x27; /* Reg host to device */ 10048 fis->h.c_pmPort = 0x80; /* C Bit is set */ 10049 10050 fis->h.command = SAT_MEDIA_EJECT; /* 0xED */ 10051 fis->h.features = 0; /* FIS features NA */ 10052 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 10053 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 10054 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 10055 fis->d.lbaLowExp = 0; 10056 fis->d.lbaMidExp = 0; 10057 fis->d.lbaHighExp = 0; 10058 fis->d.featuresExp = 0; 10059 /* sector count zero */ 10060 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 10061 fis->d.sectorCountExp = 0; 10062 fis->d.device = 0; /* FIS DEV is discared in SATA */ 10063 fis->d.control = 0; /* FIS HOB bit clear */ 10064 fis->d.reserved4 = 0; 10065 fis->d.reserved5 = 0; 10066 10067 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 10068 10069 /* Initialize CB for SATA completion. 10070 */ 10071 satIOContext->satCompleteCB = &satStartStopUnitCB; 10072 10073 /* 10074 * Prepare SGL and send FIS to LL layer. 10075 */ 10076 satIOContext->reqType = agRequestType; /* Save it */ 10077 10078 status = sataLLIOStart( tiRoot, 10079 tiIORequest, 10080 tiDeviceHandle, 10081 tiScsiRequest, 10082 satIOContext); 10083 10084 return status; 10085 } 10086 else 10087 { 10088 /* no support for removal media */ 10089 satSetSensePayload( pSense, 10090 SCSI_SNSKEY_ILLEGAL_REQUEST, 10091 0, 10092 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10093 satIOContext); 10094 10095 ostiInitiatorIOCompleted( tiRoot, 10096 tiIORequest, 10097 tiIOSuccess, 10098 SCSI_STAT_CHECK_CONDITION, 10099 satIOContext->pTiSenseData, 10100 satIOContext->interruptContext ); 10101 10102 TI_DBG5(("satStartStopUnit: return Table 29 case 3 2\n")); 10103 return tiSuccess; 10104 } 10105 10106 } 10107 /* case 4 */ 10108 else /* ( (scsiCmnd->cdb[4] & SCSI_START_MASK) && (scsiCmnd->cdb[4] & SCSI_LOEJ_MASK) ) */ 10109 { 10110 satSetSensePayload( pSense, 10111 SCSI_SNSKEY_ILLEGAL_REQUEST, 10112 0, 10113 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10114 satIOContext); 10115 10116 ostiInitiatorIOCompleted( tiRoot, 10117 tiIORequest, 10118 tiIOSuccess, 10119 SCSI_STAT_CHECK_CONDITION, 10120 satIOContext->pTiSenseData, 10121 satIOContext->interruptContext ); 10122 10123 TI_DBG5(("satStartStopUnit: return Table 29 case 4\n")); 10124 return tiSuccess; 10125 } 10126 10127 10128 } 10129 10130 10131 /*****************************************************************************/ 10132 /*! \brief SAT implementation for SCSI satStartStopUnit_1. 10133 * 10134 * SAT implementation for SCSI satStartStopUnit_1. 10135 * Sub function of satStartStopUnit 10136 * 10137 * \param tiRoot: Pointer to TISA initiator driver/port instance. 10138 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 10139 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 10140 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 10141 * \param satIOContext_t: Pointer to the SAT IO Context 10142 * 10143 * \return If command is started successfully 10144 * - \e tiSuccess: I/O request successfully initiated. 10145 * - \e tiBusy: No resources available, try again later. 10146 * - \e tiIONoDevice: Invalid device handle. 10147 * - \e tiError: Other errors. 10148 */ 10149 /*****************************************************************************/ 10150 GLOBAL bit32 satStartStopUnit_1( 10151 tiRoot_t *tiRoot, 10152 tiIORequest_t *tiIORequest, 10153 tiDeviceHandle_t *tiDeviceHandle, 10154 tiScsiInitiatorRequest_t *tiScsiRequest, 10155 satIOContext_t *satIOContext) 10156 { 10157 /* 10158 SAT Rev 8, Table 48, 9.11.3 p55 10159 sends STANDBY 10160 */ 10161 bit32 status; 10162 bit32 agRequestType; 10163 agsaFisRegHostToDevice_t *fis; 10164 10165 TI_DBG5(("satStartStopUnit_1 entry: tiDeviceHandle=%p tiIORequest=%p\n", 10166 tiDeviceHandle, tiIORequest)); 10167 10168 fis = satIOContext->pFis; 10169 10170 /* STANDBY */ 10171 fis->h.fisType = 0x27; /* Reg host to device */ 10172 fis->h.c_pmPort = 0x80; /* C Bit is set */ 10173 10174 fis->h.command = SAT_STANDBY; /* 0xE2 */ 10175 fis->h.features = 0; /* FIS features NA */ 10176 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 10177 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 10178 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 10179 fis->d.lbaLowExp = 0; 10180 fis->d.lbaMidExp = 0; 10181 fis->d.lbaHighExp = 0; 10182 fis->d.featuresExp = 0; 10183 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 10184 fis->d.sectorCountExp = 0; 10185 fis->d.reserved4 = 0; 10186 fis->d.device = 0; /* 0 */ 10187 fis->d.control = 0; /* FIS HOB bit clear */ 10188 fis->d.reserved5 = 0; 10189 10190 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 10191 10192 /* Initialize CB for SATA completion. 10193 */ 10194 satIOContext->satCompleteCB = &satStartStopUnitCB; 10195 10196 /* 10197 * Prepare SGL and send FIS to LL layer. 10198 */ 10199 satIOContext->reqType = agRequestType; /* Save it */ 10200 10201 status = sataLLIOStart( tiRoot, 10202 tiIORequest, 10203 tiDeviceHandle, 10204 tiScsiRequest, 10205 satIOContext); 10206 10207 TI_DBG5(("satStartStopUnit_1 return status %d\n", status)); 10208 return status; 10209 } 10210 10211 /*****************************************************************************/ 10212 /*! \brief SAT implementation for SCSI satRead10_2. 10213 * 10214 * SAT implementation for SCSI satRead10_2 10215 * Sub function of satRead10 10216 * 10217 * \param tiRoot: Pointer to TISA initiator driver/port instance. 10218 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 10219 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 10220 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 10221 * \param satIOContext_t: Pointer to the SAT IO Context 10222 * 10223 * \return If command is started successfully 10224 * - \e tiSuccess: I/O request successfully initiated. 10225 * - \e tiBusy: No resources available, try again later. 10226 * - \e tiIONoDevice: Invalid device handle. 10227 * - \e tiError: Other errors. 10228 */ 10229 /*****************************************************************************/ 10230 GLOBAL bit32 satRead10_2( 10231 tiRoot_t *tiRoot, 10232 tiIORequest_t *tiIORequest, 10233 tiDeviceHandle_t *tiDeviceHandle, 10234 tiScsiInitiatorRequest_t *tiScsiRequest, 10235 satIOContext_t *satIOContext) 10236 { 10237 /* 10238 externally generated ATA cmd, there is corresponding scsi cmnd 10239 called by satStartStopUnit() or maybe satRead10() 10240 */ 10241 10242 bit32 status; 10243 bit32 agRequestType; 10244 satDeviceData_t *pSatDevData; 10245 agsaFisRegHostToDevice_t *fis; 10246 10247 pSatDevData = satIOContext->pSatDevData; 10248 fis = satIOContext->pFis; 10249 10250 TI_DBG5(("satReadVerifySectorsNoChain: start\n")); 10251 10252 /* specifying ReadVerifySectors has no chain */ 10253 pSatDevData->satVerifyState = 0xFFFFFFFF; 10254 10255 if (pSatDevData->sat48BitSupport == agTRUE) 10256 { 10257 /* READ VERIFY SECTOR(S) EXT*/ 10258 fis->h.fisType = 0x27; /* Reg host to device */ 10259 fis->h.c_pmPort = 0x80; /* C Bit is set */ 10260 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 10261 fis->h.features = 0; /* FIS reserve */ 10262 fis->d.lbaLow = 0x7F; /* FIS LBA (7 :0 ) */ 10263 fis->d.lbaMid = 0x4F; /* FIS LBA (15:8 ) */ 10264 fis->d.lbaHigh = 0x00; /* FIS LBA (23:16) */ 10265 fis->d.lbaLowExp = 0xF1; /* FIS LBA (31:24) */ 10266 fis->d.lbaMidExp = 0x5F; /* FIS LBA (39:32) */ 10267 fis->d.lbaHighExp = 0xFF; /* FIS LBA (47:40) */ 10268 fis->d.featuresExp = 0; /* FIS reserve */ 10269 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 10270 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 10271 fis->d.reserved4 = 0; 10272 fis->d.device = 0x4E; /* 01001110 */ 10273 fis->d.control = 0; /* FIS HOB bit clear */ 10274 fis->d.reserved5 = 0; 10275 10276 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 10277 } 10278 else 10279 { 10280 /* READ VERIFY SECTOR(S)*/ 10281 fis->h.fisType = 0x27; /* Reg host to device */ 10282 fis->h.c_pmPort = 0x80; /* C Bit is set */ 10283 fis->h.command = SAT_READ_VERIFY_SECTORS;/* 0x40 */ 10284 fis->h.features = 0; /* FIS features NA */ 10285 fis->d.lbaLow = 0x7F; /* FIS LBA (7 :0 ) */ 10286 fis->d.lbaMid = 0x4F; /* FIS LBA (15:8 ) */ 10287 fis->d.lbaHigh = 0x00; /* FIS LBA (23:16) */ 10288 fis->d.lbaLowExp = 0; 10289 fis->d.lbaMidExp = 0; 10290 fis->d.lbaHighExp = 0; 10291 fis->d.featuresExp = 0; 10292 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 10293 fis->d.sectorCountExp = 0; 10294 fis->d.reserved4 = 0; 10295 fis->d.device = 0x4E; /* 01001110 */ 10296 fis->d.control = 0; /* FIS HOB bit clear */ 10297 fis->d.reserved5 = 0; 10298 10299 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 10300 } 10301 10302 /* Initialize CB for SATA completion. 10303 */ 10304 satIOContext->satCompleteCB = &satNonDataIOCB; 10305 10306 /* 10307 * Prepare SGL and send FIS to LL layer. 10308 */ 10309 satIOContext->reqType = agRequestType; /* Save it */ 10310 10311 status = sataLLIOStart( tiRoot, 10312 tiIORequest, 10313 tiDeviceHandle, 10314 tiScsiRequest, 10315 satIOContext); 10316 10317 TI_DBG5(("satReadVerifySectorsNoChain: return last\n")); 10318 10319 return status; 10320 } 10321 10322 10323 /*****************************************************************************/ 10324 /*! \brief SAT implementation for SCSI satWriteSame10. 10325 * 10326 * SAT implementation for SCSI satWriteSame10. 10327 * 10328 * \param tiRoot: Pointer to TISA initiator driver/port instance. 10329 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 10330 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 10331 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 10332 * \param satIOContext_t: Pointer to the SAT IO Context 10333 * 10334 * \return If command is started successfully 10335 * - \e tiSuccess: I/O request successfully initiated. 10336 * - \e tiBusy: No resources available, try again later. 10337 * - \e tiIONoDevice: Invalid device handle. 10338 * - \e tiError: Other errors. 10339 */ 10340 /*****************************************************************************/ 10341 GLOBAL bit32 satWriteSame10( 10342 tiRoot_t *tiRoot, 10343 tiIORequest_t *tiIORequest, 10344 tiDeviceHandle_t *tiDeviceHandle, 10345 tiScsiInitiatorRequest_t *tiScsiRequest, 10346 satIOContext_t *satIOContext) 10347 { 10348 bit32 status; 10349 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 10350 satDeviceData_t *pSatDevData; 10351 scsiRspSense_t *pSense; 10352 tiIniScsiCmnd_t *scsiCmnd; 10353 agsaFisRegHostToDevice_t *fis; 10354 bit32 lba = 0; 10355 bit32 tl = 0; 10356 10357 pSense = satIOContext->pSense; 10358 pSatDevData = satIOContext->pSatDevData; 10359 scsiCmnd = &tiScsiRequest->scsiCmnd; 10360 fis = satIOContext->pFis; 10361 10362 TI_DBG5(("satWriteSame10: start\n")); 10363 10364 /* checking CONTROL */ 10365 /* NACA == 1 or LINK == 1*/ 10366 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 10367 { 10368 satSetSensePayload( pSense, 10369 SCSI_SNSKEY_ILLEGAL_REQUEST, 10370 0, 10371 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10372 satIOContext); 10373 10374 ostiInitiatorIOCompleted( tiRoot, 10375 tiIORequest, 10376 tiIOSuccess, 10377 SCSI_STAT_CHECK_CONDITION, 10378 satIOContext->pTiSenseData, 10379 satIOContext->interruptContext ); 10380 10381 TI_DBG1(("satWriteSame10: return control\n")); 10382 return tiSuccess; 10383 } 10384 10385 10386 /* checking LBDATA and PBDATA */ 10387 /* case 1 */ 10388 if ( !(scsiCmnd->cdb[1] & SCSI_WRITE_SAME_LBDATA_MASK) && 10389 !(scsiCmnd->cdb[1] & SCSI_WRITE_SAME_PBDATA_MASK)) 10390 { 10391 TI_DBG5(("satWriteSame10: case 1\n")); 10392 /* spec 9.26.2, Table 62, p64, case 1*/ 10393 /* 10394 normal case 10395 just like write in 9.17.1 10396 */ 10397 10398 if ( pSatDevData->sat48BitSupport != agTRUE ) 10399 { 10400 /* 10401 writeSame10 but no support for 48 bit addressing 10402 -> problem in transfer length. Therefore, return check condition 10403 */ 10404 satSetSensePayload( pSense, 10405 SCSI_SNSKEY_ILLEGAL_REQUEST, 10406 0, 10407 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10408 satIOContext); 10409 10410 ostiInitiatorIOCompleted( tiRoot, 10411 tiIORequest, 10412 tiIOSuccess, 10413 SCSI_STAT_CHECK_CONDITION, 10414 satIOContext->pTiSenseData, 10415 satIOContext->interruptContext ); 10416 10417 TI_DBG1(("satWriteSame10: return internal checking\n")); 10418 return tiSuccess; 10419 } 10420 10421 /* cdb10; computing LBA and transfer length */ 10422 lba = (scsiCmnd->cdb[2] << (8*3)) + (scsiCmnd->cdb[3] << (8*2)) 10423 + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 10424 tl = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 10425 10426 10427 /* Table 34, 9.1, p 46 */ 10428 /* 10429 note: As of 2/10/2006, no support for DMA QUEUED 10430 */ 10431 10432 /* 10433 Table 34, 9.1, p 46, b (footnote) 10434 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 10435 return check condition 10436 */ 10437 if (pSatDevData->satNCQ != agTRUE && 10438 pSatDevData->sat48BitSupport != agTRUE 10439 ) 10440 { 10441 if (lba > SAT_TR_LBA_LIMIT - 1) /* SAT_TR_LBA_LIMIT is 2^28, 0x10000000 */ 10442 { 10443 satSetSensePayload( pSense, 10444 SCSI_SNSKEY_ILLEGAL_REQUEST, 10445 0, 10446 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 10447 satIOContext); 10448 10449 ostiInitiatorIOCompleted( tiRoot, 10450 tiIORequest, 10451 tiIOSuccess, 10452 SCSI_STAT_CHECK_CONDITION, 10453 satIOContext->pTiSenseData, 10454 satIOContext->interruptContext ); 10455 10456 TI_DBG1(("satWriteSame10: return LBA out of range\n")); 10457 return tiSuccess; 10458 } 10459 } 10460 10461 if (lba + tl <= SAT_TR_LBA_LIMIT) 10462 { 10463 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 10464 { 10465 /* case 2 */ 10466 /* WRITE DMA */ 10467 /* can't fit the transfer length since WRITE DMA has 1 byte for sector count */ 10468 TI_DBG5(("satWriteSame10: case 1-2 !!! error due to writeSame10\n")); 10469 satSetSensePayload( pSense, 10470 SCSI_SNSKEY_ILLEGAL_REQUEST, 10471 0, 10472 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10473 satIOContext); 10474 10475 ostiInitiatorIOCompleted( tiRoot, 10476 tiIORequest, 10477 tiIOSuccess, 10478 SCSI_STAT_CHECK_CONDITION, 10479 satIOContext->pTiSenseData, 10480 satIOContext->interruptContext ); 10481 return tiSuccess; 10482 } 10483 else 10484 { 10485 /* case 1 */ 10486 /* WRITE MULTIPLE or WRITE SECTOR(S) */ 10487 /* WRITE SECTORS is chosen for easier implemetation */ 10488 /* can't fit the transfer length since WRITE DMA has 1 byte for sector count */ 10489 TI_DBG5(("satWriteSame10: case 1-1 !!! error due to writesame10\n")); 10490 satSetSensePayload( pSense, 10491 SCSI_SNSKEY_ILLEGAL_REQUEST, 10492 0, 10493 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10494 satIOContext); 10495 10496 ostiInitiatorIOCompleted( tiRoot, 10497 tiIORequest, 10498 tiIOSuccess, 10499 SCSI_STAT_CHECK_CONDITION, 10500 satIOContext->pTiSenseData, 10501 satIOContext->interruptContext ); 10502 return tiSuccess; 10503 } 10504 } /* end of case 1 and 2 */ 10505 10506 /* case 3 and 4 */ 10507 if (pSatDevData->sat48BitSupport == agTRUE) 10508 { 10509 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 10510 { 10511 /* case 3 */ 10512 /* WRITE DMA EXT or WRITE DMA FUA EXT */ 10513 /* WRITE DMA EXT is chosen since WRITE SAME does not have FUA bit */ 10514 TI_DBG5(("satWriteSame10: case 1-3\n")); 10515 fis->h.fisType = 0x27; /* Reg host to device */ 10516 fis->h.c_pmPort = 0x80; /* C Bit is set */ 10517 10518 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 10519 10520 fis->h.features = 0; /* FIS reserve */ 10521 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 10522 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 10523 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 10524 fis->d.device = 0x40; /* FIS LBA mode set */ 10525 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 10526 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 10527 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 10528 fis->d.featuresExp = 0; /* FIS reserve */ 10529 if (tl == 0) 10530 { 10531 /* error check 10532 ATA spec, p125, 6.17.29 10533 pSatDevData->satMaxUserAddrSectors should be 0x0FFFFFFF 10534 and allowed value is 0x0FFFFFFF - 1 10535 */ 10536 if (pSatDevData->satMaxUserAddrSectors > 0x0FFFFFFF) 10537 { 10538 TI_DBG5(("satWriteSame10: case 3 !!! warning can't fit sectors\n")); 10539 satSetSensePayload( pSense, 10540 SCSI_SNSKEY_ILLEGAL_REQUEST, 10541 0, 10542 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10543 satIOContext); 10544 10545 ostiInitiatorIOCompleted( tiRoot, 10546 tiIORequest, 10547 tiIOSuccess, 10548 SCSI_STAT_CHECK_CONDITION, 10549 satIOContext->pTiSenseData, 10550 satIOContext->interruptContext ); 10551 return tiSuccess; 10552 } 10553 } 10554 /* one sector at a time */ 10555 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 10556 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 10557 fis->d.reserved4 = 0; 10558 fis->d.control = 0; /* FIS HOB bit clear */ 10559 fis->d.reserved5 = 0; 10560 10561 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 10562 } 10563 else 10564 { 10565 /* case 4 */ 10566 /* WRITE MULTIPLE EXT or WRITE MULTIPLE FUA EXT or WRITE SECTOR(S) EXT */ 10567 /* WRITE SECTORS EXT is chosen for easier implemetation */ 10568 TI_DBG5(("satWriteSame10: case 1-4\n")); 10569 fis->h.fisType = 0x27; /* Reg host to device */ 10570 fis->h.c_pmPort = 0x80; /* C Bit is set */ 10571 10572 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 10573 fis->h.features = 0; /* FIS reserve */ 10574 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 10575 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 10576 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 10577 fis->d.device = 0x40; /* FIS LBA mode set */ 10578 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 10579 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 10580 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 10581 fis->d.featuresExp = 0; /* FIS reserve */ 10582 if (tl == 0) 10583 { 10584 /* error check 10585 ATA spec, p125, 6.17.29 10586 pSatDevData->satMaxUserAddrSectors should be 0x0FFFFFFF 10587 and allowed value is 0x0FFFFFFF - 1 10588 */ 10589 if (pSatDevData->satMaxUserAddrSectors > 0x0FFFFFFF) 10590 { 10591 TI_DBG5(("satWriteSame10: case 4 !!! warning can't fit sectors\n")); 10592 satSetSensePayload( pSense, 10593 SCSI_SNSKEY_ILLEGAL_REQUEST, 10594 0, 10595 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10596 satIOContext); 10597 10598 ostiInitiatorIOCompleted( tiRoot, 10599 tiIORequest, 10600 tiIOSuccess, 10601 SCSI_STAT_CHECK_CONDITION, 10602 satIOContext->pTiSenseData, 10603 satIOContext->interruptContext ); 10604 return tiSuccess; 10605 } 10606 } 10607 /* one sector at a time */ 10608 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 10609 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 10610 fis->d.reserved4 = 0; 10611 fis->d.control = 0; /* FIS HOB bit clear */ 10612 fis->d.reserved5 = 0; 10613 10614 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 10615 } 10616 } 10617 10618 /* case 5 */ 10619 if (pSatDevData->satNCQ == agTRUE) 10620 { 10621 /* WRITE FPDMA QUEUED */ 10622 if (pSatDevData->sat48BitSupport != agTRUE) 10623 { 10624 TI_DBG5(("satWriteSame10: case 1-5 !!! error NCQ but 28 bit address support \n")); 10625 satSetSensePayload( pSense, 10626 SCSI_SNSKEY_ILLEGAL_REQUEST, 10627 0, 10628 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10629 satIOContext); 10630 10631 ostiInitiatorIOCompleted( tiRoot, 10632 tiIORequest, 10633 tiIOSuccess, 10634 SCSI_STAT_CHECK_CONDITION, 10635 satIOContext->pTiSenseData, 10636 satIOContext->interruptContext ); 10637 return tiSuccess; 10638 } 10639 TI_DBG5(("satWriteSame10: case 1-5\n")); 10640 10641 /* Support 48-bit FPDMA addressing, use WRITE FPDMA QUEUE command */ 10642 10643 fis->h.fisType = 0x27; /* Reg host to device */ 10644 fis->h.c_pmPort = 0x80; /* C Bit is set */ 10645 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 10646 10647 if (tl == 0) 10648 { 10649 /* error check 10650 ATA spec, p125, 6.17.29 10651 pSatDevData->satMaxUserAddrSectors should be 0x0FFFFFFF 10652 and allowed value is 0x0FFFFFFF - 1 10653 */ 10654 if (pSatDevData->satMaxUserAddrSectors > 0x0FFFFFFF) 10655 { 10656 TI_DBG5(("satWriteSame10: case 4 !!! warning can't fit sectors\n")); 10657 satSetSensePayload( pSense, 10658 SCSI_SNSKEY_ILLEGAL_REQUEST, 10659 0, 10660 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10661 satIOContext); 10662 10663 ostiInitiatorIOCompleted( tiRoot, 10664 tiIORequest, 10665 tiIOSuccess, 10666 SCSI_STAT_CHECK_CONDITION, 10667 satIOContext->pTiSenseData, 10668 satIOContext->interruptContext ); 10669 return tiSuccess; 10670 } 10671 } 10672 /* one sector at a time */ 10673 fis->h.features = 1; /* FIS sector count (7:0) */ 10674 fis->d.featuresExp = 0; /* FIS sector count (15:8) */ 10675 10676 10677 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 10678 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 10679 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 10680 10681 /* NO FUA bit in the WRITE SAME 10 */ 10682 fis->d.device = 0x40; /* FIS FUA clear */ 10683 10684 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 10685 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 10686 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 10687 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 10688 fis->d.sectorCountExp = 0; 10689 fis->d.reserved4 = 0; 10690 fis->d.control = 0; /* FIS HOB bit clear */ 10691 fis->d.reserved5 = 0; 10692 10693 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 10694 } 10695 /* Initialize CB for SATA completion. 10696 */ 10697 satIOContext->satCompleteCB = &satWriteSame10CB; 10698 10699 /* 10700 * Prepare SGL and send FIS to LL layer. 10701 */ 10702 satIOContext->reqType = agRequestType; /* Save it */ 10703 10704 status = sataLLIOStart( tiRoot, 10705 tiIORequest, 10706 tiDeviceHandle, 10707 tiScsiRequest, 10708 satIOContext); 10709 return (status); 10710 10711 10712 } /* end of case 1 */ 10713 else if ( !(scsiCmnd->cdb[1] & SCSI_WRITE_SAME_LBDATA_MASK) && 10714 (scsiCmnd->cdb[1] & SCSI_WRITE_SAME_PBDATA_MASK)) 10715 { 10716 /* spec 9.26.2, Table 62, p64, case 2*/ 10717 satSetSensePayload( pSense, 10718 SCSI_SNSKEY_ILLEGAL_REQUEST, 10719 0, 10720 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10721 satIOContext); 10722 10723 ostiInitiatorIOCompleted( tiRoot, 10724 tiIORequest, 10725 tiIOSuccess, 10726 SCSI_STAT_CHECK_CONDITION, 10727 satIOContext->pTiSenseData, 10728 satIOContext->interruptContext ); 10729 10730 TI_DBG5(("satWriteSame10: return Table 62 case 2\n")); 10731 return tiSuccess; 10732 } 10733 else if ( (scsiCmnd->cdb[1] & SCSI_WRITE_SAME_LBDATA_MASK) && 10734 !(scsiCmnd->cdb[1] & SCSI_WRITE_SAME_PBDATA_MASK)) 10735 { 10736 TI_DBG5(("satWriteSame10: Table 62 case 3\n")); 10737 10738 } 10739 else /* ( (scsiCmnd->cdb[1] & SCSI_WRITE_SAME_LBDATA_MASK) && 10740 (scsiCmnd->cdb[1] & SCSI_WRITE_SAME_PBDATA_MASK)) */ 10741 { 10742 10743 /* spec 9.26.2, Table 62, p64, case 4*/ 10744 satSetSensePayload( pSense, 10745 SCSI_SNSKEY_ILLEGAL_REQUEST, 10746 0, 10747 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 10748 satIOContext); 10749 10750 ostiInitiatorIOCompleted( tiRoot, 10751 tiIORequest, 10752 tiIOSuccess, 10753 SCSI_STAT_CHECK_CONDITION, 10754 satIOContext->pTiSenseData, 10755 satIOContext->interruptContext ); 10756 10757 TI_DBG5(("satWriteSame10: return Table 62 case 4\n")); 10758 return tiSuccess; 10759 } 10760 10761 10762 return tiSuccess; 10763 } 10764 10765 /*****************************************************************************/ 10766 /*! \brief SAT implementation for SCSI satWriteSame10_1. 10767 * 10768 * SAT implementation for SCSI WRITESANE10 and send FIS request to LL layer. 10769 * This is used when WRITESAME10 is divided into multiple ATA commands 10770 * 10771 * \param tiRoot: Pointer to TISA initiator driver/port instance. 10772 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 10773 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 10774 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 10775 * \param satIOContext_t: Pointer to the SAT IO Context 10776 * \param lba: LBA 10777 * 10778 * \return If command is started successfully 10779 * - \e tiSuccess: I/O request successfully initiated. 10780 * - \e tiBusy: No resources available, try again later. 10781 * - \e tiIONoDevice: Invalid device handle. 10782 * - \e tiError: Other errors. 10783 */ 10784 /*****************************************************************************/ 10785 GLOBAL bit32 satWriteSame10_1( 10786 tiRoot_t *tiRoot, 10787 tiIORequest_t *tiIORequest, 10788 tiDeviceHandle_t *tiDeviceHandle, 10789 tiScsiInitiatorRequest_t *tiScsiRequest, 10790 satIOContext_t *satIOContext, 10791 bit32 lba 10792 ) 10793 { 10794 /* 10795 sends SAT_WRITE_DMA_EXT 10796 */ 10797 10798 bit32 status; 10799 bit32 agRequestType; 10800 agsaFisRegHostToDevice_t *fis; 10801 bit8 lba1, lba2 ,lba3, lba4; 10802 10803 TI_DBG5(("satWriteSame10_1 entry: tiDeviceHandle=%p tiIORequest=%p\n", 10804 tiDeviceHandle, tiIORequest)); 10805 10806 fis = satIOContext->pFis; 10807 10808 /* MSB */ 10809 lba1 = (bit8)((lba & 0xFF000000) >> (8*3)); 10810 lba2 = (bit8)((lba & 0x00FF0000) >> (8*2)); 10811 lba3 = (bit8)((lba & 0x0000FF00) >> (8*1)); 10812 /* LSB */ 10813 lba4 = (bit8)(lba & 0x000000FF); 10814 10815 /* SAT_WRITE_DMA_EXT */ 10816 fis->h.fisType = 0x27; /* Reg host to device */ 10817 fis->h.c_pmPort = 0x80; /* C Bit is set */ 10818 10819 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 10820 10821 fis->h.features = 0; /* FIS reserve */ 10822 fis->d.lbaLow = lba4; /* FIS LBA (7 :0 ) */ 10823 fis->d.lbaMid = lba3; /* FIS LBA (15:8 ) */ 10824 fis->d.lbaHigh = lba2; /* FIS LBA (23:16) */ 10825 fis->d.device = 0x40; /* FIS LBA mode set */ 10826 fis->d.lbaLowExp = lba1; /* FIS LBA (31:24) */ 10827 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 10828 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 10829 fis->d.featuresExp = 0; /* FIS reserve */ 10830 /* one sector at a time */ 10831 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 10832 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 10833 10834 fis->d.reserved4 = 0; 10835 fis->d.control = 0; /* FIS HOB bit clear */ 10836 fis->d.reserved5 = 0; 10837 10838 10839 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 10840 10841 /* Initialize CB for SATA completion. 10842 */ 10843 satIOContext->satCompleteCB = &satWriteSame10CB; 10844 10845 /* 10846 * Prepare SGL and send FIS to LL layer. 10847 */ 10848 satIOContext->reqType = agRequestType; /* Save it */ 10849 10850 status = sataLLIOStart( tiRoot, 10851 tiIORequest, 10852 tiDeviceHandle, 10853 tiScsiRequest, 10854 satIOContext); 10855 10856 TI_DBG5(("satWriteSame10_1 return status %d\n", status)); 10857 return status; 10858 } 10859 10860 /*****************************************************************************/ 10861 /*! \brief SAT implementation for SCSI satWriteSame10_2. 10862 * 10863 * SAT implementation for SCSI WRITESANE10 and send FIS request to LL layer. 10864 * This is used when WRITESAME10 is divided into multiple ATA commands 10865 * 10866 * \param tiRoot: Pointer to TISA initiator driver/port instance. 10867 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 10868 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 10869 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 10870 * \param satIOContext_t: Pointer to the SAT IO Context 10871 * \param lba: LBA 10872 * 10873 * \return If command is started successfully 10874 * - \e tiSuccess: I/O request successfully initiated. 10875 * - \e tiBusy: No resources available, try again later. 10876 * - \e tiIONoDevice: Invalid device handle. 10877 * - \e tiError: Other errors. 10878 */ 10879 /*****************************************************************************/ 10880 GLOBAL bit32 satWriteSame10_2( 10881 tiRoot_t *tiRoot, 10882 tiIORequest_t *tiIORequest, 10883 tiDeviceHandle_t *tiDeviceHandle, 10884 tiScsiInitiatorRequest_t *tiScsiRequest, 10885 satIOContext_t *satIOContext, 10886 bit32 lba 10887 ) 10888 { 10889 /* 10890 sends SAT_WRITE_SECTORS_EXT 10891 */ 10892 10893 bit32 status; 10894 bit32 agRequestType; 10895 agsaFisRegHostToDevice_t *fis; 10896 bit8 lba1, lba2 ,lba3, lba4; 10897 10898 TI_DBG5(("satWriteSame10_2 entry: tiDeviceHandle=%p tiIORequest=%p\n", 10899 tiDeviceHandle, tiIORequest)); 10900 10901 fis = satIOContext->pFis; 10902 10903 /* MSB */ 10904 lba1 = (bit8)((lba & 0xFF000000) >> (8*3)); 10905 lba2 = (bit8)((lba & 0x00FF0000) >> (8*2)); 10906 lba3 = (bit8)((lba & 0x0000FF00) >> (8*1)); 10907 /* LSB */ 10908 lba4 = (bit8)(lba & 0x000000FF); 10909 10910 10911 /* SAT_WRITE_SECTORS_EXT */ 10912 fis->h.fisType = 0x27; /* Reg host to device */ 10913 fis->h.c_pmPort = 0x80; /* C Bit is set */ 10914 10915 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 10916 fis->h.features = 0; /* FIS reserve */ 10917 fis->d.lbaLow = lba4; /* FIS LBA (7 :0 ) */ 10918 fis->d.lbaMid = lba3; /* FIS LBA (15:8 ) */ 10919 fis->d.lbaHigh = lba2; /* FIS LBA (23:16) */ 10920 fis->d.device = 0x40; /* FIS LBA mode set */ 10921 fis->d.lbaLowExp = lba1; /* FIS LBA (31:24) */ 10922 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 10923 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 10924 fis->d.featuresExp = 0; /* FIS reserve */ 10925 /* one sector at a time */ 10926 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 10927 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 10928 10929 fis->d.reserved4 = 0; 10930 fis->d.control = 0; /* FIS HOB bit clear */ 10931 fis->d.reserved5 = 0; 10932 10933 10934 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 10935 10936 /* Initialize CB for SATA completion. 10937 */ 10938 satIOContext->satCompleteCB = &satWriteSame10CB; 10939 10940 /* 10941 * Prepare SGL and send FIS to LL layer. 10942 */ 10943 satIOContext->reqType = agRequestType; /* Save it */ 10944 10945 status = sataLLIOStart( tiRoot, 10946 tiIORequest, 10947 tiDeviceHandle, 10948 tiScsiRequest, 10949 satIOContext); 10950 10951 TI_DBG5(("satWriteSame10_2 return status %d\n", status)); 10952 return status; 10953 } 10954 10955 /*****************************************************************************/ 10956 /*! \brief SAT implementation for SCSI satWriteSame10_3. 10957 * 10958 * SAT implementation for SCSI WRITESANE10 and send FIS request to LL layer. 10959 * This is used when WRITESAME10 is divided into multiple ATA commands 10960 * 10961 * \param tiRoot: Pointer to TISA initiator driver/port instance. 10962 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 10963 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 10964 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 10965 * \param satIOContext_t: Pointer to the SAT IO Context 10966 * \param lba: LBA 10967 * 10968 * \return If command is started successfully 10969 * - \e tiSuccess: I/O request successfully initiated. 10970 * - \e tiBusy: No resources available, try again later. 10971 * - \e tiIONoDevice: Invalid device handle. 10972 * - \e tiError: Other errors. 10973 */ 10974 /*****************************************************************************/ 10975 GLOBAL bit32 satWriteSame10_3( 10976 tiRoot_t *tiRoot, 10977 tiIORequest_t *tiIORequest, 10978 tiDeviceHandle_t *tiDeviceHandle, 10979 tiScsiInitiatorRequest_t *tiScsiRequest, 10980 satIOContext_t *satIOContext, 10981 bit32 lba 10982 ) 10983 { 10984 /* 10985 sends SAT_WRITE_FPDMA_QUEUED 10986 */ 10987 10988 bit32 status; 10989 bit32 agRequestType; 10990 agsaFisRegHostToDevice_t *fis; 10991 bit8 lba1, lba2 ,lba3, lba4; 10992 10993 TI_DBG5(("satWriteSame10_3 entry: tiDeviceHandle=%p tiIORequest=%p\n", 10994 tiDeviceHandle, tiIORequest)); 10995 10996 fis = satIOContext->pFis; 10997 10998 /* MSB */ 10999 lba1 = (bit8)((lba & 0xFF000000) >> (8*3)); 11000 lba2 = (bit8)((lba & 0x00FF0000) >> (8*2)); 11001 lba3 = (bit8)((lba & 0x0000FF00) >> (8*1)); 11002 /* LSB */ 11003 lba4 = (bit8)(lba & 0x000000FF); 11004 11005 /* SAT_WRITE_FPDMA_QUEUED */ 11006 fis->h.fisType = 0x27; /* Reg host to device */ 11007 fis->h.c_pmPort = 0x80; /* C Bit is set */ 11008 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 11009 11010 11011 /* one sector at a time */ 11012 fis->h.features = 1; /* FIS sector count (7:0) */ 11013 fis->d.featuresExp = 0; /* FIS sector count (15:8) */ 11014 11015 11016 fis->d.lbaLow = lba4; /* FIS LBA (7 :0 ) */ 11017 fis->d.lbaMid = lba3; /* FIS LBA (15:8 ) */ 11018 fis->d.lbaHigh = lba2; /* FIS LBA (23:16) */ 11019 11020 /* NO FUA bit in the WRITE SAME 10 */ 11021 fis->d.device = 0x40; /* FIS FUA clear */ 11022 11023 fis->d.lbaLowExp = lba1; /* FIS LBA (31:24) */ 11024 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 11025 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 11026 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 11027 fis->d.sectorCountExp = 0; 11028 fis->d.reserved4 = 0; 11029 fis->d.control = 0; /* FIS HOB bit clear */ 11030 fis->d.reserved5 = 0; 11031 11032 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 11033 11034 /* Initialize CB for SATA completion. 11035 */ 11036 satIOContext->satCompleteCB = &satWriteSame10CB; 11037 11038 /* 11039 * Prepare SGL and send FIS to LL layer. 11040 */ 11041 satIOContext->reqType = agRequestType; /* Save it */ 11042 11043 status = sataLLIOStart( tiRoot, 11044 tiIORequest, 11045 tiDeviceHandle, 11046 tiScsiRequest, 11047 satIOContext); 11048 11049 TI_DBG5(("satWriteSame10_2 return status %d\n", status)); 11050 return status; 11051 } 11052 /*****************************************************************************/ 11053 /*! \brief SAT implementation for SCSI satWriteSame16. 11054 * 11055 * SAT implementation for SCSI satWriteSame16. 11056 * 11057 * \param tiRoot: Pointer to TISA initiator driver/port instance. 11058 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 11059 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 11060 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 11061 * \param satIOContext_t: Pointer to the SAT IO Context 11062 * 11063 * \return If command is started successfully 11064 * - \e tiSuccess: I/O request successfully initiated. 11065 * - \e tiBusy: No resources available, try again later. 11066 * - \e tiIONoDevice: Invalid device handle. 11067 * - \e tiError: Other errors. 11068 */ 11069 /*****************************************************************************/ 11070 GLOBAL bit32 satWriteSame16( 11071 tiRoot_t *tiRoot, 11072 tiIORequest_t *tiIORequest, 11073 tiDeviceHandle_t *tiDeviceHandle, 11074 tiScsiInitiatorRequest_t *tiScsiRequest, 11075 satIOContext_t *satIOContext) 11076 { 11077 scsiRspSense_t *pSense; 11078 11079 pSense = satIOContext->pSense; 11080 11081 TI_DBG5(("satWriteSame16:start\n")); 11082 11083 11084 satSetSensePayload( pSense, 11085 SCSI_SNSKEY_NO_SENSE, 11086 0, 11087 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 11088 satIOContext); 11089 11090 ostiInitiatorIOCompleted( tiRoot, 11091 tiIORequest, /* == &satIntIo->satOrgTiIORequest */ 11092 tiIOSuccess, 11093 SCSI_STAT_CHECK_CONDITION, 11094 satIOContext->pTiSenseData, 11095 satIOContext->interruptContext ); 11096 TI_DBG5(("satWriteSame16: return internal checking\n")); 11097 return tiSuccess; 11098 } 11099 11100 /*****************************************************************************/ 11101 /*! \brief SAT implementation for SCSI satLogSense_1. 11102 * 11103 * Part of SAT implementation for SCSI satLogSense. 11104 * 11105 * \param tiRoot: Pointer to TISA initiator driver/port instance. 11106 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 11107 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 11108 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 11109 * \param satIOContext_t: Pointer to the SAT IO Context 11110 * 11111 * \return If command is started successfully 11112 * - \e tiSuccess: I/O request successfully initiated. 11113 * - \e tiBusy: No resources available, try again later. 11114 * - \e tiIONoDevice: Invalid device handle. 11115 * - \e tiError: Other errors. 11116 */ 11117 /*****************************************************************************/ 11118 GLOBAL bit32 satLogSense_1( 11119 tiRoot_t *tiRoot, 11120 tiIORequest_t *tiIORequest, 11121 tiDeviceHandle_t *tiDeviceHandle, 11122 tiScsiInitiatorRequest_t *tiScsiRequest, 11123 satIOContext_t *satIOContext) 11124 { 11125 bit32 status; 11126 bit32 agRequestType; 11127 satDeviceData_t *pSatDevData; 11128 agsaFisRegHostToDevice_t *fis; 11129 11130 pSatDevData = satIOContext->pSatDevData; 11131 fis = satIOContext->pFis; 11132 11133 TI_DBG5(("satLogSense_1: start\n")); 11134 11135 11136 /* SAT Rev 8, 10.2.4 p74 */ 11137 if ( pSatDevData->sat48BitSupport == agTRUE ) 11138 { 11139 TI_DBG5(("satLogSense_1: case 2-1 sends READ LOG EXT\n")); 11140 /* sends READ LOG EXT */ 11141 fis->h.fisType = 0x27; /* Reg host to device */ 11142 fis->h.c_pmPort = 0x80; /* C Bit is set */ 11143 11144 fis->h.command = SAT_READ_LOG_EXT; /* 0x2F */ 11145 fis->h.features = 0; /* FIS reserve */ 11146 fis->d.lbaLow = 0x07; /* 0x07 */ 11147 fis->d.lbaMid = 0; /* */ 11148 fis->d.lbaHigh = 0; /* */ 11149 fis->d.device = 0; /* */ 11150 fis->d.lbaLowExp = 0; /* */ 11151 fis->d.lbaMidExp = 0; /* */ 11152 fis->d.lbaHighExp = 0; /* */ 11153 fis->d.featuresExp = 0; /* FIS reserve */ 11154 fis->d.sectorCount = 0x01; /* 1 sector counts */ 11155 fis->d.sectorCountExp = 0x00; /* 1 sector counts */ 11156 fis->d.reserved4 = 0; 11157 fis->d.control = 0; /* FIS HOB bit clear */ 11158 fis->d.reserved5 = 0; 11159 11160 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 11161 11162 /* Initialize CB for SATA completion. 11163 */ 11164 satIOContext->satCompleteCB = &satLogSenseCB; 11165 11166 /* 11167 * Prepare SGL and send FIS to LL layer. 11168 */ 11169 satIOContext->reqType = agRequestType; /* Save it */ 11170 11171 status = sataLLIOStart( tiRoot, 11172 tiIORequest, 11173 tiDeviceHandle, 11174 tiScsiRequest, 11175 satIOContext); 11176 return status; 11177 11178 } 11179 else 11180 { 11181 TI_DBG5(("satLogSense_1: case 2-2 sends SMART READ LOG\n")); 11182 /* sends SMART READ LOG */ 11183 fis->h.fisType = 0x27; /* Reg host to device */ 11184 fis->h.c_pmPort = 0x80; /* C Bit is set */ 11185 11186 fis->h.command = SAT_SMART_READ_LOG; /* 0x2F */ 11187 fis->h.features = 0x00; /* 0xd5 */ 11188 fis->d.lbaLow = 0x06; /* 0x06 */ 11189 fis->d.lbaMid = 0x00; /* 0x4f */ 11190 fis->d.lbaHigh = 0x00; /* 0xc2 */ 11191 fis->d.device = 0; /* */ 11192 fis->d.lbaLowExp = 0; /* */ 11193 fis->d.lbaMidExp = 0; /* */ 11194 fis->d.lbaHighExp = 0; /* */ 11195 fis->d.featuresExp = 0; /* FIS reserve */ 11196 fis->d.sectorCount = 0x01; /* */ 11197 fis->d.sectorCountExp = 0x00; /* */ 11198 fis->d.reserved4 = 0; 11199 fis->d.control = 0; /* FIS HOB bit clear */ 11200 fis->d.reserved5 = 0; 11201 11202 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 11203 11204 /* Initialize CB for SATA completion. 11205 */ 11206 satIOContext->satCompleteCB = &satLogSenseCB; 11207 11208 /* 11209 * Prepare SGL and send FIS to LL layer. 11210 */ 11211 satIOContext->reqType = agRequestType; /* Save it */ 11212 11213 status = sataLLIOStart( tiRoot, 11214 tiIORequest, 11215 tiDeviceHandle, 11216 tiScsiRequest, 11217 satIOContext); 11218 return status; 11219 11220 } 11221 } 11222 11223 /*****************************************************************************/ 11224 /*! \brief SAT implementation for SCSI satSMARTEnable. 11225 * 11226 * Part of SAT implementation for SCSI satLogSense. 11227 * 11228 * \param tiRoot: Pointer to TISA initiator driver/port instance. 11229 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 11230 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 11231 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 11232 * \param satIOContext_t: Pointer to the SAT IO Context 11233 * 11234 * \return If command is started successfully 11235 * - \e tiSuccess: I/O request successfully initiated. 11236 * - \e tiBusy: No resources available, try again later. 11237 * - \e tiIONoDevice: Invalid device handle. 11238 * - \e tiError: Other errors. 11239 */ 11240 /*****************************************************************************/ 11241 GLOBAL bit32 satSMARTEnable( 11242 tiRoot_t *tiRoot, 11243 tiIORequest_t *tiIORequest, 11244 tiDeviceHandle_t *tiDeviceHandle, 11245 tiScsiInitiatorRequest_t *tiScsiRequest, 11246 satIOContext_t *satIOContext) 11247 { 11248 bit32 status; 11249 bit32 agRequestType; 11250 agsaFisRegHostToDevice_t *fis; 11251 11252 TI_DBG4(("satSMARTEnable entry: tiDeviceHandle=%p tiIORequest=%p\n", 11253 tiDeviceHandle, tiIORequest)); 11254 11255 fis = satIOContext->pFis; 11256 11257 /* 11258 * Send the SAT_SMART_ENABLE_OPERATIONS command. 11259 */ 11260 fis->h.fisType = 0x27; /* Reg host to device */ 11261 fis->h.c_pmPort = 0x80; /* C Bit is set */ 11262 11263 fis->h.command = SAT_SMART_ENABLE_OPERATIONS; /* 0xB0 */ 11264 fis->h.features = 0xD8; 11265 fis->d.lbaLow = 0; 11266 fis->d.lbaMid = 0x4F; 11267 fis->d.lbaHigh = 0xC2; 11268 fis->d.device = 0; 11269 fis->d.lbaLowExp = 0; 11270 fis->d.lbaMidExp = 0; 11271 fis->d.lbaHighExp = 0; 11272 fis->d.featuresExp = 0; 11273 fis->d.sectorCount = 0; 11274 fis->d.sectorCountExp = 0; 11275 fis->d.reserved4 = 0; 11276 fis->d.control = 0; /* FIS HOB bit clear */ 11277 fis->d.reserved5 = 0; 11278 11279 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 11280 11281 /* Initialize CB for SATA completion. 11282 */ 11283 satIOContext->satCompleteCB = &satSMARTEnableCB; 11284 11285 /* 11286 * Prepare SGL and send FIS to LL layer. 11287 */ 11288 satIOContext->reqType = agRequestType; /* Save it */ 11289 11290 status = sataLLIOStart( tiRoot, 11291 tiIORequest, 11292 tiDeviceHandle, 11293 tiScsiRequest, 11294 satIOContext); 11295 11296 11297 return status; 11298 } 11299 11300 /*****************************************************************************/ 11301 /*! \brief SAT implementation for SCSI satLogSense_3. 11302 * 11303 * Part of SAT implementation for SCSI satLogSense. 11304 * 11305 * \param tiRoot: Pointer to TISA initiator driver/port instance. 11306 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 11307 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 11308 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 11309 * \param satIOContext_t: Pointer to the SAT IO Context 11310 * 11311 * \return If command is started successfully 11312 * - \e tiSuccess: I/O request successfully initiated. 11313 * - \e tiBusy: No resources available, try again later. 11314 * - \e tiIONoDevice: Invalid device handle. 11315 * - \e tiError: Other errors. 11316 */ 11317 /*****************************************************************************/ 11318 GLOBAL bit32 satLogSense_3( 11319 tiRoot_t *tiRoot, 11320 tiIORequest_t *tiIORequest, 11321 tiDeviceHandle_t *tiDeviceHandle, 11322 tiScsiInitiatorRequest_t *tiScsiRequest, 11323 satIOContext_t *satIOContext) 11324 { 11325 bit32 status; 11326 bit32 agRequestType; 11327 agsaFisRegHostToDevice_t *fis; 11328 11329 TI_DBG4(("satLogSense_3 entry: tiDeviceHandle=%p tiIORequest=%p\n", 11330 tiDeviceHandle, tiIORequest)); 11331 11332 fis = satIOContext->pFis; 11333 /* sends READ LOG EXT */ 11334 fis->h.fisType = 0x27; /* Reg host to device */ 11335 fis->h.c_pmPort = 0x80; /* C Bit is set */ 11336 11337 fis->h.command = SAT_SMART_READ_LOG; /* 0x2F */ 11338 fis->h.features = 0xD5; /* 0xd5 */ 11339 fis->d.lbaLow = 0x06; /* 0x06 */ 11340 fis->d.lbaMid = 0x4F; /* 0x4f */ 11341 fis->d.lbaHigh = 0xC2; /* 0xc2 */ 11342 fis->d.device = 0; /* */ 11343 fis->d.lbaLowExp = 0; /* */ 11344 fis->d.lbaMidExp = 0; /* */ 11345 fis->d.lbaHighExp = 0; /* */ 11346 fis->d.featuresExp = 0; /* FIS reserve */ 11347 fis->d.sectorCount = 0x01; /* 1 sector counts */ 11348 fis->d.sectorCountExp = 0x00; /* 1 sector counts */ 11349 fis->d.reserved4 = 0; 11350 fis->d.control = 0; /* FIS HOB bit clear */ 11351 fis->d.reserved5 = 0; 11352 11353 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 11354 11355 /* Initialize CB for SATA completion. 11356 */ 11357 satIOContext->satCompleteCB = &satLogSenseCB; 11358 11359 /* 11360 * Prepare SGL and send FIS to LL layer. 11361 */ 11362 satIOContext->reqType = agRequestType; /* Save it */ 11363 11364 status = sataLLIOStart( tiRoot, 11365 tiIORequest, 11366 tiDeviceHandle, 11367 tiScsiRequest, 11368 satIOContext); 11369 return status; 11370 } 11371 11372 /*****************************************************************************/ 11373 /*! \brief SAT implementation for SCSI satLogSense_2. 11374 * 11375 * Part of SAT implementation for SCSI satLogSense. 11376 * 11377 * \param tiRoot: Pointer to TISA initiator driver/port instance. 11378 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 11379 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 11380 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 11381 * \param satIOContext_t: Pointer to the SAT IO Context 11382 * 11383 * \return If command is started successfully 11384 * - \e tiSuccess: I/O request successfully initiated. 11385 * - \e tiBusy: No resources available, try again later. 11386 * - \e tiIONoDevice: Invalid device handle. 11387 * - \e tiError: Other errors. 11388 */ 11389 /*****************************************************************************/ 11390 GLOBAL bit32 satLogSense_2( 11391 tiRoot_t *tiRoot, 11392 tiIORequest_t *tiIORequest, 11393 tiDeviceHandle_t *tiDeviceHandle, 11394 tiScsiInitiatorRequest_t *tiScsiRequest, 11395 satIOContext_t *satIOContext) 11396 { 11397 bit32 status; 11398 bit32 agRequestType; 11399 agsaFisRegHostToDevice_t *fis; 11400 11401 TI_DBG4(("satLogSense_2 entry: tiDeviceHandle=%p tiIORequest=%p\n", 11402 tiDeviceHandle, tiIORequest)); 11403 11404 fis = satIOContext->pFis; 11405 /* sends READ LOG EXT */ 11406 fis->h.fisType = 0x27; /* Reg host to device */ 11407 fis->h.c_pmPort = 0x80; /* C Bit is set */ 11408 11409 fis->h.command = SAT_READ_LOG_EXT; /* 0x2F */ 11410 fis->h.features = 0; /* FIS reserve */ 11411 fis->d.lbaLow = 0x07; /* 0x07 */ 11412 fis->d.lbaMid = 0; /* */ 11413 fis->d.lbaHigh = 0; /* */ 11414 fis->d.device = 0; /* */ 11415 fis->d.lbaLowExp = 0; /* */ 11416 fis->d.lbaMidExp = 0; /* */ 11417 fis->d.lbaHighExp = 0; /* */ 11418 fis->d.featuresExp = 0; /* FIS reserve */ 11419 fis->d.sectorCount = 0x01; /* 1 sector counts */ 11420 fis->d.sectorCountExp = 0x00; /* 1 sector counts */ 11421 fis->d.reserved4 = 0; 11422 fis->d.control = 0; /* FIS HOB bit clear */ 11423 fis->d.reserved5 = 0; 11424 11425 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 11426 11427 /* Initialize CB for SATA completion. 11428 */ 11429 satIOContext->satCompleteCB = &satLogSenseCB; 11430 11431 /* 11432 * Prepare SGL and send FIS to LL layer. 11433 */ 11434 satIOContext->reqType = agRequestType; /* Save it */ 11435 11436 status = sataLLIOStart( tiRoot, 11437 tiIORequest, 11438 tiDeviceHandle, 11439 tiScsiRequest, 11440 satIOContext); 11441 return status; 11442 } 11443 11444 /*****************************************************************************/ 11445 /*! \brief SAT implementation for SCSI satLogSenseAllocate. 11446 * 11447 * Part of SAT implementation for SCSI satLogSense. 11448 * 11449 * \param tiRoot: Pointer to TISA initiator driver/port instance. 11450 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 11451 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 11452 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 11453 * \param satIOContext_t: Pointer to the SAT IO Context 11454 * \param payloadSize: size of payload to be allocated. 11455 * \param flag: flag value 11456 * 11457 * \return If command is started successfully 11458 * - \e tiSuccess: I/O request successfully initiated. 11459 * - \e tiBusy: No resources available, try again later. 11460 * - \e tiIONoDevice: Invalid device handle. 11461 * - \e tiError: Other errors. 11462 * \note 11463 * - flag values: LOG_SENSE_0, LOG_SENSE_1, LOG_SENSE_2 11464 */ 11465 /*****************************************************************************/ 11466 GLOBAL bit32 satLogSenseAllocate( 11467 tiRoot_t *tiRoot, 11468 tiIORequest_t *tiIORequest, 11469 tiDeviceHandle_t *tiDeviceHandle, 11470 tiScsiInitiatorRequest_t *tiScsiRequest, 11471 satIOContext_t *satIOContext, 11472 bit32 payloadSize, 11473 bit32 flag 11474 ) 11475 { 11476 satDeviceData_t *pSatDevData; 11477 tdIORequestBody_t *tdIORequestBody; 11478 satInternalIo_t *satIntIo = agNULL; 11479 satIOContext_t *satIOContext2; 11480 bit32 status; 11481 11482 TI_DBG4(("satLogSense_2 entry: tiDeviceHandle=%p tiIORequest=%p\n", 11483 tiDeviceHandle, tiIORequest)); 11484 11485 pSatDevData = satIOContext->pSatDevData; 11486 11487 /* create internal satIOContext */ 11488 satIntIo = satAllocIntIoResource( tiRoot, 11489 tiIORequest, /* original request */ 11490 pSatDevData, 11491 payloadSize, 11492 satIntIo); 11493 11494 if (satIntIo == agNULL) 11495 { 11496 /* memory allocation failure */ 11497 satFreeIntIoResource( tiRoot, 11498 pSatDevData, 11499 satIntIo); 11500 11501 ostiInitiatorIOCompleted( tiRoot, 11502 tiIORequest, 11503 tiIOFailed, 11504 tiDetailOtherError, 11505 agNULL, 11506 satIOContext->interruptContext ); 11507 11508 TI_DBG4(("satLogSense_2: fail in allocation\n")); 11509 return tiSuccess; 11510 } /* end of memory allocation failure */ 11511 11512 satIntIo->satOrgTiIORequest = tiIORequest; 11513 tdIORequestBody = (tdIORequestBody_t *)satIntIo->satIntRequestBody; 11514 satIOContext2 = &(tdIORequestBody->transport.SATA.satIOContext); 11515 11516 satIOContext2->pSatDevData = pSatDevData; 11517 satIOContext2->pFis = &(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 11518 satIOContext2->pScsiCmnd = &(satIntIo->satIntTiScsiXchg.scsiCmnd); 11519 satIOContext2->pSense = &(tdIORequestBody->transport.SATA.sensePayload); 11520 satIOContext2->pTiSenseData = &(tdIORequestBody->transport.SATA.tiSenseData); 11521 satIOContext2->pTiSenseData->senseData = satIOContext2->pSense; 11522 satIOContext2->tiRequestBody = satIntIo->satIntRequestBody; 11523 satIOContext2->interruptContext = satIOContext->interruptContext; 11524 satIOContext2->satIntIoContext = satIntIo; 11525 satIOContext2->ptiDeviceHandle = tiDeviceHandle; 11526 satIOContext2->satOrgIOContext = satIOContext; 11527 11528 if (flag == LOG_SENSE_0) 11529 { 11530 /* SAT_SMART_ENABLE_OPERATIONS */ 11531 status = satSMARTEnable( tiRoot, 11532 &(satIntIo->satIntTiIORequest), 11533 tiDeviceHandle, 11534 &(satIntIo->satIntTiScsiXchg), 11535 satIOContext2); 11536 } 11537 else if (flag == LOG_SENSE_1) 11538 { 11539 /* SAT_READ_LOG_EXT */ 11540 status = satLogSense_2( tiRoot, 11541 &(satIntIo->satIntTiIORequest), 11542 tiDeviceHandle, 11543 &(satIntIo->satIntTiScsiXchg), 11544 satIOContext2); 11545 } 11546 else 11547 { 11548 /* SAT_SMART_READ_LOG */ 11549 /* SAT_READ_LOG_EXT */ 11550 status = satLogSense_3( tiRoot, 11551 &(satIntIo->satIntTiIORequest), 11552 tiDeviceHandle, 11553 &(satIntIo->satIntTiScsiXchg), 11554 satIOContext2); 11555 11556 } 11557 if (status != tiSuccess) 11558 { 11559 satFreeIntIoResource( tiRoot, 11560 pSatDevData, 11561 satIntIo); 11562 11563 ostiInitiatorIOCompleted( tiRoot, 11564 tiIORequest, 11565 tiIOFailed, 11566 tiDetailOtherError, 11567 agNULL, 11568 satIOContext->interruptContext ); 11569 return tiSuccess; 11570 } 11571 11572 11573 return tiSuccess; 11574 } 11575 11576 11577 /*****************************************************************************/ 11578 /*! \brief SAT implementation for SCSI satLogSense. 11579 * 11580 * SAT implementation for SCSI satLogSense. 11581 * 11582 * \param tiRoot: Pointer to TISA initiator driver/port instance. 11583 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 11584 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 11585 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 11586 * \param satIOContext_t: Pointer to the SAT IO Context 11587 * 11588 * \return If command is started successfully 11589 * - \e tiSuccess: I/O request successfully initiated. 11590 * - \e tiBusy: No resources available, try again later. 11591 * - \e tiIONoDevice: Invalid device handle. 11592 * - \e tiError: Other errors. 11593 */ 11594 /*****************************************************************************/ 11595 GLOBAL bit32 satLogSense( 11596 tiRoot_t *tiRoot, 11597 tiIORequest_t *tiIORequest, 11598 tiDeviceHandle_t *tiDeviceHandle, 11599 tiScsiInitiatorRequest_t *tiScsiRequest, 11600 satIOContext_t *satIOContext) 11601 { 11602 bit32 status; 11603 bit32 agRequestType; 11604 satDeviceData_t *pSatDevData; 11605 scsiRspSense_t *pSense; 11606 tiIniScsiCmnd_t *scsiCmnd; 11607 agsaFisRegHostToDevice_t *fis; 11608 bit8 *pLogPage; /* Log Page data buffer */ 11609 bit32 flag = 0; 11610 bit16 AllocLen = 0; /* allocation length */ 11611 bit8 AllLogPages[8]; 11612 bit16 lenRead = 0; 11613 11614 pSense = satIOContext->pSense; 11615 pSatDevData = satIOContext->pSatDevData; 11616 scsiCmnd = &tiScsiRequest->scsiCmnd; 11617 fis = satIOContext->pFis; 11618 pLogPage = (bit8 *) tiScsiRequest->sglVirtualAddr; 11619 11620 TI_DBG5(("satLogSense: start\n")); 11621 11622 osti_memset(&AllLogPages, 0, 8); 11623 /* checking CONTROL */ 11624 /* NACA == 1 or LINK == 1*/ 11625 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 11626 { 11627 satSetSensePayload( pSense, 11628 SCSI_SNSKEY_ILLEGAL_REQUEST, 11629 0, 11630 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 11631 satIOContext); 11632 11633 ostiInitiatorIOCompleted( tiRoot, 11634 tiIORequest, 11635 tiIOSuccess, 11636 SCSI_STAT_CHECK_CONDITION, 11637 satIOContext->pTiSenseData, 11638 satIOContext->interruptContext ); 11639 11640 TI_DBG2(("satLogSense: return control\n")); 11641 return tiSuccess; 11642 } 11643 11644 11645 AllocLen = (bit8)((scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]); 11646 11647 /* checking PC (Page Control) */ 11648 /* nothing */ 11649 11650 /* special cases */ 11651 if (AllocLen == 4) 11652 { 11653 TI_DBG1(("satLogSense: AllocLen is 4\n")); 11654 switch (scsiCmnd->cdb[2] & SCSI_LOG_SENSE_PAGE_CODE_MASK) 11655 { 11656 case LOGSENSE_SUPPORTED_LOG_PAGES: 11657 TI_DBG5(("satLogSense: case LOGSENSE_SUPPORTED_LOG_PAGES\n")); 11658 11659 /* SAT Rev 8, 10.2.5 p76 */ 11660 if (pSatDevData->satSMARTFeatureSet == agTRUE) 11661 { 11662 /* add informational exception log */ 11663 flag = 1; 11664 if (pSatDevData->satSMARTSelfTest == agTRUE) 11665 { 11666 /* add Self-Test results log page */ 11667 flag = 2; 11668 } 11669 } 11670 else 11671 { 11672 /* only supported, no informational exception log, no Self-Test results log page */ 11673 flag = 0; 11674 } 11675 lenRead = 4; 11676 AllLogPages[0] = LOGSENSE_SUPPORTED_LOG_PAGES; /* page code */ 11677 AllLogPages[1] = 0; /* reserved */ 11678 switch (flag) 11679 { 11680 case 0: 11681 /* only supported */ 11682 AllLogPages[2] = 0; /* page length */ 11683 AllLogPages[3] = 1; /* page length */ 11684 break; 11685 case 1: 11686 /* supported and informational exception log */ 11687 AllLogPages[2] = 0; /* page length */ 11688 AllLogPages[3] = 2; /* page length */ 11689 break; 11690 case 2: 11691 /* supported and informational exception log */ 11692 AllLogPages[2] = 0; /* page length */ 11693 AllLogPages[3] = 3; /* page length */ 11694 break; 11695 default: 11696 TI_DBG1(("satLogSense: error unallowed flag value %d\n", flag)); 11697 break; 11698 } 11699 osti_memcpy(pLogPage, &AllLogPages, lenRead); 11700 break; 11701 case LOGSENSE_SELFTEST_RESULTS_PAGE: 11702 TI_DBG5(("satLogSense: case LOGSENSE_SUPPORTED_LOG_PAGES\n")); 11703 lenRead = 4; 11704 AllLogPages[0] = LOGSENSE_SELFTEST_RESULTS_PAGE; /* page code */ 11705 AllLogPages[1] = 0; /* reserved */ 11706 /* page length = SELFTEST_RESULTS_LOG_PAGE_LENGTH - 1 - 3 = 400 = 0x190 */ 11707 AllLogPages[2] = 0x01; 11708 AllLogPages[3] = 0x90; /* page length */ 11709 osti_memcpy(pLogPage, &AllLogPages, lenRead); 11710 11711 break; 11712 case LOGSENSE_INFORMATION_EXCEPTIONS_PAGE: 11713 TI_DBG5(("satLogSense: case LOGSENSE_SUPPORTED_LOG_PAGES\n")); 11714 lenRead = 4; 11715 AllLogPages[0] = LOGSENSE_INFORMATION_EXCEPTIONS_PAGE; /* page code */ 11716 AllLogPages[1] = 0; /* reserved */ 11717 AllLogPages[2] = 0; /* page length */ 11718 AllLogPages[3] = INFORMATION_EXCEPTIONS_LOG_PAGE_LENGTH - 1 - 3; /* page length */ 11719 osti_memcpy(pLogPage, &AllLogPages, lenRead); 11720 break; 11721 default: 11722 TI_DBG1(("satLogSense: default Page Code 0x%x\n", scsiCmnd->cdb[2] & SCSI_LOG_SENSE_PAGE_CODE_MASK)); 11723 satSetSensePayload( pSense, 11724 SCSI_SNSKEY_ILLEGAL_REQUEST, 11725 0, 11726 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 11727 satIOContext); 11728 11729 ostiInitiatorIOCompleted( tiRoot, 11730 tiIORequest, 11731 tiIOSuccess, 11732 SCSI_STAT_CHECK_CONDITION, 11733 satIOContext->pTiSenseData, 11734 satIOContext->interruptContext ); 11735 return tiSuccess; 11736 } 11737 ostiInitiatorIOCompleted( tiRoot, 11738 tiIORequest, 11739 tiIOSuccess, 11740 SCSI_STAT_GOOD, 11741 agNULL, 11742 satIOContext->interruptContext); 11743 return tiSuccess; 11744 11745 } /* if */ 11746 11747 /* SAT rev8 Table 11 p30*/ 11748 /* checking Page Code */ 11749 switch (scsiCmnd->cdb[2] & SCSI_LOG_SENSE_PAGE_CODE_MASK) 11750 { 11751 case LOGSENSE_SUPPORTED_LOG_PAGES: 11752 TI_DBG5(("satLogSense: case 1\n")); 11753 11754 /* SAT Rev 8, 10.2.5 p76 */ 11755 11756 if (pSatDevData->satSMARTFeatureSet == agTRUE) 11757 { 11758 /* add informational exception log */ 11759 flag = 1; 11760 if (pSatDevData->satSMARTSelfTest == agTRUE) 11761 { 11762 /* add Self-Test results log page */ 11763 flag = 2; 11764 } 11765 } 11766 else 11767 { 11768 /* only supported, no informational exception log, no Self-Test results log page */ 11769 flag = 0; 11770 } 11771 AllLogPages[0] = 0; /* page code */ 11772 AllLogPages[1] = 0; /* reserved */ 11773 switch (flag) 11774 { 11775 case 0: 11776 /* only supported */ 11777 AllLogPages[2] = 0; /* page length */ 11778 AllLogPages[3] = 1; /* page length */ 11779 AllLogPages[4] = 0x00; /* supported page list */ 11780 lenRead = (bit8)(MIN(AllocLen, 5)); 11781 break; 11782 case 1: 11783 /* supported and informational exception log */ 11784 AllLogPages[2] = 0; /* page length */ 11785 AllLogPages[3] = 2; /* page length */ 11786 AllLogPages[4] = 0x00; /* supported page list */ 11787 AllLogPages[5] = 0x10; /* supported page list */ 11788 lenRead = (bit8)(MIN(AllocLen, 6)); 11789 break; 11790 case 2: 11791 /* supported and informational exception log */ 11792 AllLogPages[2] = 0; /* page length */ 11793 AllLogPages[3] = 3; /* page length */ 11794 AllLogPages[4] = 0x00; /* supported page list */ 11795 AllLogPages[5] = 0x10; /* supported page list */ 11796 AllLogPages[6] = 0x2F; /* supported page list */ 11797 lenRead = (bit8)(MIN(AllocLen, 7)); 11798 break; 11799 default: 11800 TI_DBG1(("satLogSense: error unallowed flag value %d\n", flag)); 11801 break; 11802 } 11803 11804 osti_memcpy(pLogPage, &AllLogPages, lenRead); 11805 /* comparing allocation length to Log Page byte size */ 11806 /* SPC-4, 4.3.4.6, p28 */ 11807 if (AllocLen > lenRead ) 11808 { 11809 TI_DBG1(("satLogSense reporting underrun lenRead=0x%x AllocLen=0x%x tiIORequest=%p\n", lenRead, AllocLen, tiIORequest)); 11810 ostiInitiatorIOCompleted( tiRoot, 11811 tiIORequest, 11812 tiIOUnderRun, 11813 AllocLen - lenRead, 11814 agNULL, 11815 satIOContext->interruptContext ); 11816 } 11817 else 11818 { 11819 ostiInitiatorIOCompleted( tiRoot, 11820 tiIORequest, 11821 tiIOSuccess, 11822 SCSI_STAT_GOOD, 11823 agNULL, 11824 satIOContext->interruptContext); 11825 } 11826 break; 11827 case LOGSENSE_SELFTEST_RESULTS_PAGE: 11828 TI_DBG5(("satLogSense: case 2\n")); 11829 /* checking SMART self-test */ 11830 if (pSatDevData->satSMARTSelfTest == agFALSE) 11831 { 11832 TI_DBG5(("satLogSense: case 2 no SMART Self Test\n")); 11833 satSetSensePayload( pSense, 11834 SCSI_SNSKEY_ILLEGAL_REQUEST, 11835 0, 11836 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 11837 satIOContext); 11838 11839 ostiInitiatorIOCompleted( tiRoot, 11840 tiIORequest, 11841 tiIOSuccess, 11842 SCSI_STAT_CHECK_CONDITION, 11843 satIOContext->pTiSenseData, 11844 satIOContext->interruptContext ); 11845 } 11846 else 11847 { 11848 /* if satSMARTEnabled is false, send SMART_ENABLE_OPERATIONS */ 11849 if (pSatDevData->satSMARTEnabled == agFALSE) 11850 { 11851 TI_DBG5(("satLogSense: case 2 calling satSMARTEnable\n")); 11852 status = satLogSenseAllocate(tiRoot, 11853 tiIORequest, 11854 tiDeviceHandle, 11855 tiScsiRequest, 11856 satIOContext, 11857 0, 11858 LOG_SENSE_0 11859 ); 11860 11861 return status; 11862 11863 } 11864 else 11865 { 11866 /* SAT Rev 8, 10.2.4 p74 */ 11867 if ( pSatDevData->sat48BitSupport == agTRUE ) 11868 { 11869 TI_DBG5(("satLogSense: case 2-1 sends READ LOG EXT\n")); 11870 status = satLogSenseAllocate(tiRoot, 11871 tiIORequest, 11872 tiDeviceHandle, 11873 tiScsiRequest, 11874 satIOContext, 11875 512, 11876 LOG_SENSE_1 11877 ); 11878 11879 return status; 11880 } 11881 else 11882 { 11883 TI_DBG5(("satLogSense: case 2-2 sends SMART READ LOG\n")); 11884 status = satLogSenseAllocate(tiRoot, 11885 tiIORequest, 11886 tiDeviceHandle, 11887 tiScsiRequest, 11888 satIOContext, 11889 512, 11890 LOG_SENSE_2 11891 ); 11892 11893 return status; 11894 } 11895 } 11896 } 11897 break; 11898 case LOGSENSE_INFORMATION_EXCEPTIONS_PAGE: 11899 TI_DBG5(("satLogSense: case 3\n")); 11900 /* checking SMART feature set */ 11901 if (pSatDevData->satSMARTFeatureSet == agFALSE) 11902 { 11903 satSetSensePayload( pSense, 11904 SCSI_SNSKEY_ILLEGAL_REQUEST, 11905 0, 11906 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 11907 satIOContext); 11908 11909 ostiInitiatorIOCompleted( tiRoot, 11910 tiIORequest, 11911 tiIOSuccess, 11912 SCSI_STAT_CHECK_CONDITION, 11913 satIOContext->pTiSenseData, 11914 satIOContext->interruptContext ); 11915 } 11916 else 11917 { 11918 /* checking SMART feature enabled */ 11919 if (pSatDevData->satSMARTEnabled == agFALSE) 11920 { 11921 satSetSensePayload( pSense, 11922 SCSI_SNSKEY_ABORTED_COMMAND, 11923 0, 11924 SCSI_SNSCODE_ATA_DEVICE_FEATURE_NOT_ENABLED, 11925 satIOContext); 11926 11927 ostiInitiatorIOCompleted( tiRoot, 11928 tiIORequest, 11929 tiIOSuccess, 11930 SCSI_STAT_CHECK_CONDITION, 11931 satIOContext->pTiSenseData, 11932 satIOContext->interruptContext ); 11933 } 11934 else 11935 { 11936 /* SAT Rev 8, 10.2.3 p72 */ 11937 TI_DBG5(("satLogSense: case 3 sends SMART RETURN STATUS\n")); 11938 11939 /* sends SMART RETURN STATUS */ 11940 fis->h.fisType = 0x27; /* Reg host to device */ 11941 fis->h.c_pmPort = 0x80; /* C Bit is set */ 11942 11943 fis->h.command = SAT_SMART_RETURN_STATUS;/* 0xB0 */ 11944 fis->h.features = 0xDA; /* FIS features */ 11945 fis->d.featuresExp = 0; /* FIS reserve */ 11946 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 11947 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 11948 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 11949 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 11950 fis->d.lbaMid = 0x4F; /* FIS LBA (15:8 ) */ 11951 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 11952 fis->d.lbaHigh = 0xC2; /* FIS LBA (23:16) */ 11953 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 11954 fis->d.device = 0; /* FIS DEV is discared in SATA */ 11955 fis->d.control = 0; /* FIS HOB bit clear */ 11956 fis->d.reserved4 = 0; 11957 fis->d.reserved5 = 0; 11958 11959 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 11960 /* Initialize CB for SATA completion. 11961 */ 11962 satIOContext->satCompleteCB = &satLogSenseCB; 11963 11964 /* 11965 * Prepare SGL and send FIS to LL layer. 11966 */ 11967 satIOContext->reqType = agRequestType; /* Save it */ 11968 11969 status = sataLLIOStart( tiRoot, 11970 tiIORequest, 11971 tiDeviceHandle, 11972 tiScsiRequest, 11973 satIOContext); 11974 11975 11976 return status; 11977 } 11978 } 11979 break; 11980 default: 11981 TI_DBG1(("satLogSense: default Page Code 0x%x\n", scsiCmnd->cdb[2] & SCSI_LOG_SENSE_PAGE_CODE_MASK)); 11982 satSetSensePayload( pSense, 11983 SCSI_SNSKEY_ILLEGAL_REQUEST, 11984 0, 11985 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 11986 satIOContext); 11987 11988 ostiInitiatorIOCompleted( tiRoot, 11989 tiIORequest, 11990 tiIOSuccess, 11991 SCSI_STAT_CHECK_CONDITION, 11992 satIOContext->pTiSenseData, 11993 satIOContext->interruptContext ); 11994 11995 break; 11996 } /* end switch */ 11997 11998 return tiSuccess; 11999 12000 12001 } 12002 12003 /*****************************************************************************/ 12004 /*! \brief SAT implementation for SCSI satModeSelect6. 12005 * 12006 * SAT implementation for SCSI satModeSelect6. 12007 * 12008 * \param tiRoot: Pointer to TISA initiator driver/port instance. 12009 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 12010 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 12011 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 12012 * \param satIOContext_t: Pointer to the SAT IO Context 12013 * 12014 * \return If command is started successfully 12015 * - \e tiSuccess: I/O request successfully initiated. 12016 * - \e tiBusy: No resources available, try again later. 12017 * - \e tiIONoDevice: Invalid device handle. 12018 * - \e tiError: Other errors. 12019 */ 12020 /*****************************************************************************/ 12021 GLOBAL bit32 satModeSelect6( 12022 tiRoot_t *tiRoot, 12023 tiIORequest_t *tiIORequest, 12024 tiDeviceHandle_t *tiDeviceHandle, 12025 tiScsiInitiatorRequest_t *tiScsiRequest, 12026 satIOContext_t *satIOContext) 12027 { 12028 bit32 status; 12029 bit32 agRequestType; 12030 satDeviceData_t *pSatDevData; 12031 scsiRspSense_t *pSense; 12032 tiIniScsiCmnd_t *scsiCmnd; 12033 agsaFisRegHostToDevice_t *fis; 12034 bit8 *pLogPage; /* Log Page data buffer */ 12035 bit32 StartingIndex = 0; 12036 bit8 PageCode = 0; 12037 bit32 chkCnd = agFALSE; 12038 12039 pSense = satIOContext->pSense; 12040 pSatDevData = satIOContext->pSatDevData; 12041 scsiCmnd = &tiScsiRequest->scsiCmnd; 12042 fis = satIOContext->pFis; 12043 pLogPage = (bit8 *) tiScsiRequest->sglVirtualAddr; 12044 12045 TI_DBG5(("satModeSelect6: start\n")); 12046 12047 /* checking CONTROL */ 12048 /* NACA == 1 or LINK == 1*/ 12049 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 12050 { 12051 satSetSensePayload( pSense, 12052 SCSI_SNSKEY_ILLEGAL_REQUEST, 12053 0, 12054 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 12055 satIOContext); 12056 12057 ostiInitiatorIOCompleted( tiRoot, 12058 tiIORequest, 12059 tiIOSuccess, 12060 SCSI_STAT_CHECK_CONDITION, 12061 satIOContext->pTiSenseData, 12062 satIOContext->interruptContext ); 12063 12064 TI_DBG2(("satModeSelect6: return control\n")); 12065 return tiSuccess; 12066 } 12067 12068 /* checking PF bit */ 12069 if ( !(scsiCmnd->cdb[1] & SCSI_MODE_SELECT6_PF_MASK)) 12070 { 12071 satSetSensePayload( pSense, 12072 SCSI_SNSKEY_ILLEGAL_REQUEST, 12073 0, 12074 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 12075 satIOContext); 12076 12077 ostiInitiatorIOCompleted( tiRoot, 12078 tiIORequest, 12079 tiIOSuccess, 12080 SCSI_STAT_CHECK_CONDITION, 12081 satIOContext->pTiSenseData, 12082 satIOContext->interruptContext ); 12083 12084 TI_DBG1(("satModeSelect6: PF bit check \n")); 12085 return tiSuccess; 12086 12087 } 12088 12089 /* checking Block Descriptor Length on Mode parameter header(6)*/ 12090 if (pLogPage[3] == 8) 12091 { 12092 /* mode parameter block descriptor exists */ 12093 PageCode = (bit8)(pLogPage[12] & 0x3F); /* page code and index is 4 + 8 */ 12094 StartingIndex = 12; 12095 } 12096 else if (pLogPage[3] == 0) 12097 { 12098 /* mode parameter block descriptor does not exist */ 12099 PageCode = (bit8)(pLogPage[4] & 0x3F); /* page code and index is 4 + 0 */ 12100 StartingIndex = 4; 12101 ostiInitiatorIOCompleted( tiRoot, 12102 tiIORequest, 12103 tiIOSuccess, 12104 SCSI_STAT_GOOD, 12105 agNULL, 12106 satIOContext->interruptContext); 12107 return tiSuccess; 12108 } 12109 else 12110 { 12111 TI_DBG1(("satModeSelect6: return mode parameter block descriptor 0x%x\n", pLogPage[3])); 12112 /* no more than one mode parameter block descriptor shall be supported */ 12113 satSetSensePayload( pSense, 12114 SCSI_SNSKEY_NO_SENSE, 12115 0, 12116 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 12117 satIOContext); 12118 12119 ostiInitiatorIOCompleted( tiRoot, 12120 tiIORequest, 12121 tiIOSuccess, 12122 SCSI_STAT_CHECK_CONDITION, 12123 satIOContext->pTiSenseData, 12124 satIOContext->interruptContext ); 12125 return tiSuccess; 12126 } 12127 12128 12129 12130 switch (PageCode) /* page code */ 12131 { 12132 case MODESELECT_CONTROL_PAGE: 12133 TI_DBG1(("satModeSelect6: Control mode page\n")); 12134 /* 12135 compare pLogPage to expected value (SAT Table 65, p67) 12136 If not match, return check condition 12137 */ 12138 if ( pLogPage[StartingIndex+1] != 0x0A || 12139 pLogPage[StartingIndex+2] != 0x02 || 12140 (pSatDevData->satNCQ == agTRUE && pLogPage[StartingIndex+3] != 0x12) || 12141 (pSatDevData->satNCQ == agFALSE && pLogPage[StartingIndex+3] != 0x02) || 12142 (pLogPage[StartingIndex+4] & BIT3_MASK) != 0x00 || /* SWP bit */ 12143 (pLogPage[StartingIndex+4] & BIT4_MASK) != 0x00 || /* UA_INTLCK_CTRL */ 12144 (pLogPage[StartingIndex+4] & BIT5_MASK) != 0x00 || /* UA_INTLCK_CTRL */ 12145 12146 (pLogPage[StartingIndex+5] & BIT0_MASK) != 0x00 || /* AUTOLOAD MODE */ 12147 (pLogPage[StartingIndex+5] & BIT1_MASK) != 0x00 || /* AUTOLOAD MODE */ 12148 (pLogPage[StartingIndex+5] & BIT2_MASK) != 0x00 || /* AUTOLOAD MODE */ 12149 (pLogPage[StartingIndex+5] & BIT6_MASK) != 0x00 || /* TAS bit */ 12150 12151 pLogPage[StartingIndex+8] != 0xFF || 12152 pLogPage[StartingIndex+9] != 0xFF || 12153 pLogPage[StartingIndex+10] != 0x00 || 12154 pLogPage[StartingIndex+11] != 0x00 12155 ) 12156 { 12157 chkCnd = agTRUE; 12158 } 12159 if (chkCnd == agTRUE) 12160 { 12161 satSetSensePayload( pSense, 12162 SCSI_SNSKEY_ILLEGAL_REQUEST, 12163 0, 12164 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 12165 satIOContext); 12166 12167 ostiInitiatorIOCompleted( tiRoot, 12168 tiIORequest, 12169 tiIOSuccess, 12170 SCSI_STAT_CHECK_CONDITION, 12171 satIOContext->pTiSenseData, 12172 satIOContext->interruptContext ); 12173 12174 TI_DBG1(("satModeSelect10: unexpected values\n")); 12175 } 12176 else 12177 { 12178 ostiInitiatorIOCompleted( tiRoot, 12179 tiIORequest, 12180 tiIOSuccess, 12181 SCSI_STAT_GOOD, 12182 agNULL, 12183 satIOContext->interruptContext); 12184 } 12185 return tiSuccess; 12186 break; 12187 case MODESELECT_READ_WRITE_ERROR_RECOVERY_PAGE: 12188 TI_DBG1(("satModeSelect6: Read-Write Error Recovery mode page\n")); 12189 12190 if ( (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT6_AWRE_MASK) || 12191 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT6_RC_MASK) || 12192 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT6_EER_MASK) || 12193 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT6_PER_MASK) || 12194 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT6_DTE_MASK) || 12195 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT6_DCR_MASK) || 12196 (pLogPage[StartingIndex + 10]) || 12197 (pLogPage[StartingIndex + 11]) 12198 ) 12199 { 12200 TI_DBG5(("satModeSelect6: return check condition \n")); 12201 12202 satSetSensePayload( pSense, 12203 SCSI_SNSKEY_ILLEGAL_REQUEST, 12204 0, 12205 SCSI_SNSCODE_INVALID_FIELD_PARAMETER_LIST, 12206 satIOContext); 12207 12208 ostiInitiatorIOCompleted( tiRoot, 12209 tiIORequest, 12210 tiIOSuccess, 12211 SCSI_STAT_CHECK_CONDITION, 12212 satIOContext->pTiSenseData, 12213 satIOContext->interruptContext ); 12214 return tiSuccess; 12215 } 12216 else 12217 { 12218 TI_DBG5(("satModeSelect6: return GOOD \n")); 12219 ostiInitiatorIOCompleted( tiRoot, 12220 tiIORequest, 12221 tiIOSuccess, 12222 SCSI_STAT_GOOD, 12223 agNULL, 12224 satIOContext->interruptContext); 12225 return tiSuccess; 12226 } 12227 12228 break; 12229 case MODESELECT_CACHING: 12230 /* SAT rev8 Table67, p69*/ 12231 TI_DBG5(("satModeSelect6: Caching mode page\n")); 12232 if ( (pLogPage[StartingIndex + 2] & 0xFB) || /* 1111 1011 */ 12233 (pLogPage[StartingIndex + 3]) || 12234 (pLogPage[StartingIndex + 4]) || 12235 (pLogPage[StartingIndex + 5]) || 12236 (pLogPage[StartingIndex + 6]) || 12237 (pLogPage[StartingIndex + 7]) || 12238 (pLogPage[StartingIndex + 8]) || 12239 (pLogPage[StartingIndex + 9]) || 12240 (pLogPage[StartingIndex + 10]) || 12241 (pLogPage[StartingIndex + 11]) || 12242 12243 (pLogPage[StartingIndex + 12] & 0xC1) || /* 1100 0001 */ 12244 (pLogPage[StartingIndex + 13]) || 12245 (pLogPage[StartingIndex + 14]) || 12246 (pLogPage[StartingIndex + 15]) 12247 ) 12248 { 12249 TI_DBG1(("satModeSelect6: return check condition \n")); 12250 12251 satSetSensePayload( pSense, 12252 SCSI_SNSKEY_ILLEGAL_REQUEST, 12253 0, 12254 SCSI_SNSCODE_INVALID_FIELD_PARAMETER_LIST, 12255 satIOContext); 12256 12257 ostiInitiatorIOCompleted( tiRoot, 12258 tiIORequest, 12259 tiIOSuccess, 12260 SCSI_STAT_CHECK_CONDITION, 12261 satIOContext->pTiSenseData, 12262 satIOContext->interruptContext ); 12263 return tiSuccess; 12264 12265 } 12266 else 12267 { 12268 /* sends ATA SET FEATURES based on WCE bit */ 12269 if ( !(pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT6_WCE_MASK) ) 12270 { 12271 TI_DBG5(("satModeSelect6: disable write cache\n")); 12272 /* sends SET FEATURES */ 12273 fis->h.fisType = 0x27; /* Reg host to device */ 12274 fis->h.c_pmPort = 0x80; /* C Bit is set */ 12275 12276 fis->h.command = SAT_SET_FEATURES; /* 0xEF */ 12277 fis->h.features = 0x82; /* disable write cache */ 12278 fis->d.lbaLow = 0; /* */ 12279 fis->d.lbaMid = 0; /* */ 12280 fis->d.lbaHigh = 0; /* */ 12281 fis->d.device = 0; /* */ 12282 fis->d.lbaLowExp = 0; /* */ 12283 fis->d.lbaMidExp = 0; /* */ 12284 fis->d.lbaHighExp = 0; /* */ 12285 fis->d.featuresExp = 0; /* */ 12286 fis->d.sectorCount = 0; /* */ 12287 fis->d.sectorCountExp = 0; /* */ 12288 fis->d.reserved4 = 0; 12289 fis->d.control = 0; /* FIS HOB bit clear */ 12290 fis->d.reserved5 = 0; 12291 12292 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 12293 12294 /* Initialize CB for SATA completion. 12295 */ 12296 satIOContext->satCompleteCB = &satModeSelect6n10CB; 12297 12298 /* 12299 * Prepare SGL and send FIS to LL layer. 12300 */ 12301 satIOContext->reqType = agRequestType; /* Save it */ 12302 12303 status = sataLLIOStart( tiRoot, 12304 tiIORequest, 12305 tiDeviceHandle, 12306 tiScsiRequest, 12307 satIOContext); 12308 return status; 12309 } 12310 else 12311 { 12312 TI_DBG5(("satModeSelect6: enable write cache\n")); 12313 /* sends SET FEATURES */ 12314 fis->h.fisType = 0x27; /* Reg host to device */ 12315 fis->h.c_pmPort = 0x80; /* C Bit is set */ 12316 12317 fis->h.command = SAT_SET_FEATURES; /* 0xEF */ 12318 fis->h.features = 0x02; /* enable write cache */ 12319 fis->d.lbaLow = 0; /* */ 12320 fis->d.lbaMid = 0; /* */ 12321 fis->d.lbaHigh = 0; /* */ 12322 fis->d.device = 0; /* */ 12323 fis->d.lbaLowExp = 0; /* */ 12324 fis->d.lbaMidExp = 0; /* */ 12325 fis->d.lbaHighExp = 0; /* */ 12326 fis->d.featuresExp = 0; /* */ 12327 fis->d.sectorCount = 0; /* */ 12328 fis->d.sectorCountExp = 0; /* */ 12329 fis->d.reserved4 = 0; 12330 fis->d.control = 0; /* FIS HOB bit clear */ 12331 fis->d.reserved5 = 0; 12332 12333 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 12334 12335 /* Initialize CB for SATA completion. 12336 */ 12337 satIOContext->satCompleteCB = &satModeSelect6n10CB; 12338 12339 /* 12340 * Prepare SGL and send FIS to LL layer. 12341 */ 12342 satIOContext->reqType = agRequestType; /* Save it */ 12343 12344 status = sataLLIOStart( tiRoot, 12345 tiIORequest, 12346 tiDeviceHandle, 12347 tiScsiRequest, 12348 satIOContext); 12349 return status; 12350 12351 } 12352 } 12353 break; 12354 case MODESELECT_INFORMATION_EXCEPTION_CONTROL_PAGE: 12355 TI_DBG5(("satModeSelect6: Informational Exception Control mode page\n")); 12356 if ( (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT6_PERF_MASK) || 12357 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT6_TEST_MASK) 12358 ) 12359 { 12360 TI_DBG1(("satModeSelect6: return check condition \n")); 12361 12362 satSetSensePayload( pSense, 12363 SCSI_SNSKEY_ILLEGAL_REQUEST, 12364 0, 12365 SCSI_SNSCODE_INVALID_FIELD_PARAMETER_LIST, 12366 satIOContext); 12367 12368 ostiInitiatorIOCompleted( tiRoot, 12369 tiIORequest, 12370 tiIOSuccess, 12371 SCSI_STAT_CHECK_CONDITION, 12372 satIOContext->pTiSenseData, 12373 satIOContext->interruptContext ); 12374 return tiSuccess; 12375 } 12376 else 12377 { 12378 /* sends either ATA SMART ENABLE/DISABLE OPERATIONS based on DEXCPT bit */ 12379 if ( !(pLogPage[StartingIndex + 2] & 0x08) ) 12380 { 12381 TI_DBG5(("satModeSelect6: enable information exceptions reporting\n")); 12382 /* sends SMART ENABLE OPERATIONS */ 12383 fis->h.fisType = 0x27; /* Reg host to device */ 12384 fis->h.c_pmPort = 0x80; /* C Bit is set */ 12385 12386 fis->h.command = SAT_SMART_ENABLE_OPERATIONS; /* 0xB0 */ 12387 fis->h.features = 0xD8; /* enable */ 12388 fis->d.lbaLow = 0; /* */ 12389 fis->d.lbaMid = 0x4F; /* 0x4F */ 12390 fis->d.lbaHigh = 0xC2; /* 0xC2 */ 12391 fis->d.device = 0; /* */ 12392 fis->d.lbaLowExp = 0; /* */ 12393 fis->d.lbaMidExp = 0; /* */ 12394 fis->d.lbaHighExp = 0; /* */ 12395 fis->d.featuresExp = 0; /* */ 12396 fis->d.sectorCount = 0; /* */ 12397 fis->d.sectorCountExp = 0; /* */ 12398 fis->d.reserved4 = 0; 12399 fis->d.control = 0; /* FIS HOB bit clear */ 12400 fis->d.reserved5 = 0; 12401 12402 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 12403 12404 /* Initialize CB for SATA completion. 12405 */ 12406 satIOContext->satCompleteCB = &satModeSelect6n10CB; 12407 12408 /* 12409 * Prepare SGL and send FIS to LL layer. 12410 */ 12411 satIOContext->reqType = agRequestType; /* Save it */ 12412 12413 status = sataLLIOStart( tiRoot, 12414 tiIORequest, 12415 tiDeviceHandle, 12416 tiScsiRequest, 12417 satIOContext); 12418 return status; 12419 } 12420 else 12421 { 12422 TI_DBG5(("satModeSelect6: disable information exceptions reporting\n")); 12423 /* sends SMART DISABLE OPERATIONS */ 12424 fis->h.fisType = 0x27; /* Reg host to device */ 12425 fis->h.c_pmPort = 0x80; /* C Bit is set */ 12426 12427 fis->h.command = SAT_SMART_DISABLE_OPERATIONS; /* 0xB0 */ 12428 fis->h.features = 0xD9; /* disable */ 12429 fis->d.lbaLow = 0; /* */ 12430 fis->d.lbaMid = 0x4F; /* 0x4F */ 12431 fis->d.lbaHigh = 0xC2; /* 0xC2 */ 12432 fis->d.device = 0; /* */ 12433 fis->d.lbaLowExp = 0; /* */ 12434 fis->d.lbaMidExp = 0; /* */ 12435 fis->d.lbaHighExp = 0; /* */ 12436 fis->d.featuresExp = 0; /* */ 12437 fis->d.sectorCount = 0; /* */ 12438 fis->d.sectorCountExp = 0; /* */ 12439 fis->d.reserved4 = 0; 12440 fis->d.control = 0; /* FIS HOB bit clear */ 12441 fis->d.reserved5 = 0; 12442 12443 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 12444 12445 /* Initialize CB for SATA completion. 12446 */ 12447 satIOContext->satCompleteCB = &satModeSelect6n10CB; 12448 12449 /* 12450 * Prepare SGL and send FIS to LL layer. 12451 */ 12452 satIOContext->reqType = agRequestType; /* Save it */ 12453 12454 status = sataLLIOStart( tiRoot, 12455 tiIORequest, 12456 tiDeviceHandle, 12457 tiScsiRequest, 12458 satIOContext); 12459 return status; 12460 12461 } 12462 } 12463 break; 12464 default: 12465 TI_DBG1(("satModeSelect6: Error unknown page code 0x%x\n", pLogPage[12])); 12466 satSetSensePayload( pSense, 12467 SCSI_SNSKEY_NO_SENSE, 12468 0, 12469 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 12470 satIOContext); 12471 12472 ostiInitiatorIOCompleted( tiRoot, 12473 tiIORequest, 12474 tiIOSuccess, 12475 SCSI_STAT_CHECK_CONDITION, 12476 satIOContext->pTiSenseData, 12477 satIOContext->interruptContext ); 12478 return tiSuccess; 12479 } 12480 12481 } 12482 12483 /*****************************************************************************/ 12484 /*! \brief SAT implementation for SCSI satModeSelect6n10_1. 12485 * 12486 * This function is part of implementation of ModeSelect6 and ModeSelect10. 12487 * When ModeSelect6 or ModeSelect10 is coverted into multiple ATA commands, 12488 * this function is used. 12489 * 12490 * \param tiRoot: Pointer to TISA initiator driver/port instance. 12491 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 12492 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 12493 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 12494 * \param satIOContext_t: Pointer to the SAT IO Context 12495 * 12496 * \return If command is started successfully 12497 * - \e tiSuccess: I/O request successfully initiated. 12498 * - \e tiBusy: No resources available, try again later. 12499 * - \e tiIONoDevice: Invalid device handle. 12500 * - \e tiError: Other errors. 12501 */ 12502 /*****************************************************************************/ 12503 GLOBAL bit32 satModeSelect6n10_1( 12504 tiRoot_t *tiRoot, 12505 tiIORequest_t *tiIORequest, 12506 tiDeviceHandle_t *tiDeviceHandle, 12507 tiScsiInitiatorRequest_t *tiScsiRequest, 12508 satIOContext_t *satIOContext) 12509 { 12510 /* sends either ATA SET FEATURES based on DRA bit */ 12511 bit32 status; 12512 bit32 agRequestType; 12513 agsaFisRegHostToDevice_t *fis; 12514 bit8 *pLogPage; /* Log Page data buffer */ 12515 bit32 StartingIndex = 0; 12516 12517 fis = satIOContext->pFis; 12518 pLogPage = (bit8 *) tiScsiRequest->sglVirtualAddr; 12519 TI_DBG5(("satModeSelect6_1: start\n")); 12520 /* checking Block Descriptor Length on Mode parameter header(6)*/ 12521 if (pLogPage[3] == 8) 12522 { 12523 /* mode parameter block descriptor exists */ 12524 StartingIndex = 12; 12525 } 12526 else 12527 { 12528 /* mode parameter block descriptor does not exist */ 12529 StartingIndex = 4; 12530 } 12531 12532 /* sends ATA SET FEATURES based on DRA bit */ 12533 if ( !(pLogPage[StartingIndex + 12] & SCSI_MODE_SELECT6_DRA_MASK) ) 12534 { 12535 TI_DBG5(("satModeSelect6_1: enable read look-ahead feature\n")); 12536 /* sends SET FEATURES */ 12537 fis->h.fisType = 0x27; /* Reg host to device */ 12538 fis->h.c_pmPort = 0x80; /* C Bit is set */ 12539 12540 fis->h.command = SAT_SET_FEATURES; /* 0xEF */ 12541 fis->h.features = 0xAA; /* enable read look-ahead */ 12542 fis->d.lbaLow = 0; /* */ 12543 fis->d.lbaMid = 0; /* */ 12544 fis->d.lbaHigh = 0; /* */ 12545 fis->d.device = 0; /* */ 12546 fis->d.lbaLowExp = 0; /* */ 12547 fis->d.lbaMidExp = 0; /* */ 12548 fis->d.lbaHighExp = 0; /* */ 12549 fis->d.featuresExp = 0; /* */ 12550 fis->d.sectorCount = 0; /* */ 12551 fis->d.sectorCountExp = 0; /* */ 12552 fis->d.reserved4 = 0; 12553 fis->d.control = 0; /* FIS HOB bit clear */ 12554 fis->d.reserved5 = 0; 12555 12556 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 12557 12558 /* Initialize CB for SATA completion. 12559 */ 12560 satIOContext->satCompleteCB = &satModeSelect6n10CB; 12561 12562 /* 12563 * Prepare SGL and send FIS to LL layer. 12564 */ 12565 satIOContext->reqType = agRequestType; /* Save it */ 12566 12567 status = sataLLIOStart( tiRoot, 12568 tiIORequest, 12569 tiDeviceHandle, 12570 tiScsiRequest, 12571 satIOContext); 12572 return status; 12573 } 12574 else 12575 { 12576 TI_DBG5(("satModeSelect6_1: disable read look-ahead feature\n")); 12577 /* sends SET FEATURES */ 12578 fis->h.fisType = 0x27; /* Reg host to device */ 12579 fis->h.c_pmPort = 0x80; /* C Bit is set */ 12580 12581 fis->h.command = SAT_SET_FEATURES; /* 0xEF */ 12582 fis->h.features = 0x55; /* disable read look-ahead */ 12583 fis->d.lbaLow = 0; /* */ 12584 fis->d.lbaMid = 0; /* */ 12585 fis->d.lbaHigh = 0; /* */ 12586 fis->d.device = 0; /* */ 12587 fis->d.lbaLowExp = 0; /* */ 12588 fis->d.lbaMidExp = 0; /* */ 12589 fis->d.lbaHighExp = 0; /* */ 12590 fis->d.featuresExp = 0; /* */ 12591 fis->d.sectorCount = 0; /* */ 12592 fis->d.sectorCountExp = 0; /* */ 12593 fis->d.reserved4 = 0; 12594 fis->d.control = 0; /* FIS HOB bit clear */ 12595 fis->d.reserved5 = 0; 12596 12597 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 12598 12599 /* Initialize CB for SATA completion. 12600 */ 12601 satIOContext->satCompleteCB = &satModeSelect6n10CB; 12602 12603 /* 12604 * Prepare SGL and send FIS to LL layer. 12605 */ 12606 satIOContext->reqType = agRequestType; /* Save it */ 12607 12608 status = sataLLIOStart( tiRoot, 12609 tiIORequest, 12610 tiDeviceHandle, 12611 tiScsiRequest, 12612 satIOContext); 12613 return status; 12614 } 12615 12616 } 12617 12618 12619 /*****************************************************************************/ 12620 /*! \brief SAT implementation for SCSI satModeSelect10. 12621 * 12622 * SAT implementation for SCSI satModeSelect10. 12623 * 12624 * \param tiRoot: Pointer to TISA initiator driver/port instance. 12625 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 12626 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 12627 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 12628 * \param satIOContext_t: Pointer to the SAT IO Context 12629 * 12630 * \return If command is started successfully 12631 * - \e tiSuccess: I/O request successfully initiated. 12632 * - \e tiBusy: No resources available, try again later. 12633 * - \e tiIONoDevice: Invalid device handle. 12634 * - \e tiError: Other errors. 12635 */ 12636 /*****************************************************************************/ 12637 GLOBAL bit32 satModeSelect10( 12638 tiRoot_t *tiRoot, 12639 tiIORequest_t *tiIORequest, 12640 tiDeviceHandle_t *tiDeviceHandle, 12641 tiScsiInitiatorRequest_t *tiScsiRequest, 12642 satIOContext_t *satIOContext) 12643 { 12644 bit32 status; 12645 bit32 agRequestType; 12646 satDeviceData_t *pSatDevData; 12647 scsiRspSense_t *pSense; 12648 tiIniScsiCmnd_t *scsiCmnd; 12649 agsaFisRegHostToDevice_t *fis; 12650 bit8 *pLogPage; /* Log Page data buffer */ 12651 bit16 BlkDescLen = 0; /* Block Descriptor Length */ 12652 bit32 StartingIndex = 0; 12653 bit8 PageCode = 0; 12654 bit32 chkCnd = agFALSE; 12655 12656 pSense = satIOContext->pSense; 12657 pSatDevData = satIOContext->pSatDevData; 12658 scsiCmnd = &tiScsiRequest->scsiCmnd; 12659 fis = satIOContext->pFis; 12660 pLogPage = (bit8 *) tiScsiRequest->sglVirtualAddr; 12661 12662 TI_DBG5(("satModeSelect10: start\n")); 12663 12664 /* checking CONTROL */ 12665 /* NACA == 1 or LINK == 1*/ 12666 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 12667 { 12668 satSetSensePayload( pSense, 12669 SCSI_SNSKEY_ILLEGAL_REQUEST, 12670 0, 12671 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 12672 satIOContext); 12673 12674 ostiInitiatorIOCompleted( tiRoot, 12675 tiIORequest, 12676 tiIOSuccess, 12677 SCSI_STAT_CHECK_CONDITION, 12678 satIOContext->pTiSenseData, 12679 satIOContext->interruptContext ); 12680 12681 TI_DBG2(("satModeSelect10: return control\n")); 12682 return tiSuccess; 12683 } 12684 12685 /* checking PF bit */ 12686 if ( !(scsiCmnd->cdb[1] & SCSI_MODE_SELECT10_PF_MASK)) 12687 { 12688 satSetSensePayload( pSense, 12689 SCSI_SNSKEY_ILLEGAL_REQUEST, 12690 0, 12691 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 12692 satIOContext); 12693 12694 ostiInitiatorIOCompleted( tiRoot, 12695 tiIORequest, 12696 tiIOSuccess, 12697 SCSI_STAT_CHECK_CONDITION, 12698 satIOContext->pTiSenseData, 12699 satIOContext->interruptContext ); 12700 12701 TI_DBG1(("satModeSelect10: PF bit check \n")); 12702 return tiSuccess; 12703 12704 } 12705 12706 BlkDescLen = (bit8)((pLogPage[6] << 8) + pLogPage[7]); 12707 12708 /* checking Block Descriptor Length on Mode parameter header(10) and LONGLBA bit*/ 12709 if ( (BlkDescLen == 8) && !(pLogPage[4] & SCSI_MODE_SELECT10_LONGLBA_MASK) ) 12710 { 12711 /* mode parameter block descriptor exists and length is 8 byte */ 12712 PageCode = (bit8)(pLogPage[16] & 0x3F); /* page code and index is 8 + 8 */ 12713 StartingIndex = 16; 12714 } 12715 else if ( (BlkDescLen == 16) && (pLogPage[4] & SCSI_MODE_SELECT10_LONGLBA_MASK) ) 12716 { 12717 /* mode parameter block descriptor exists and length is 16 byte */ 12718 PageCode = (bit8)(pLogPage[24] & 0x3F); /* page code and index is 8 + 16 */ 12719 StartingIndex = 24; 12720 } 12721 else if (BlkDescLen == 0) 12722 { 12723 /* 12724 mode parameter block descriptor does not exist 12725 */ 12726 PageCode = (bit8)(pLogPage[8] & 0x3F); /* page code and index is 8 + 0 */ 12727 StartingIndex = 8; 12728 ostiInitiatorIOCompleted( tiRoot, 12729 tiIORequest, 12730 tiIOSuccess, 12731 SCSI_STAT_GOOD, 12732 agNULL, 12733 satIOContext->interruptContext); 12734 return tiSuccess; 12735 } 12736 else 12737 { 12738 TI_DBG1(("satModeSelect10: return mode parameter block descriptor 0x%x\n", BlkDescLen)); 12739 /* no more than one mode parameter block descriptor shall be supported */ 12740 satSetSensePayload( pSense, 12741 SCSI_SNSKEY_NO_SENSE, 12742 0, 12743 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 12744 satIOContext); 12745 12746 ostiInitiatorIOCompleted( tiRoot, 12747 tiIORequest, 12748 tiIOSuccess, 12749 SCSI_STAT_CHECK_CONDITION, 12750 satIOContext->pTiSenseData, 12751 satIOContext->interruptContext ); 12752 return tiSuccess; 12753 } 12754 /* 12755 for debugging only 12756 */ 12757 if (StartingIndex == 8) 12758 { 12759 tdhexdump("startingindex 8", (bit8 *)pLogPage, 8); 12760 } 12761 else if(StartingIndex == 16) 12762 { 12763 if (PageCode == MODESELECT_CACHING) 12764 { 12765 tdhexdump("startingindex 16", (bit8 *)pLogPage, 16+20); 12766 } 12767 else 12768 { 12769 tdhexdump("startingindex 16", (bit8 *)pLogPage, 16+12); 12770 } 12771 } 12772 else 12773 { 12774 if (PageCode == MODESELECT_CACHING) 12775 { 12776 tdhexdump("startingindex 24", (bit8 *)pLogPage, 24+20); 12777 } 12778 else 12779 { 12780 tdhexdump("startingindex 24", (bit8 *)pLogPage, 24+12); 12781 } 12782 } 12783 switch (PageCode) /* page code */ 12784 { 12785 case MODESELECT_CONTROL_PAGE: 12786 TI_DBG5(("satModeSelect10: Control mode page\n")); 12787 /* 12788 compare pLogPage to expected value (SAT Table 65, p67) 12789 If not match, return check condition 12790 */ 12791 if ( pLogPage[StartingIndex+1] != 0x0A || 12792 pLogPage[StartingIndex+2] != 0x02 || 12793 (pSatDevData->satNCQ == agTRUE && pLogPage[StartingIndex+3] != 0x12) || 12794 (pSatDevData->satNCQ == agFALSE && pLogPage[StartingIndex+3] != 0x02) || 12795 (pLogPage[StartingIndex+4] & BIT3_MASK) != 0x00 || /* SWP bit */ 12796 (pLogPage[StartingIndex+4] & BIT4_MASK) != 0x00 || /* UA_INTLCK_CTRL */ 12797 (pLogPage[StartingIndex+4] & BIT5_MASK) != 0x00 || /* UA_INTLCK_CTRL */ 12798 12799 (pLogPage[StartingIndex+5] & BIT0_MASK) != 0x00 || /* AUTOLOAD MODE */ 12800 (pLogPage[StartingIndex+5] & BIT1_MASK) != 0x00 || /* AUTOLOAD MODE */ 12801 (pLogPage[StartingIndex+5] & BIT2_MASK) != 0x00 || /* AUTOLOAD MODE */ 12802 (pLogPage[StartingIndex+5] & BIT6_MASK) != 0x00 || /* TAS bit */ 12803 12804 pLogPage[StartingIndex+8] != 0xFF || 12805 pLogPage[StartingIndex+9] != 0xFF || 12806 pLogPage[StartingIndex+10] != 0x00 || 12807 pLogPage[StartingIndex+11] != 0x00 12808 ) 12809 { 12810 chkCnd = agTRUE; 12811 } 12812 if (chkCnd == agTRUE) 12813 { 12814 satSetSensePayload( pSense, 12815 SCSI_SNSKEY_ILLEGAL_REQUEST, 12816 0, 12817 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 12818 satIOContext); 12819 12820 ostiInitiatorIOCompleted( tiRoot, 12821 tiIORequest, 12822 tiIOSuccess, 12823 SCSI_STAT_CHECK_CONDITION, 12824 satIOContext->pTiSenseData, 12825 satIOContext->interruptContext ); 12826 12827 TI_DBG1(("satModeSelect10: unexpected values\n")); 12828 } 12829 else 12830 { 12831 ostiInitiatorIOCompleted( tiRoot, 12832 tiIORequest, 12833 tiIOSuccess, 12834 SCSI_STAT_GOOD, 12835 agNULL, 12836 satIOContext->interruptContext); 12837 } 12838 return tiSuccess; 12839 break; 12840 case MODESELECT_READ_WRITE_ERROR_RECOVERY_PAGE: 12841 TI_DBG5(("satModeSelect10: Read-Write Error Recovery mode page\n")); 12842 if ( (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT10_AWRE_MASK) || 12843 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT10_RC_MASK) || 12844 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT10_EER_MASK) || 12845 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT10_PER_MASK) || 12846 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT10_DTE_MASK) || 12847 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT10_DCR_MASK) || 12848 (pLogPage[StartingIndex + 10]) || 12849 (pLogPage[StartingIndex + 11]) 12850 ) 12851 { 12852 TI_DBG1(("satModeSelect10: return check condition \n")); 12853 12854 satSetSensePayload( pSense, 12855 SCSI_SNSKEY_ILLEGAL_REQUEST, 12856 0, 12857 SCSI_SNSCODE_INVALID_FIELD_PARAMETER_LIST, 12858 satIOContext); 12859 12860 ostiInitiatorIOCompleted( tiRoot, 12861 tiIORequest, 12862 tiIOSuccess, 12863 SCSI_STAT_CHECK_CONDITION, 12864 satIOContext->pTiSenseData, 12865 satIOContext->interruptContext ); 12866 return tiSuccess; 12867 } 12868 else 12869 { 12870 TI_DBG2(("satModeSelect10: return GOOD \n")); 12871 ostiInitiatorIOCompleted( tiRoot, 12872 tiIORequest, 12873 tiIOSuccess, 12874 SCSI_STAT_GOOD, 12875 agNULL, 12876 satIOContext->interruptContext); 12877 return tiSuccess; 12878 } 12879 12880 break; 12881 case MODESELECT_CACHING: 12882 /* SAT rev8 Table67, p69*/ 12883 TI_DBG5(("satModeSelect10: Caching mode page\n")); 12884 if ( (pLogPage[StartingIndex + 2] & 0xFB) || /* 1111 1011 */ 12885 (pLogPage[StartingIndex + 3]) || 12886 (pLogPage[StartingIndex + 4]) || 12887 (pLogPage[StartingIndex + 5]) || 12888 (pLogPage[StartingIndex + 6]) || 12889 (pLogPage[StartingIndex + 7]) || 12890 (pLogPage[StartingIndex + 8]) || 12891 (pLogPage[StartingIndex + 9]) || 12892 (pLogPage[StartingIndex + 10]) || 12893 (pLogPage[StartingIndex + 11]) || 12894 12895 (pLogPage[StartingIndex + 12] & 0xC1) || /* 1100 0001 */ 12896 (pLogPage[StartingIndex + 13]) || 12897 (pLogPage[StartingIndex + 14]) || 12898 (pLogPage[StartingIndex + 15]) 12899 ) 12900 { 12901 TI_DBG1(("satModeSelect10: return check condition \n")); 12902 12903 satSetSensePayload( pSense, 12904 SCSI_SNSKEY_ILLEGAL_REQUEST, 12905 0, 12906 SCSI_SNSCODE_INVALID_FIELD_PARAMETER_LIST, 12907 satIOContext); 12908 12909 ostiInitiatorIOCompleted( tiRoot, 12910 tiIORequest, 12911 tiIOSuccess, 12912 SCSI_STAT_CHECK_CONDITION, 12913 satIOContext->pTiSenseData, 12914 satIOContext->interruptContext ); 12915 return tiSuccess; 12916 12917 } 12918 else 12919 { 12920 /* sends ATA SET FEATURES based on WCE bit */ 12921 if ( !(pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT10_WCE_MASK) ) 12922 { 12923 TI_DBG5(("satModeSelect10: disable write cache\n")); 12924 /* sends SET FEATURES */ 12925 fis->h.fisType = 0x27; /* Reg host to device */ 12926 fis->h.c_pmPort = 0x80; /* C Bit is set */ 12927 12928 fis->h.command = SAT_SET_FEATURES; /* 0xEF */ 12929 fis->h.features = 0x82; /* disable write cache */ 12930 fis->d.lbaLow = 0; /* */ 12931 fis->d.lbaMid = 0; /* */ 12932 fis->d.lbaHigh = 0; /* */ 12933 fis->d.device = 0; /* */ 12934 fis->d.lbaLowExp = 0; /* */ 12935 fis->d.lbaMidExp = 0; /* */ 12936 fis->d.lbaHighExp = 0; /* */ 12937 fis->d.featuresExp = 0; /* */ 12938 fis->d.sectorCount = 0; /* */ 12939 fis->d.sectorCountExp = 0; /* */ 12940 fis->d.reserved4 = 0; 12941 fis->d.control = 0; /* FIS HOB bit clear */ 12942 fis->d.reserved5 = 0; 12943 12944 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 12945 12946 /* Initialize CB for SATA completion. 12947 */ 12948 satIOContext->satCompleteCB = &satModeSelect6n10CB; 12949 12950 /* 12951 * Prepare SGL and send FIS to LL layer. 12952 */ 12953 satIOContext->reqType = agRequestType; /* Save it */ 12954 12955 status = sataLLIOStart( tiRoot, 12956 tiIORequest, 12957 tiDeviceHandle, 12958 tiScsiRequest, 12959 satIOContext); 12960 return status; 12961 } 12962 else 12963 { 12964 TI_DBG5(("satModeSelect10: enable write cache\n")); 12965 /* sends SET FEATURES */ 12966 fis->h.fisType = 0x27; /* Reg host to device */ 12967 fis->h.c_pmPort = 0x80; /* C Bit is set */ 12968 12969 fis->h.command = SAT_SET_FEATURES; /* 0xEF */ 12970 fis->h.features = 0x02; /* enable write cache */ 12971 fis->d.lbaLow = 0; /* */ 12972 fis->d.lbaMid = 0; /* */ 12973 fis->d.lbaHigh = 0; /* */ 12974 fis->d.device = 0; /* */ 12975 fis->d.lbaLowExp = 0; /* */ 12976 fis->d.lbaMidExp = 0; /* */ 12977 fis->d.lbaHighExp = 0; /* */ 12978 fis->d.featuresExp = 0; /* */ 12979 fis->d.sectorCount = 0; /* */ 12980 fis->d.sectorCountExp = 0; /* */ 12981 fis->d.reserved4 = 0; 12982 fis->d.control = 0; /* FIS HOB bit clear */ 12983 fis->d.reserved5 = 0; 12984 12985 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 12986 12987 /* Initialize CB for SATA completion. 12988 */ 12989 satIOContext->satCompleteCB = &satModeSelect6n10CB; 12990 12991 /* 12992 * Prepare SGL and send FIS to LL layer. 12993 */ 12994 satIOContext->reqType = agRequestType; /* Save it */ 12995 12996 status = sataLLIOStart( tiRoot, 12997 tiIORequest, 12998 tiDeviceHandle, 12999 tiScsiRequest, 13000 satIOContext); 13001 return status; 13002 13003 } 13004 } 13005 break; 13006 case MODESELECT_INFORMATION_EXCEPTION_CONTROL_PAGE: 13007 TI_DBG5(("satModeSelect10: Informational Exception Control mode page\n")); 13008 13009 if ( (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT10_PERF_MASK) || 13010 (pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT10_TEST_MASK) 13011 ) 13012 { 13013 TI_DBG1(("satModeSelect10: return check condition \n")); 13014 13015 satSetSensePayload( pSense, 13016 SCSI_SNSKEY_ILLEGAL_REQUEST, 13017 0, 13018 SCSI_SNSCODE_INVALID_FIELD_PARAMETER_LIST, 13019 satIOContext); 13020 13021 ostiInitiatorIOCompleted( tiRoot, 13022 tiIORequest, 13023 tiIOSuccess, 13024 SCSI_STAT_CHECK_CONDITION, 13025 satIOContext->pTiSenseData, 13026 satIOContext->interruptContext ); 13027 return tiSuccess; 13028 } 13029 else 13030 { 13031 /* sends either ATA SMART ENABLE/DISABLE OPERATIONS based on DEXCPT bit */ 13032 if ( !(pLogPage[StartingIndex + 2] & SCSI_MODE_SELECT10_DEXCPT_MASK) ) 13033 { 13034 TI_DBG5(("satModeSelect10: enable information exceptions reporting\n")); 13035 /* sends SMART ENABLE OPERATIONS */ 13036 fis->h.fisType = 0x27; /* Reg host to device */ 13037 fis->h.c_pmPort = 0x80; /* C Bit is set */ 13038 13039 fis->h.command = SAT_SMART_ENABLE_OPERATIONS; /* 0xB0 */ 13040 fis->h.features = 0xD8; /* enable */ 13041 fis->d.lbaLow = 0; /* */ 13042 fis->d.lbaMid = 0x4F; /* 0x4F */ 13043 fis->d.lbaHigh = 0xC2; /* 0xC2 */ 13044 fis->d.device = 0; /* */ 13045 fis->d.lbaLowExp = 0; /* */ 13046 fis->d.lbaMidExp = 0; /* */ 13047 fis->d.lbaHighExp = 0; /* */ 13048 fis->d.featuresExp = 0; /* */ 13049 fis->d.sectorCount = 0; /* */ 13050 fis->d.sectorCountExp = 0; /* */ 13051 fis->d.reserved4 = 0; 13052 fis->d.control = 0; /* FIS HOB bit clear */ 13053 fis->d.reserved5 = 0; 13054 13055 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 13056 13057 /* Initialize CB for SATA completion. 13058 */ 13059 satIOContext->satCompleteCB = &satModeSelect6n10CB; 13060 13061 /* 13062 * Prepare SGL and send FIS to LL layer. 13063 */ 13064 satIOContext->reqType = agRequestType; /* Save it */ 13065 13066 status = sataLLIOStart( tiRoot, 13067 tiIORequest, 13068 tiDeviceHandle, 13069 tiScsiRequest, 13070 satIOContext); 13071 return status; 13072 } 13073 else 13074 { 13075 TI_DBG5(("satModeSelect10: disable information exceptions reporting\n")); 13076 /* sends SMART DISABLE OPERATIONS */ 13077 fis->h.fisType = 0x27; /* Reg host to device */ 13078 fis->h.c_pmPort = 0x80; /* C Bit is set */ 13079 13080 fis->h.command = SAT_SMART_DISABLE_OPERATIONS; /* 0xB0 */ 13081 fis->h.features = 0xD9; /* disable */ 13082 fis->d.lbaLow = 0; /* */ 13083 fis->d.lbaMid = 0x4F; /* 0x4F */ 13084 fis->d.lbaHigh = 0xC2; /* 0xC2 */ 13085 fis->d.device = 0; /* */ 13086 fis->d.lbaLowExp = 0; /* */ 13087 fis->d.lbaMidExp = 0; /* */ 13088 fis->d.lbaHighExp = 0; /* */ 13089 fis->d.featuresExp = 0; /* */ 13090 fis->d.sectorCount = 0; /* */ 13091 fis->d.sectorCountExp = 0; /* */ 13092 fis->d.reserved4 = 0; 13093 fis->d.control = 0; /* FIS HOB bit clear */ 13094 fis->d.reserved5 = 0; 13095 13096 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 13097 13098 /* Initialize CB for SATA completion. 13099 */ 13100 satIOContext->satCompleteCB = &satModeSelect6n10CB; 13101 13102 /* 13103 * Prepare SGL and send FIS to LL layer. 13104 */ 13105 satIOContext->reqType = agRequestType; /* Save it */ 13106 13107 status = sataLLIOStart( tiRoot, 13108 tiIORequest, 13109 tiDeviceHandle, 13110 tiScsiRequest, 13111 satIOContext); 13112 return status; 13113 13114 } 13115 } 13116 break; 13117 default: 13118 TI_DBG1(("satModeSelect10: Error unknown page code 0x%x\n", pLogPage[12])); 13119 satSetSensePayload( pSense, 13120 SCSI_SNSKEY_NO_SENSE, 13121 0, 13122 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 13123 satIOContext); 13124 13125 ostiInitiatorIOCompleted( tiRoot, 13126 tiIORequest, 13127 tiIOSuccess, 13128 SCSI_STAT_CHECK_CONDITION, 13129 satIOContext->pTiSenseData, 13130 satIOContext->interruptContext ); 13131 return tiSuccess; 13132 } 13133 13134 } 13135 13136 13137 /*****************************************************************************/ 13138 /*! \brief SAT implementation for SCSI satSynchronizeCache10. 13139 * 13140 * SAT implementation for SCSI satSynchronizeCache10. 13141 * 13142 * \param tiRoot: Pointer to TISA initiator driver/port instance. 13143 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 13144 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 13145 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 13146 * \param satIOContext_t: Pointer to the SAT IO Context 13147 * 13148 * \return If command is started successfully 13149 * - \e tiSuccess: I/O request successfully initiated. 13150 * - \e tiBusy: No resources available, try again later. 13151 * - \e tiIONoDevice: Invalid device handle. 13152 * - \e tiError: Other errors. 13153 */ 13154 /*****************************************************************************/ 13155 GLOBAL bit32 satSynchronizeCache10( 13156 tiRoot_t *tiRoot, 13157 tiIORequest_t *tiIORequest, 13158 tiDeviceHandle_t *tiDeviceHandle, 13159 tiScsiInitiatorRequest_t *tiScsiRequest, 13160 satIOContext_t *satIOContext) 13161 { 13162 bit32 status; 13163 bit32 agRequestType; 13164 satDeviceData_t *pSatDevData; 13165 scsiRspSense_t *pSense; 13166 tiIniScsiCmnd_t *scsiCmnd; 13167 agsaFisRegHostToDevice_t *fis; 13168 13169 pSense = satIOContext->pSense; 13170 pSatDevData = satIOContext->pSatDevData; 13171 scsiCmnd = &tiScsiRequest->scsiCmnd; 13172 fis = satIOContext->pFis; 13173 13174 TI_DBG5(("satSynchronizeCache10: start\n")); 13175 13176 /* checking CONTROL */ 13177 /* NACA == 1 or LINK == 1*/ 13178 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 13179 { 13180 satSetSensePayload( pSense, 13181 SCSI_SNSKEY_ILLEGAL_REQUEST, 13182 0, 13183 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 13184 satIOContext); 13185 13186 ostiInitiatorIOCompleted( tiRoot, 13187 tiIORequest, 13188 tiIOSuccess, 13189 SCSI_STAT_CHECK_CONDITION, 13190 satIOContext->pTiSenseData, 13191 satIOContext->interruptContext ); 13192 13193 TI_DBG2(("satSynchronizeCache10: return control\n")); 13194 return tiSuccess; 13195 } 13196 13197 /* checking IMMED bit */ 13198 if (scsiCmnd->cdb[1] & SCSI_SYNC_CACHE_IMMED_MASK) 13199 { 13200 TI_DBG1(("satSynchronizeCache10: GOOD status due to IMMED bit\n")); 13201 13202 /* return GOOD status first here */ 13203 ostiInitiatorIOCompleted( tiRoot, 13204 tiIORequest, 13205 tiIOSuccess, 13206 SCSI_STAT_GOOD, 13207 agNULL, 13208 satIOContext->interruptContext); 13209 } 13210 13211 /* sends FLUSH CACHE or FLUSH CACHE EXT */ 13212 if (pSatDevData->sat48BitSupport == agTRUE) 13213 { 13214 TI_DBG5(("satSynchronizeCache10: sends FLUSH CACHE EXT\n")); 13215 /* FLUSH CACHE EXT */ 13216 fis->h.fisType = 0x27; /* Reg host to device */ 13217 fis->h.c_pmPort = 0x80; /* C Bit is set */ 13218 13219 fis->h.command = SAT_FLUSH_CACHE_EXT; /* 0xEA */ 13220 fis->h.features = 0; /* FIS reserve */ 13221 fis->d.featuresExp = 0; /* FIS reserve */ 13222 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 13223 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 13224 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 13225 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 13226 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 13227 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 13228 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 13229 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 13230 fis->d.device = 0; /* FIS DEV is discared in SATA */ 13231 fis->d.control = 0; /* FIS HOB bit clear */ 13232 fis->d.reserved4 = 0; 13233 fis->d.reserved5 = 0; 13234 13235 } 13236 else 13237 { 13238 TI_DBG5(("satSynchronizeCache10: sends FLUSH CACHE\n")); 13239 /* FLUSH CACHE */ 13240 fis->h.fisType = 0x27; /* Reg host to device */ 13241 fis->h.c_pmPort = 0x80; /* C Bit is set */ 13242 13243 fis->h.command = SAT_FLUSH_CACHE; /* 0xE7 */ 13244 fis->h.features = 0; /* FIS features NA */ 13245 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 13246 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 13247 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 13248 fis->d.lbaLowExp = 0; 13249 fis->d.lbaMidExp = 0; 13250 fis->d.lbaHighExp = 0; 13251 fis->d.featuresExp = 0; 13252 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 13253 fis->d.sectorCountExp = 0; 13254 fis->d.device = 0; /* FIS DEV is discared in SATA */ 13255 fis->d.control = 0; /* FIS HOB bit clear */ 13256 fis->d.reserved4 = 0; 13257 fis->d.reserved5 = 0; 13258 13259 } 13260 13261 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 13262 13263 /* Initialize CB for SATA completion. 13264 */ 13265 satIOContext->satCompleteCB = &satSynchronizeCache10n16CB; 13266 13267 /* 13268 * Prepare SGL and send FIS to LL layer. 13269 */ 13270 satIOContext->reqType = agRequestType; /* Save it */ 13271 13272 status = sataLLIOStart( tiRoot, 13273 tiIORequest, 13274 tiDeviceHandle, 13275 tiScsiRequest, 13276 satIOContext); 13277 13278 13279 return (status); 13280 } 13281 13282 /*****************************************************************************/ 13283 /*! \brief SAT implementation for SCSI satSynchronizeCache16. 13284 * 13285 * SAT implementation for SCSI satSynchronizeCache16. 13286 * 13287 * \param tiRoot: Pointer to TISA initiator driver/port instance. 13288 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 13289 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 13290 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 13291 * \param satIOContext_t: Pointer to the SAT IO Context 13292 * 13293 * \return If command is started successfully 13294 * - \e tiSuccess: I/O request successfully initiated. 13295 * - \e tiBusy: No resources available, try again later. 13296 * - \e tiIONoDevice: Invalid device handle. 13297 * - \e tiError: Other errors. 13298 */ 13299 /*****************************************************************************/ 13300 GLOBAL bit32 satSynchronizeCache16( 13301 tiRoot_t *tiRoot, 13302 tiIORequest_t *tiIORequest, 13303 tiDeviceHandle_t *tiDeviceHandle, 13304 tiScsiInitiatorRequest_t *tiScsiRequest, 13305 satIOContext_t *satIOContext) 13306 { 13307 bit32 status; 13308 bit32 agRequestType; 13309 satDeviceData_t *pSatDevData; 13310 scsiRspSense_t *pSense; 13311 tiIniScsiCmnd_t *scsiCmnd; 13312 agsaFisRegHostToDevice_t *fis; 13313 13314 pSense = satIOContext->pSense; 13315 pSatDevData = satIOContext->pSatDevData; 13316 scsiCmnd = &tiScsiRequest->scsiCmnd; 13317 fis = satIOContext->pFis; 13318 13319 TI_DBG5(("satSynchronizeCache16: start\n")); 13320 13321 /* checking CONTROL */ 13322 /* NACA == 1 or LINK == 1*/ 13323 if ( (scsiCmnd->cdb[15] & SCSI_NACA_MASK) || (scsiCmnd->cdb[15] & SCSI_LINK_MASK) ) 13324 { 13325 satSetSensePayload( pSense, 13326 SCSI_SNSKEY_ILLEGAL_REQUEST, 13327 0, 13328 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 13329 satIOContext); 13330 13331 ostiInitiatorIOCompleted( tiRoot, 13332 tiIORequest, 13333 tiIOSuccess, 13334 SCSI_STAT_CHECK_CONDITION, 13335 satIOContext->pTiSenseData, 13336 satIOContext->interruptContext ); 13337 13338 TI_DBG1(("satSynchronizeCache16: return control\n")); 13339 return tiSuccess; 13340 } 13341 13342 13343 /* checking IMMED bit */ 13344 if (scsiCmnd->cdb[1] & SCSI_SYNC_CACHE_IMMED_MASK) 13345 { 13346 TI_DBG1(("satSynchronizeCache16: GOOD status due to IMMED bit\n")); 13347 13348 /* return GOOD status first here */ 13349 ostiInitiatorIOCompleted( tiRoot, 13350 tiIORequest, 13351 tiIOSuccess, 13352 SCSI_STAT_GOOD, 13353 agNULL, 13354 satIOContext->interruptContext); 13355 } 13356 13357 /* sends FLUSH CACHE or FLUSH CACHE EXT */ 13358 if (pSatDevData->sat48BitSupport == agTRUE) 13359 { 13360 TI_DBG5(("satSynchronizeCache16: sends FLUSH CACHE EXT\n")); 13361 /* FLUSH CACHE EXT */ 13362 fis->h.fisType = 0x27; /* Reg host to device */ 13363 fis->h.c_pmPort = 0x80; /* C Bit is set */ 13364 13365 fis->h.command = SAT_FLUSH_CACHE_EXT; /* 0xEA */ 13366 fis->h.features = 0; /* FIS reserve */ 13367 fis->d.featuresExp = 0; /* FIS reserve */ 13368 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 13369 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 13370 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 13371 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 13372 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 13373 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 13374 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 13375 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 13376 fis->d.device = 0; /* FIS DEV is discared in SATA */ 13377 fis->d.control = 0; /* FIS HOB bit clear */ 13378 fis->d.reserved4 = 0; 13379 fis->d.reserved5 = 0; 13380 13381 } 13382 else 13383 { 13384 TI_DBG5(("satSynchronizeCache16: sends FLUSH CACHE\n")); 13385 /* FLUSH CACHE */ 13386 fis->h.fisType = 0x27; /* Reg host to device */ 13387 fis->h.c_pmPort = 0x80; /* C Bit is set */ 13388 13389 fis->h.command = SAT_FLUSH_CACHE; /* 0xE7 */ 13390 fis->h.features = 0; /* FIS features NA */ 13391 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 13392 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 13393 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 13394 fis->d.lbaLowExp = 0; 13395 fis->d.lbaMidExp = 0; 13396 fis->d.lbaHighExp = 0; 13397 fis->d.featuresExp = 0; 13398 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 13399 fis->d.sectorCountExp = 0; 13400 fis->d.device = 0; /* FIS DEV is discared in SATA */ 13401 fis->d.control = 0; /* FIS HOB bit clear */ 13402 fis->d.reserved4 = 0; 13403 fis->d.reserved5 = 0; 13404 13405 } 13406 13407 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 13408 13409 /* Initialize CB for SATA completion. 13410 */ 13411 satIOContext->satCompleteCB = &satSynchronizeCache10n16CB; 13412 13413 /* 13414 * Prepare SGL and send FIS to LL layer. 13415 */ 13416 satIOContext->reqType = agRequestType; /* Save it */ 13417 13418 status = sataLLIOStart( tiRoot, 13419 tiIORequest, 13420 tiDeviceHandle, 13421 tiScsiRequest, 13422 satIOContext); 13423 13424 13425 return (status); 13426 } 13427 13428 13429 /*****************************************************************************/ 13430 /*! \brief SAT implementation for SCSI satWriteAndVerify10. 13431 * 13432 * SAT implementation for SCSI satWriteAndVerify10. 13433 * 13434 * \param tiRoot: Pointer to TISA initiator driver/port instance. 13435 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 13436 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 13437 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 13438 * \param satIOContext_t: Pointer to the SAT IO Context 13439 * 13440 * \return If command is started successfully 13441 * - \e tiSuccess: I/O request successfully initiated. 13442 * - \e tiBusy: No resources available, try again later. 13443 * - \e tiIONoDevice: Invalid device handle. 13444 * - \e tiError: Other errors. 13445 */ 13446 /*****************************************************************************/ 13447 GLOBAL bit32 satWriteAndVerify10( 13448 tiRoot_t *tiRoot, 13449 tiIORequest_t *tiIORequest, 13450 tiDeviceHandle_t *tiDeviceHandle, 13451 tiScsiInitiatorRequest_t *tiScsiRequest, 13452 satIOContext_t *satIOContext) 13453 { 13454 /* 13455 combination of write10 and verify10 13456 */ 13457 13458 bit32 status; 13459 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 13460 satDeviceData_t *pSatDevData; 13461 scsiRspSense_t *pSense; 13462 tiIniScsiCmnd_t *scsiCmnd; 13463 agsaFisRegHostToDevice_t *fis; 13464 bit32 lba = 0; 13465 bit32 tl = 0; 13466 bit32 LoopNum = 1; 13467 bit8 LBA[4]; 13468 bit8 TL[4]; 13469 bit32 rangeChk = agFALSE; /* lba and tl range check */ 13470 13471 pSense = satIOContext->pSense; 13472 pSatDevData = satIOContext->pSatDevData; 13473 scsiCmnd = &tiScsiRequest->scsiCmnd; 13474 fis = satIOContext->pFis; 13475 13476 TI_DBG5(("satWriteAndVerify10: start\n")); 13477 13478 13479 /* checking BYTCHK bit */ 13480 if (scsiCmnd->cdb[1] & SCSI_WRITE_N_VERIFY_BYTCHK_MASK) 13481 { 13482 satSetSensePayload( pSense, 13483 SCSI_SNSKEY_ILLEGAL_REQUEST, 13484 0, 13485 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 13486 satIOContext); 13487 13488 ostiInitiatorIOCompleted( tiRoot, 13489 tiIORequest, 13490 tiIOSuccess, 13491 SCSI_STAT_CHECK_CONDITION, 13492 satIOContext->pTiSenseData, 13493 satIOContext->interruptContext ); 13494 13495 TI_DBG1(("satWriteAndVerify10: BYTCHK bit checking \n")); 13496 return tiSuccess; 13497 } 13498 13499 13500 /* checking CONTROL */ 13501 /* NACA == 1 or LINK == 1*/ 13502 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 13503 { 13504 satSetSensePayload( pSense, 13505 SCSI_SNSKEY_ILLEGAL_REQUEST, 13506 0, 13507 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 13508 satIOContext); 13509 13510 ostiInitiatorIOCompleted( tiRoot, 13511 tiIORequest, 13512 tiIOSuccess, 13513 SCSI_STAT_CHECK_CONDITION, 13514 satIOContext->pTiSenseData, 13515 satIOContext->interruptContext ); 13516 13517 TI_DBG1(("satWriteAndVerify10: return control\n")); 13518 return tiSuccess; 13519 } 13520 13521 osti_memset(LBA, 0, sizeof(LBA)); 13522 osti_memset(TL, 0, sizeof(TL)); 13523 13524 /* do not use memcpy due to indexing in LBA and TL */ 13525 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 13526 LBA[1] = scsiCmnd->cdb[3]; 13527 LBA[2] = scsiCmnd->cdb[4]; 13528 LBA[3] = scsiCmnd->cdb[5]; /* LSB */ 13529 13530 TL[0] = 0; 13531 TL[1] = 0; 13532 TL[2] = scsiCmnd->cdb[7]; /* MSB */ 13533 TL[3] = scsiCmnd->cdb[8]; /* LSB */ 13534 13535 rangeChk = satAddNComparebit32(LBA, TL); 13536 13537 /* cbd10; computing LBA and transfer length */ 13538 lba = (scsiCmnd->cdb[2] << (8*3)) + (scsiCmnd->cdb[3] << (8*2)) 13539 + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 13540 tl = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 13541 13542 13543 /* Table 34, 9.1, p 46 */ 13544 /* 13545 note: As of 2/10/2006, no support for DMA QUEUED 13546 */ 13547 13548 /* 13549 Table 34, 9.1, p 46, b 13550 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 13551 return check condition 13552 */ 13553 if (pSatDevData->satNCQ != agTRUE && 13554 pSatDevData->sat48BitSupport != agTRUE 13555 ) 13556 { 13557 if (lba > SAT_TR_LBA_LIMIT - 1) 13558 { 13559 satSetSensePayload( pSense, 13560 SCSI_SNSKEY_ILLEGAL_REQUEST, 13561 0, 13562 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 13563 satIOContext); 13564 13565 ostiInitiatorIOCompleted( tiRoot, 13566 tiIORequest, 13567 tiIOSuccess, 13568 SCSI_STAT_CHECK_CONDITION, 13569 satIOContext->pTiSenseData, 13570 satIOContext->interruptContext ); 13571 13572 TI_DBG1(("satWriteAndVerify10: return LBA out of range\n")); 13573 return tiSuccess; 13574 } 13575 13576 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 13577 { 13578 TI_DBG1(("satWrite10: return LBA+TL out of range, not EXT\n")); 13579 satSetSensePayload( pSense, 13580 SCSI_SNSKEY_ILLEGAL_REQUEST, 13581 0, 13582 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 13583 satIOContext); 13584 13585 ostiInitiatorIOCompleted( tiRoot, 13586 tiIORequest, 13587 tiIOSuccess, 13588 SCSI_STAT_CHECK_CONDITION, 13589 satIOContext->pTiSenseData, 13590 satIOContext->interruptContext ); 13591 13592 return tiSuccess; 13593 } 13594 } 13595 13596 13597 /* case 1 and 2 */ 13598 if (!rangeChk) // if (lba + tl <= SAT_TR_LBA_LIMIT) 13599 { 13600 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 13601 { 13602 /* case 2 */ 13603 /* WRITE DMA*/ 13604 /* can't fit the transfer length */ 13605 TI_DBG5(("satWriteAndVerify10: case 2 !!!\n")); 13606 fis->h.fisType = 0x27; /* Reg host to device */ 13607 fis->h.c_pmPort = 0x80; /* C bit is set */ 13608 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 13609 fis->h.features = 0; /* FIS reserve */ 13610 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 13611 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 13612 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 13613 13614 /* FIS LBA mode set LBA (27:24) */ 13615 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 13616 13617 fis->d.lbaLowExp = 0; 13618 fis->d.lbaMidExp = 0; 13619 fis->d.lbaHighExp = 0; 13620 fis->d.featuresExp = 0; 13621 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 13622 fis->d.sectorCountExp = 0; 13623 fis->d.reserved4 = 0; 13624 fis->d.control = 0; /* FIS HOB bit clear */ 13625 fis->d.reserved5 = 0; 13626 13627 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 13628 satIOContext->ATACmd = SAT_WRITE_DMA; 13629 } 13630 else 13631 { 13632 /* case 1 */ 13633 /* WRITE MULTIPLE or WRITE SECTOR(S) */ 13634 /* WRITE SECTORS for easier implemetation */ 13635 /* can't fit the transfer length */ 13636 TI_DBG5(("satWriteAndVerify10: case 1 !!!\n")); 13637 fis->h.fisType = 0x27; /* Reg host to device */ 13638 fis->h.c_pmPort = 0x80; /* C bit is set */ 13639 fis->h.command = SAT_WRITE_SECTORS; /* 0x30 */ 13640 fis->h.features = 0; /* FIS reserve */ 13641 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 13642 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 13643 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 13644 13645 /* FIS LBA mode set LBA (27:24) */ 13646 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 13647 13648 fis->d.lbaLowExp = 0; 13649 fis->d.lbaMidExp = 0; 13650 fis->d.lbaHighExp = 0; 13651 fis->d.featuresExp = 0; 13652 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 13653 fis->d.sectorCountExp = 0; 13654 fis->d.reserved4 = 0; 13655 fis->d.control = 0; /* FIS HOB bit clear */ 13656 fis->d.reserved5 = 0; 13657 13658 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 13659 satIOContext->ATACmd = SAT_WRITE_SECTORS; 13660 13661 } 13662 } 13663 13664 /* case 3 and 4 */ 13665 if (pSatDevData->sat48BitSupport == agTRUE) 13666 { 13667 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 13668 { 13669 /* case 3 */ 13670 /* WRITE DMA EXT or WRITE DMA FUA EXT */ 13671 TI_DBG5(("satWriteAndVerify10: case 3\n")); 13672 fis->h.fisType = 0x27; /* Reg host to device */ 13673 fis->h.c_pmPort = 0x80; /* C Bit is set */ 13674 13675 /* SAT_WRITE_DMA_FUA_EXT is optional and we don't support it */ 13676 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 13677 13678 fis->h.features = 0; /* FIS reserve */ 13679 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 13680 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 13681 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 13682 fis->d.device = 0x40; /* FIS LBA mode set */ 13683 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 13684 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 13685 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 13686 fis->d.featuresExp = 0; /* FIS reserve */ 13687 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 13688 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 13689 fis->d.reserved4 = 0; 13690 fis->d.control = 0; /* FIS HOB bit clear */ 13691 fis->d.reserved5 = 0; 13692 13693 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 13694 satIOContext->ATACmd = SAT_WRITE_DMA_EXT; 13695 } 13696 else 13697 { 13698 /* case 4 */ 13699 /* WRITE MULTIPLE EXT or WRITE MULTIPLE FUA EXT or WRITE SECTOR(S) EXT */ 13700 /* WRITE SECTORS EXT for easier implemetation */ 13701 TI_DBG5(("satWriteAndVerify10: case 4\n")); 13702 fis->h.fisType = 0x27; /* Reg host to device */ 13703 fis->h.c_pmPort = 0x80; /* C Bit is set */ 13704 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 13705 13706 fis->h.features = 0; /* FIS reserve */ 13707 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 13708 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 13709 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 13710 fis->d.device = 0x40; /* FIS LBA mode set */ 13711 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 13712 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 13713 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 13714 fis->d.featuresExp = 0; /* FIS reserve */ 13715 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 13716 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 13717 fis->d.reserved4 = 0; 13718 fis->d.control = 0; /* FIS HOB bit clear */ 13719 fis->d.reserved5 = 0; 13720 13721 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 13722 satIOContext->ATACmd = SAT_WRITE_SECTORS_EXT; 13723 } 13724 } 13725 /* case 5 */ 13726 if (pSatDevData->satNCQ == agTRUE) 13727 { 13728 /* WRITE FPDMA QUEUED */ 13729 if (pSatDevData->sat48BitSupport != agTRUE) 13730 { 13731 TI_DBG5(("satWriteAndVerify10: case 5 !!! error NCQ but 28 bit address support \n")); 13732 satSetSensePayload( pSense, 13733 SCSI_SNSKEY_ILLEGAL_REQUEST, 13734 0, 13735 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 13736 satIOContext); 13737 13738 ostiInitiatorIOCompleted( tiRoot, 13739 tiIORequest, 13740 tiIOSuccess, 13741 SCSI_STAT_CHECK_CONDITION, 13742 satIOContext->pTiSenseData, 13743 satIOContext->interruptContext ); 13744 return tiSuccess; 13745 } 13746 TI_DBG5(("satWriteAndVerify10: case 5\n")); 13747 13748 /* Support 48-bit FPDMA addressing, use WRITE FPDMA QUEUE command */ 13749 13750 fis->h.fisType = 0x27; /* Reg host to device */ 13751 fis->h.c_pmPort = 0x80; /* C Bit is set */ 13752 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 13753 fis->h.features = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 13754 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 13755 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 13756 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 13757 13758 /* Check FUA bit */ 13759 if (scsiCmnd->cdb[1] & SCSI_WRITE_N_VERIFY10_FUA_MASK) 13760 fis->d.device = 0xC0; /* FIS FUA set */ 13761 else 13762 fis->d.device = 0x40; /* FIS FUA clear */ 13763 13764 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 13765 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 13766 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 13767 fis->d.featuresExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 13768 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 13769 fis->d.sectorCountExp = 0; 13770 fis->d.reserved4 = 0; 13771 fis->d.control = 0; /* FIS HOB bit clear */ 13772 fis->d.reserved5 = 0; 13773 13774 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 13775 satIOContext->ATACmd = SAT_WRITE_FPDMA_QUEUED; 13776 } 13777 13778 satIOContext->currentLBA = lba; 13779 satIOContext->OrgTL = tl; 13780 13781 /* 13782 computing number of loop and remainder for tl 13783 0xFF in case not ext 13784 0xFFFF in case EXT 13785 */ 13786 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 13787 { 13788 LoopNum = satComputeLoopNum(tl, 0xFF); 13789 } 13790 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 13791 fis->h.command == SAT_WRITE_DMA_EXT || 13792 fis->h.command == SAT_WRITE_DMA_FUA_EXT 13793 ) 13794 { 13795 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 13796 LoopNum = satComputeLoopNum(tl, 0xFFFF); 13797 } 13798 else 13799 { 13800 /* SAT_WRITE_FPDMA_QUEUED */ 13801 LoopNum = satComputeLoopNum(tl, 0xFFFF); 13802 } 13803 13804 satIOContext->LoopNum = LoopNum; 13805 13806 13807 if (LoopNum == 1) 13808 { 13809 TI_DBG5(("satWriteAndVerify10: NON CHAINED data\n")); 13810 /* Initialize CB for SATA completion. 13811 */ 13812 satIOContext->satCompleteCB = &satNonChainedWriteNVerifyCB; 13813 } 13814 else 13815 { 13816 TI_DBG1(("satWriteAndVerify10: CHAINED data\n")); 13817 /* re-setting tl */ 13818 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 13819 { 13820 fis->d.sectorCount = 0xFF; 13821 } 13822 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 13823 fis->h.command == SAT_WRITE_DMA_EXT || 13824 fis->h.command == SAT_WRITE_DMA_FUA_EXT 13825 ) 13826 { 13827 fis->d.sectorCount = 0xFF; 13828 fis->d.sectorCountExp = 0xFF; 13829 } 13830 else 13831 { 13832 /* SAT_WRITE_FPDMA_QUEUED */ 13833 fis->h.features = 0xFF; 13834 fis->d.featuresExp = 0xFF; 13835 } 13836 13837 /* Initialize CB for SATA completion. 13838 */ 13839 satIOContext->satCompleteCB = &satChainedWriteNVerifyCB; 13840 } 13841 13842 13843 /* 13844 * Prepare SGL and send FIS to LL layer. 13845 */ 13846 satIOContext->reqType = agRequestType; /* Save it */ 13847 13848 status = sataLLIOStart( tiRoot, 13849 tiIORequest, 13850 tiDeviceHandle, 13851 tiScsiRequest, 13852 satIOContext); 13853 return (status); 13854 13855 } 13856 13857 13858 13859 13860 13861 13862 #ifdef REMOVED 13863 GLOBAL bit32 satWriteAndVerify10( 13864 tiRoot_t *tiRoot, 13865 tiIORequest_t *tiIORequest, 13866 tiDeviceHandle_t *tiDeviceHandle, 13867 tiScsiInitiatorRequest_t *tiScsiRequest, 13868 satIOContext_t *satIOContext) 13869 { 13870 /* 13871 combination of write10 and verify10 13872 */ 13873 13874 bit32 status; 13875 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 13876 satDeviceData_t *pSatDevData; 13877 scsiRspSense_t *pSense; 13878 tiIniScsiCmnd_t *scsiCmnd; 13879 agsaFisRegHostToDevice_t *fis; 13880 bit32 lba = 0; 13881 bit32 tl = 0; 13882 13883 pSense = satIOContext->pSense; 13884 pSatDevData = satIOContext->pSatDevData; 13885 scsiCmnd = &tiScsiRequest->scsiCmnd; 13886 fis = satIOContext->pFis; 13887 13888 TI_DBG5(("satWriteAndVerify10: start\n")); 13889 13890 13891 /* checking BYTCHK bit */ 13892 if (scsiCmnd->cdb[1] & SCSI_WRITE_N_VERIFY_BYTCHK_MASK) 13893 { 13894 satSetSensePayload( pSense, 13895 SCSI_SNSKEY_ILLEGAL_REQUEST, 13896 0, 13897 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 13898 satIOContext); 13899 13900 ostiInitiatorIOCompleted( tiRoot, 13901 tiIORequest, 13902 tiIOSuccess, 13903 SCSI_STAT_CHECK_CONDITION, 13904 satIOContext->pTiSenseData, 13905 satIOContext->interruptContext ); 13906 13907 TI_DBG1(("satWriteAndVerify10: BYTCHK bit checking \n")); 13908 return tiSuccess; 13909 } 13910 13911 13912 /* checking CONTROL */ 13913 /* NACA == 1 or LINK == 1*/ 13914 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 13915 { 13916 satSetSensePayload( pSense, 13917 SCSI_SNSKEY_ILLEGAL_REQUEST, 13918 0, 13919 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 13920 satIOContext); 13921 13922 ostiInitiatorIOCompleted( tiRoot, 13923 tiIORequest, 13924 tiIOSuccess, 13925 SCSI_STAT_CHECK_CONDITION, 13926 satIOContext->pTiSenseData, 13927 satIOContext->interruptContext ); 13928 13929 TI_DBG2(("satWriteAndVerify10: return control\n")); 13930 return tiSuccess; 13931 } 13932 13933 /* let's do write10 */ 13934 if ( pSatDevData->sat48BitSupport != agTRUE ) 13935 { 13936 /* 13937 writeandverify10 but no support for 48 bit addressing -> problem in transfer 13938 length(sector count) 13939 */ 13940 satSetSensePayload( pSense, 13941 SCSI_SNSKEY_ILLEGAL_REQUEST, 13942 0, 13943 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 13944 satIOContext); 13945 13946 ostiInitiatorIOCompleted( tiRoot, 13947 tiIORequest, 13948 tiIOSuccess, 13949 SCSI_STAT_CHECK_CONDITION, 13950 satIOContext->pTiSenseData, 13951 satIOContext->interruptContext ); 13952 13953 TI_DBG1(("satWriteAndVerify10: return internal checking\n")); 13954 return tiSuccess; 13955 } 13956 13957 /* cbd10; computing LBA and transfer length */ 13958 lba = (scsiCmnd->cdb[2] << (8*3)) + (scsiCmnd->cdb[3] << (8*2)) 13959 + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 13960 tl = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 13961 13962 13963 /* Table 34, 9.1, p 46 */ 13964 /* 13965 note: As of 2/10/2006, no support for DMA QUEUED 13966 */ 13967 13968 /* 13969 Table 34, 9.1, p 46, b 13970 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 13971 return check condition 13972 */ 13973 if (pSatDevData->satNCQ != agTRUE && 13974 pSatDevData->sat48BitSupport != agTRUE 13975 ) 13976 { 13977 if (lba > SAT_TR_LBA_LIMIT - 1) 13978 { 13979 satSetSensePayload( pSense, 13980 SCSI_SNSKEY_ILLEGAL_REQUEST, 13981 0, 13982 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 13983 satIOContext); 13984 13985 ostiInitiatorIOCompleted( tiRoot, 13986 tiIORequest, 13987 tiIOSuccess, 13988 SCSI_STAT_CHECK_CONDITION, 13989 satIOContext->pTiSenseData, 13990 satIOContext->interruptContext ); 13991 13992 TI_DBG1(("satWriteAndVerify10: return LBA out of range\n")); 13993 return tiSuccess; 13994 } 13995 } 13996 13997 13998 /* case 1 and 2 */ 13999 if (lba + tl <= SAT_TR_LBA_LIMIT) 14000 { 14001 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 14002 { 14003 /* case 2 */ 14004 /* WRITE DMA*/ 14005 /* can't fit the transfer length */ 14006 TI_DBG5(("satWriteAndVerify10: case 2 !!!\n")); 14007 fis->h.fisType = 0x27; /* Reg host to device */ 14008 fis->h.c_pmPort = 0x80; /* C bit is set */ 14009 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 14010 fis->h.features = 0; /* FIS reserve */ 14011 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14012 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14013 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14014 14015 /* FIS LBA mode set LBA (27:24) */ 14016 fis->d.device = (0x4 << 4) | (scsiCmnd->cdb[2] & 0xF); 14017 14018 fis->d.lbaLowExp = 0; 14019 fis->d.lbaMidExp = 0; 14020 fis->d.lbaHighExp = 0; 14021 fis->d.featuresExp = 0; 14022 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 14023 fis->d.sectorCountExp = 0; 14024 fis->d.reserved4 = 0; 14025 fis->d.control = 0; /* FIS HOB bit clear */ 14026 fis->d.reserved5 = 0; 14027 14028 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 14029 satIOContext->ATACmd = SAT_WRITE_DMA; 14030 } 14031 else 14032 { 14033 /* case 1 */ 14034 /* WRITE MULTIPLE or WRITE SECTOR(S) */ 14035 /* WRITE SECTORS for easier implemetation */ 14036 /* can't fit the transfer length */ 14037 TI_DBG5(("satWriteAndVerify10: case 1 !!!\n")); 14038 fis->h.fisType = 0x27; /* Reg host to device */ 14039 fis->h.c_pmPort = 0x80; /* C bit is set */ 14040 fis->h.command = SAT_WRITE_SECTORS; /* 0x30 */ 14041 fis->h.features = 0; /* FIS reserve */ 14042 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14043 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14044 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14045 14046 /* FIS LBA mode set LBA (27:24) */ 14047 fis->d.device = (0x4 << 4) | (scsiCmnd->cdb[2] & 0xF); 14048 14049 fis->d.lbaLowExp = 0; 14050 fis->d.lbaMidExp = 0; 14051 fis->d.lbaHighExp = 0; 14052 fis->d.featuresExp = 0; 14053 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 14054 fis->d.sectorCountExp = 0; 14055 fis->d.reserved4 = 0; 14056 fis->d.control = 0; /* FIS HOB bit clear */ 14057 fis->d.reserved5 = 0; 14058 14059 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 14060 satIOContext->ATACmd = SAT_WRITE_SECTORS; 14061 14062 } 14063 } 14064 14065 /* case 3 and 4 */ 14066 if (pSatDevData->sat48BitSupport == agTRUE) 14067 { 14068 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 14069 { 14070 /* case 3 */ 14071 /* WRITE DMA EXT or WRITE DMA FUA EXT */ 14072 TI_DBG5(("satWriteAndVerify10: case 3\n")); 14073 fis->h.fisType = 0x27; /* Reg host to device */ 14074 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14075 14076 /* SAT_WRITE_DMA_FUA_EXT is optional and we don't support it */ 14077 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 14078 14079 fis->h.features = 0; /* FIS reserve */ 14080 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14081 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14082 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14083 fis->d.device = 0x40; /* FIS LBA mode set */ 14084 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 14085 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14086 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14087 fis->d.featuresExp = 0; /* FIS reserve */ 14088 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 14089 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 14090 fis->d.reserved4 = 0; 14091 fis->d.control = 0; /* FIS HOB bit clear */ 14092 fis->d.reserved5 = 0; 14093 14094 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 14095 } 14096 else 14097 { 14098 /* case 4 */ 14099 /* WRITE MULTIPLE EXT or WRITE MULTIPLE FUA EXT or WRITE SECTOR(S) EXT */ 14100 /* WRITE SECTORS EXT for easier implemetation */ 14101 TI_DBG5(("satWriteAndVerify10: case 4\n")); 14102 fis->h.fisType = 0x27; /* Reg host to device */ 14103 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14104 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 14105 14106 fis->h.features = 0; /* FIS reserve */ 14107 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14108 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14109 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14110 fis->d.device = 0x40; /* FIS LBA mode set */ 14111 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 14112 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14113 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14114 fis->d.featuresExp = 0; /* FIS reserve */ 14115 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 14116 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 14117 fis->d.reserved4 = 0; 14118 fis->d.control = 0; /* FIS HOB bit clear */ 14119 fis->d.reserved5 = 0; 14120 14121 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 14122 } 14123 } 14124 /* case 5 */ 14125 if (pSatDevData->satNCQ == agTRUE) 14126 { 14127 /* WRITE FPDMA QUEUED */ 14128 if (pSatDevData->sat48BitSupport != agTRUE) 14129 { 14130 TI_DBG5(("satWriteAndVerify10: case 5 !!! error NCQ but 28 bit address support \n")); 14131 satSetSensePayload( pSense, 14132 SCSI_SNSKEY_ILLEGAL_REQUEST, 14133 0, 14134 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 14135 satIOContext); 14136 14137 ostiInitiatorIOCompleted( tiRoot, 14138 tiIORequest, 14139 tiIOSuccess, 14140 SCSI_STAT_CHECK_CONDITION, 14141 satIOContext->pTiSenseData, 14142 satIOContext->interruptContext ); 14143 return tiSuccess; 14144 } 14145 TI_DBG5(("satWriteAndVerify10: case 5\n")); 14146 14147 /* Support 48-bit FPDMA addressing, use WRITE FPDMA QUEUE command */ 14148 14149 fis->h.fisType = 0x27; /* Reg host to device */ 14150 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14151 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 14152 fis->h.features = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 14153 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14154 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14155 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14156 14157 /* Check FUA bit */ 14158 if (scsiCmnd->cdb[1] & SCSI_WRITE_N_VERIFY10_FUA_MASK) 14159 fis->d.device = 0xC0; /* FIS FUA set */ 14160 else 14161 fis->d.device = 0x40; /* FIS FUA clear */ 14162 14163 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 14164 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14165 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14166 fis->d.featuresExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 14167 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 14168 fis->d.sectorCountExp = 0; 14169 fis->d.reserved4 = 0; 14170 fis->d.control = 0; /* FIS HOB bit clear */ 14171 fis->d.reserved5 = 0; 14172 14173 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 14174 } 14175 14176 /* Initialize CB for SATA completion. 14177 */ 14178 satIOContext->satCompleteCB = &satWriteAndVerify10CB; 14179 14180 /* 14181 * Prepare SGL and send FIS to LL layer. 14182 */ 14183 satIOContext->reqType = agRequestType; /* Save it */ 14184 14185 status = sataLLIOStart( tiRoot, 14186 tiIORequest, 14187 tiDeviceHandle, 14188 tiScsiRequest, 14189 satIOContext); 14190 return (status); 14191 14192 } 14193 #endif /* REMOVED */ 14194 14195 #ifdef REMOVED 14196 /*****************************************************************************/ 14197 /*! \brief SAT implementation for SCSI satWriteAndVerify10_1. 14198 * 14199 * SAT implementation for SCSI satWriteAndVerify10_1. 14200 * Sub function of satWriteAndVerify10 14201 * 14202 * \param tiRoot: Pointer to TISA initiator driver/port instance. 14203 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 14204 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 14205 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 14206 * \param satIOContext_t: Pointer to the SAT IO Context 14207 * 14208 * \return If command is started successfully 14209 * - \e tiSuccess: I/O request successfully initiated. 14210 * - \e tiBusy: No resources available, try again later. 14211 * - \e tiIONoDevice: Invalid device handle. 14212 * - \e tiError: Other errors. 14213 */ 14214 /*****************************************************************************/ 14215 GLOBAL bit32 satWriteAndVerify10_1( 14216 tiRoot_t *tiRoot, 14217 tiIORequest_t *tiIORequest, 14218 tiDeviceHandle_t *tiDeviceHandle, 14219 tiScsiInitiatorRequest_t *tiScsiRequest, 14220 satIOContext_t *satIOContext) 14221 { 14222 bit32 status; 14223 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 14224 satDeviceData_t *pSatDevData; 14225 scsiRspSense_t *pSense; 14226 tiIniScsiCmnd_t *scsiCmnd; 14227 agsaFisRegHostToDevice_t *fis; 14228 14229 pSense = satIOContext->pSense; 14230 pSatDevData = satIOContext->pSatDevData; 14231 scsiCmnd = &tiScsiRequest->scsiCmnd; 14232 fis = satIOContext->pFis; 14233 14234 TI_DBG5(("satWriteAndVerify10_1: start\n")); 14235 14236 if (pSatDevData->sat48BitSupport == agTRUE) 14237 { 14238 fis->h.fisType = 0x27; /* Reg host to device */ 14239 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14240 14241 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 14242 fis->h.features = 0; /* FIS reserve */ 14243 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14244 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14245 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14246 fis->d.device = 0x40; /* FIS LBA mode set 01000000 */ 14247 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 14248 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14249 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14250 fis->d.featuresExp = 0; /* FIS reserve */ 14251 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 14252 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 14253 14254 fis->d.reserved4 = 0; 14255 fis->d.control = 0; /* FIS HOB bit clear */ 14256 fis->d.reserved5 = 0; 14257 14258 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 14259 14260 /* Initialize CB for SATA completion. 14261 */ 14262 satIOContext->satCompleteCB = &satWriteAndVerify10CB; 14263 14264 /* 14265 * Prepare SGL and send FIS to LL layer. 14266 */ 14267 satIOContext->reqType = agRequestType; /* Save it */ 14268 14269 status = sataLLIOStart( tiRoot, 14270 tiIORequest, 14271 tiDeviceHandle, 14272 tiScsiRequest, 14273 satIOContext); 14274 14275 14276 TI_DBG1(("satWriteAndVerify10_1: return status %d\n", status)); 14277 return (status); 14278 } 14279 else 14280 { 14281 /* can't fit in SAT_READ_VERIFY_SECTORS becasue of Sector Count and LBA */ 14282 TI_DBG1(("satWriteAndVerify10_1: can't fit in SAT_READ_VERIFY_SECTORS\n")); 14283 return tiError; 14284 } 14285 14286 14287 return tiSuccess; 14288 } 14289 #endif /* REMOVED */ 14290 14291 /*****************************************************************************/ 14292 /*! \brief SAT implementation for SCSI satWriteAndVerify12. 14293 * 14294 * SAT implementation for SCSI satWriteAndVerify12. 14295 * 14296 * \param tiRoot: Pointer to TISA initiator driver/port instance. 14297 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 14298 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 14299 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 14300 * \param satIOContext_t: Pointer to the SAT IO Context 14301 * 14302 * \return If command is started successfully 14303 * - \e tiSuccess: I/O request successfully initiated. 14304 * - \e tiBusy: No resources available, try again later. 14305 * - \e tiIONoDevice: Invalid device handle. 14306 * - \e tiError: Other errors. 14307 */ 14308 /*****************************************************************************/ 14309 GLOBAL bit32 satWriteAndVerify12( 14310 tiRoot_t *tiRoot, 14311 tiIORequest_t *tiIORequest, 14312 tiDeviceHandle_t *tiDeviceHandle, 14313 tiScsiInitiatorRequest_t *tiScsiRequest, 14314 satIOContext_t *satIOContext) 14315 { 14316 /* 14317 combination of write12 and verify12 14318 temp: since write12 is not support (due to internal checking), no support 14319 */ 14320 bit32 status; 14321 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 14322 satDeviceData_t *pSatDevData; 14323 scsiRspSense_t *pSense; 14324 tiIniScsiCmnd_t *scsiCmnd; 14325 agsaFisRegHostToDevice_t *fis; 14326 bit32 lba = 0; 14327 bit32 tl = 0; 14328 bit32 LoopNum = 1; 14329 bit8 LBA[4]; 14330 bit8 TL[4]; 14331 bit32 rangeChk = agFALSE; /* lba and tl range check */ 14332 14333 pSense = satIOContext->pSense; 14334 pSatDevData = satIOContext->pSatDevData; 14335 scsiCmnd = &tiScsiRequest->scsiCmnd; 14336 fis = satIOContext->pFis; 14337 14338 TI_DBG5(("satWriteAndVerify12: start\n")); 14339 14340 /* checking BYTCHK bit */ 14341 if (scsiCmnd->cdb[1] & SCSI_WRITE_N_VERIFY_BYTCHK_MASK) 14342 { 14343 satSetSensePayload( pSense, 14344 SCSI_SNSKEY_ILLEGAL_REQUEST, 14345 0, 14346 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 14347 satIOContext); 14348 14349 ostiInitiatorIOCompleted( tiRoot, 14350 tiIORequest, 14351 tiIOSuccess, 14352 SCSI_STAT_CHECK_CONDITION, 14353 satIOContext->pTiSenseData, 14354 satIOContext->interruptContext ); 14355 14356 TI_DBG1(("satWriteAndVerify12: BYTCHK bit checking \n")); 14357 return tiSuccess; 14358 } 14359 14360 /* checking CONTROL */ 14361 /* NACA == 1 or LINK == 1*/ 14362 if ( (scsiCmnd->cdb[11] & SCSI_NACA_MASK) || (scsiCmnd->cdb[11] & SCSI_LINK_MASK) ) 14363 { 14364 satSetSensePayload( pSense, 14365 SCSI_SNSKEY_ILLEGAL_REQUEST, 14366 0, 14367 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 14368 satIOContext); 14369 14370 ostiInitiatorIOCompleted( tiRoot, 14371 tiIORequest, 14372 tiIOSuccess, 14373 SCSI_STAT_CHECK_CONDITION, 14374 satIOContext->pTiSenseData, 14375 satIOContext->interruptContext ); 14376 14377 TI_DBG2(("satWriteAndVerify12: return control\n")); 14378 return tiSuccess; 14379 } 14380 14381 osti_memset(LBA, 0, sizeof(LBA)); 14382 osti_memset(TL, 0, sizeof(TL)); 14383 14384 /* do not use memcpy due to indexing in LBA and TL */ 14385 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 14386 LBA[1] = scsiCmnd->cdb[3]; 14387 LBA[2] = scsiCmnd->cdb[4]; 14388 LBA[3] = scsiCmnd->cdb[5]; /* LSB */ 14389 14390 TL[0] = scsiCmnd->cdb[6]; /* MSB */ 14391 TL[1] = scsiCmnd->cdb[7]; 14392 TL[2] = scsiCmnd->cdb[7]; 14393 TL[3] = scsiCmnd->cdb[8]; /* LSB */ 14394 14395 rangeChk = satAddNComparebit32(LBA, TL); 14396 14397 lba = satComputeCDB12LBA(satIOContext); 14398 tl = satComputeCDB12TL(satIOContext); 14399 14400 14401 /* Table 34, 9.1, p 46 */ 14402 /* 14403 note: As of 2/10/2006, no support for DMA QUEUED 14404 */ 14405 14406 /* 14407 Table 34, 9.1, p 46, b 14408 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 14409 return check condition 14410 */ 14411 if (pSatDevData->satNCQ != agTRUE && 14412 pSatDevData->sat48BitSupport != agTRUE 14413 ) 14414 { 14415 if (lba > SAT_TR_LBA_LIMIT - 1) 14416 { 14417 satSetSensePayload( pSense, 14418 SCSI_SNSKEY_ILLEGAL_REQUEST, 14419 0, 14420 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 14421 satIOContext); 14422 14423 ostiInitiatorIOCompleted( tiRoot, 14424 tiIORequest, 14425 tiIOSuccess, 14426 SCSI_STAT_CHECK_CONDITION, 14427 satIOContext->pTiSenseData, 14428 satIOContext->interruptContext ); 14429 14430 TI_DBG1(("satWriteAndVerify12: return LBA out of range, not EXT\n")); 14431 return tiSuccess; 14432 } 14433 14434 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 14435 { 14436 TI_DBG1(("satWriteAndVerify12: return LBA+TL out of range, not EXT\n")); 14437 satSetSensePayload( pSense, 14438 SCSI_SNSKEY_ILLEGAL_REQUEST, 14439 0, 14440 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 14441 satIOContext); 14442 14443 ostiInitiatorIOCompleted( tiRoot, 14444 tiIORequest, 14445 tiIOSuccess, 14446 SCSI_STAT_CHECK_CONDITION, 14447 satIOContext->pTiSenseData, 14448 satIOContext->interruptContext ); 14449 14450 return tiSuccess; 14451 } 14452 } 14453 14454 /* case 1 and 2 */ 14455 if (!rangeChk) // if (lba + tl <= SAT_TR_LBA_LIMIT) 14456 { 14457 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 14458 { 14459 /* case 2 */ 14460 /* WRITE DMA*/ 14461 /* In case that we can't fit the transfer length, we loop */ 14462 TI_DBG5(("satWriteAndVerify12: case 2\n")); 14463 fis->h.fisType = 0x27; /* Reg host to device */ 14464 fis->h.c_pmPort = 0x80; /* C bit is set */ 14465 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 14466 fis->h.features = 0; /* FIS reserve */ 14467 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14468 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14469 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14470 14471 /* FIS LBA mode set LBA (27:24) */ 14472 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 14473 14474 fis->d.lbaLowExp = 0; 14475 fis->d.lbaMidExp = 0; 14476 fis->d.lbaHighExp = 0; 14477 fis->d.featuresExp = 0; 14478 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 14479 fis->d.sectorCountExp = 0; 14480 fis->d.reserved4 = 0; 14481 fis->d.control = 0; /* FIS HOB bit clear */ 14482 fis->d.reserved5 = 0; 14483 14484 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 14485 satIOContext->ATACmd = SAT_WRITE_DMA; 14486 } 14487 else 14488 { 14489 /* case 1 */ 14490 /* WRITE MULTIPLE or WRITE SECTOR(S) */ 14491 /* WRITE SECTORS for easier implemetation */ 14492 /* In case that we can't fit the transfer length, we loop */ 14493 TI_DBG5(("satWriteAndVerify12: case 1\n")); 14494 fis->h.fisType = 0x27; /* Reg host to device */ 14495 fis->h.c_pmPort = 0x80; /* C bit is set */ 14496 fis->h.command = SAT_WRITE_SECTORS; /* 0x30 */ 14497 fis->h.features = 0; /* FIS reserve */ 14498 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14499 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14500 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14501 14502 /* FIS LBA mode set LBA (27:24) */ 14503 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 14504 14505 fis->d.lbaLowExp = 0; 14506 fis->d.lbaMidExp = 0; 14507 fis->d.lbaHighExp = 0; 14508 fis->d.featuresExp = 0; 14509 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 14510 fis->d.sectorCountExp = 0; 14511 fis->d.reserved4 = 0; 14512 fis->d.control = 0; /* FIS HOB bit clear */ 14513 fis->d.reserved5 = 0; 14514 14515 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 14516 satIOContext->ATACmd = SAT_WRITE_SECTORS; 14517 } 14518 } 14519 14520 /* case 3 and 4 */ 14521 if (pSatDevData->sat48BitSupport == agTRUE) 14522 { 14523 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 14524 { 14525 /* case 3 */ 14526 /* WRITE DMA EXT or WRITE DMA FUA EXT */ 14527 TI_DBG5(("satWriteAndVerify12: case 3\n")); 14528 fis->h.fisType = 0x27; /* Reg host to device */ 14529 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14530 14531 /* SAT_WRITE_DMA_FUA_EXT is optional and we don't support it */ 14532 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 14533 14534 fis->h.features = 0; /* FIS reserve */ 14535 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14536 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14537 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14538 fis->d.device = 0x40; /* FIS LBA mode set */ 14539 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 14540 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14541 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14542 fis->d.featuresExp = 0; /* FIS reserve */ 14543 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 14544 fis->d.sectorCountExp = scsiCmnd->cdb[8]; /* FIS sector count (15:8) */ 14545 fis->d.reserved4 = 0; 14546 fis->d.control = 0; /* FIS HOB bit clear */ 14547 fis->d.reserved5 = 0; 14548 14549 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 14550 satIOContext->ATACmd = SAT_WRITE_DMA_EXT; 14551 } 14552 else 14553 { 14554 /* case 4 */ 14555 /* WRITE MULTIPLE EXT or WRITE MULTIPLE FUA EXT or WRITE SECTOR(S) EXT */ 14556 /* WRITE SECTORS EXT for easier implemetation */ 14557 TI_DBG5(("satWriteAndVerify12: case 4\n")); 14558 fis->h.fisType = 0x27; /* Reg host to device */ 14559 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14560 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 14561 14562 fis->h.features = 0; /* FIS reserve */ 14563 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14564 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14565 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14566 fis->d.device = 0x40; /* FIS LBA mode set */ 14567 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 14568 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14569 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14570 fis->d.featuresExp = 0; /* FIS reserve */ 14571 fis->d.sectorCount = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 14572 fis->d.sectorCountExp = scsiCmnd->cdb[8]; /* FIS sector count (15:8) */ 14573 fis->d.reserved4 = 0; 14574 fis->d.control = 0; /* FIS HOB bit clear */ 14575 fis->d.reserved5 = 0; 14576 14577 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 14578 satIOContext->ATACmd = SAT_WRITE_SECTORS_EXT; 14579 } 14580 } 14581 14582 /* case 5 */ 14583 if (pSatDevData->satNCQ == agTRUE) 14584 { 14585 /* WRITE FPDMA QUEUED */ 14586 if (pSatDevData->sat48BitSupport != agTRUE) 14587 { 14588 TI_DBG5(("satWriteAndVerify12: case 5 !!! error NCQ but 28 bit address support \n")); 14589 satSetSensePayload( pSense, 14590 SCSI_SNSKEY_ILLEGAL_REQUEST, 14591 0, 14592 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 14593 satIOContext); 14594 14595 ostiInitiatorIOCompleted( tiRoot, 14596 tiIORequest, 14597 tiIOSuccess, 14598 SCSI_STAT_CHECK_CONDITION, 14599 satIOContext->pTiSenseData, 14600 satIOContext->interruptContext ); 14601 return tiSuccess; 14602 } 14603 TI_DBG6(("satWriteAndVerify12: case 5\n")); 14604 14605 /* Support 48-bit FPDMA addressing, use WRITE FPDMA QUEUE command */ 14606 14607 fis->h.fisType = 0x27; /* Reg host to device */ 14608 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14609 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 14610 fis->h.features = scsiCmnd->cdb[9]; /* FIS sector count (7:0) */ 14611 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14612 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14613 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14614 14615 /* Check FUA bit */ 14616 if (scsiCmnd->cdb[1] & SCSI_WRITE12_FUA_MASK) 14617 fis->d.device = 0xC0; /* FIS FUA set */ 14618 else 14619 fis->d.device = 0x40; /* FIS FUA clear */ 14620 14621 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 14622 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14623 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14624 fis->d.featuresExp = scsiCmnd->cdb[8]; /* FIS sector count (15:8) */ 14625 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 14626 fis->d.sectorCountExp = 0; 14627 fis->d.reserved4 = 0; 14628 fis->d.control = 0; /* FIS HOB bit clear */ 14629 fis->d.reserved5 = 0; 14630 14631 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 14632 satIOContext->ATACmd = SAT_WRITE_FPDMA_QUEUED; 14633 } 14634 14635 satIOContext->currentLBA = lba; 14636 // satIOContext->OrgLBA = lba; 14637 satIOContext->OrgTL = tl; 14638 14639 /* 14640 computing number of loop and remainder for tl 14641 0xFF in case not ext 14642 0xFFFF in case EXT 14643 */ 14644 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 14645 { 14646 LoopNum = satComputeLoopNum(tl, 0xFF); 14647 } 14648 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 14649 fis->h.command == SAT_WRITE_DMA_EXT || 14650 fis->h.command == SAT_WRITE_DMA_FUA_EXT 14651 ) 14652 { 14653 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 14654 LoopNum = satComputeLoopNum(tl, 0xFFFF); 14655 } 14656 else 14657 { 14658 /* SAT_WRITE_FPDMA_QUEUEDK */ 14659 LoopNum = satComputeLoopNum(tl, 0xFFFF); 14660 } 14661 14662 satIOContext->LoopNum = LoopNum; 14663 satIOContext->LoopNum2 = LoopNum; 14664 14665 14666 if (LoopNum == 1) 14667 { 14668 TI_DBG5(("satWriteAndVerify12: NON CHAINED data\n")); 14669 /* Initialize CB for SATA completion. 14670 */ 14671 satIOContext->satCompleteCB = &satNonChainedWriteNVerifyCB; 14672 } 14673 else 14674 { 14675 TI_DBG1(("satWriteAndVerify12: CHAINED data\n")); 14676 /* re-setting tl */ 14677 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 14678 { 14679 fis->d.sectorCount = 0xFF; 14680 } 14681 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 14682 fis->h.command == SAT_WRITE_DMA_EXT || 14683 fis->h.command == SAT_WRITE_DMA_FUA_EXT 14684 ) 14685 { 14686 fis->d.sectorCount = 0xFF; 14687 fis->d.sectorCountExp = 0xFF; 14688 } 14689 else 14690 { 14691 /* SAT_WRITE_FPDMA_QUEUED */ 14692 fis->h.features = 0xFF; 14693 fis->d.featuresExp = 0xFF; 14694 } 14695 14696 /* Initialize CB for SATA completion. 14697 */ 14698 satIOContext->satCompleteCB = &satChainedWriteNVerifyCB; 14699 } 14700 14701 14702 /* 14703 * Prepare SGL and send FIS to LL layer. 14704 */ 14705 satIOContext->reqType = agRequestType; /* Save it */ 14706 14707 status = sataLLIOStart( tiRoot, 14708 tiIORequest, 14709 tiDeviceHandle, 14710 tiScsiRequest, 14711 satIOContext); 14712 return (status); 14713 } 14714 14715 GLOBAL bit32 satNonChainedWriteNVerify_Verify( 14716 tiRoot_t *tiRoot, 14717 tiIORequest_t *tiIORequest, 14718 tiDeviceHandle_t *tiDeviceHandle, 14719 tiScsiInitiatorRequest_t *tiScsiRequest, 14720 satIOContext_t *satIOContext) 14721 { 14722 bit32 status; 14723 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 14724 satDeviceData_t *pSatDevData; 14725 tiIniScsiCmnd_t *scsiCmnd; 14726 agsaFisRegHostToDevice_t *fis; 14727 14728 pSatDevData = satIOContext->pSatDevData; 14729 scsiCmnd = &tiScsiRequest->scsiCmnd; 14730 fis = satIOContext->pFis; 14731 14732 TI_DBG5(("satNonChainedWriteNVerify_Verify: start\n")); 14733 14734 if (pSatDevData->sat48BitSupport == agTRUE) 14735 { 14736 fis->h.fisType = 0x27; /* Reg host to device */ 14737 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14738 14739 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 14740 fis->h.features = 0; /* FIS reserve */ 14741 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 14742 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 14743 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 14744 fis->d.device = 0x40; /* FIS LBA mode set 01000000 */ 14745 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 14746 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14747 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14748 fis->d.featuresExp = 0; /* FIS reserve */ 14749 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 14750 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 14751 14752 fis->d.reserved4 = 0; 14753 fis->d.control = 0; /* FIS HOB bit clear */ 14754 fis->d.reserved5 = 0; 14755 14756 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 14757 14758 /* Initialize CB for SATA completion. 14759 */ 14760 satIOContext->satCompleteCB = &satNonChainedWriteNVerifyCB; 14761 14762 /* 14763 * Prepare SGL and send FIS to LL layer. 14764 */ 14765 satIOContext->reqType = agRequestType; /* Save it */ 14766 14767 status = sataLLIOStart( tiRoot, 14768 tiIORequest, 14769 tiDeviceHandle, 14770 tiScsiRequest, 14771 satIOContext); 14772 14773 14774 TI_DBG1(("satNonChainedWriteNVerify_Verify: return status %d\n", status)); 14775 return (status); 14776 } 14777 else 14778 { 14779 /* can't fit in SAT_READ_VERIFY_SECTORS becasue of Sector Count and LBA */ 14780 TI_DBG1(("satNonChainedWriteNVerify_Verify: can't fit in SAT_READ_VERIFY_SECTORS\n")); 14781 return tiError; 14782 } 14783 14784 } 14785 14786 GLOBAL bit32 satChainedWriteNVerify_Write( 14787 tiRoot_t *tiRoot, 14788 tiIORequest_t *tiIORequest, 14789 tiDeviceHandle_t *tiDeviceHandle, 14790 tiScsiInitiatorRequest_t *tiScsiRequest, 14791 satIOContext_t *satIOContext) 14792 { 14793 /* 14794 Assumption: error check on lba and tl has been done in satWrite*() 14795 lba = lba + tl; 14796 */ 14797 bit32 status; 14798 satIOContext_t *satOrgIOContext = agNULL; 14799 tiIniScsiCmnd_t *scsiCmnd; 14800 agsaFisRegHostToDevice_t *fis; 14801 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 14802 bit32 lba = 0; 14803 bit32 DenomTL = 0xFF; 14804 bit32 Remainder = 0; 14805 bit8 LBA[4]; /* 0 MSB, 3 LSB */ 14806 14807 TI_DBG1(("satChainedWriteNVerify_Write: start\n")); 14808 14809 fis = satIOContext->pFis; 14810 satOrgIOContext = satIOContext->satOrgIOContext; 14811 scsiCmnd = satOrgIOContext->pScsiCmnd; 14812 14813 osti_memset(LBA,0, sizeof(LBA)); 14814 14815 switch (satOrgIOContext->ATACmd) 14816 { 14817 case SAT_WRITE_DMA: 14818 DenomTL = 0xFF; 14819 break; 14820 case SAT_WRITE_SECTORS: 14821 DenomTL = 0xFF; 14822 break; 14823 case SAT_WRITE_DMA_EXT: 14824 DenomTL = 0xFFFF; 14825 break; 14826 case SAT_WRITE_DMA_FUA_EXT: 14827 DenomTL = 0xFFFF; 14828 break; 14829 case SAT_WRITE_SECTORS_EXT: 14830 DenomTL = 0xFFFF; 14831 break; 14832 case SAT_WRITE_FPDMA_QUEUED: 14833 DenomTL = 0xFFFF; 14834 break; 14835 default: 14836 TI_DBG1(("satChainedWriteNVerify_Write: error incorrect ata command 0x%x\n", satIOContext->ATACmd)); 14837 return tiError; 14838 break; 14839 } 14840 14841 Remainder = satOrgIOContext->OrgTL % DenomTL; 14842 satOrgIOContext->currentLBA = satOrgIOContext->currentLBA + DenomTL; 14843 lba = satOrgIOContext->currentLBA; 14844 14845 LBA[0] = (bit8)((lba & 0xF000) >> (8 * 3)); /* MSB */ 14846 LBA[1] = (bit8)((lba & 0xF00) >> (8 * 2)); 14847 LBA[2] = (bit8)((lba & 0xF0) >> 8); 14848 LBA[3] = (bit8)(lba & 0xF); /* LSB */ 14849 14850 switch (satOrgIOContext->ATACmd) 14851 { 14852 case SAT_WRITE_DMA: 14853 fis->h.fisType = 0x27; /* Reg host to device */ 14854 fis->h.c_pmPort = 0x80; /* C bit is set */ 14855 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 14856 fis->h.features = 0; /* FIS reserve */ 14857 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 14858 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 14859 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 14860 14861 /* FIS LBA mode set LBA (27:24) */ 14862 fis->d.device = (bit8)((0x4 << 4) | (LBA[0] & 0xF)); 14863 14864 fis->d.lbaLowExp = 0; 14865 fis->d.lbaMidExp = 0; 14866 fis->d.lbaHighExp = 0; 14867 fis->d.featuresExp = 0; 14868 if (satOrgIOContext->LoopNum == 1) 14869 { 14870 /* last loop */ 14871 fis->d.sectorCount = (bit8)Remainder; /* FIS sector count (7:0) */ 14872 } 14873 else 14874 { 14875 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 14876 } 14877 fis->d.sectorCountExp = 0; 14878 fis->d.reserved4 = 0; 14879 fis->d.control = 0; /* FIS HOB bit clear */ 14880 fis->d.reserved5 = 0; 14881 14882 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 14883 14884 break; 14885 case SAT_WRITE_SECTORS: 14886 fis->h.fisType = 0x27; /* Reg host to device */ 14887 fis->h.c_pmPort = 0x80; /* C bit is set */ 14888 fis->h.command = SAT_WRITE_SECTORS; /* 0x30 */ 14889 fis->h.features = 0; /* FIS reserve */ 14890 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 14891 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 14892 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 14893 14894 /* FIS LBA mode set LBA (27:24) */ 14895 fis->d.device = (bit8)((0x4 << 4) | (LBA[0] & 0xF)); 14896 14897 fis->d.lbaLowExp = 0; 14898 fis->d.lbaMidExp = 0; 14899 fis->d.lbaHighExp = 0; 14900 fis->d.featuresExp = 0; 14901 if (satOrgIOContext->LoopNum == 1) 14902 { 14903 /* last loop */ 14904 fis->d.sectorCount = (bit8)Remainder; /* FIS sector count (7:0) */ 14905 } 14906 else 14907 { 14908 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 14909 } 14910 fis->d.sectorCountExp = 0; 14911 fis->d.reserved4 = 0; 14912 fis->d.control = 0; /* FIS HOB bit clear */ 14913 fis->d.reserved5 = 0; 14914 14915 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 14916 14917 break; 14918 case SAT_WRITE_DMA_EXT: 14919 fis->h.fisType = 0x27; /* Reg host to device */ 14920 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14921 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x3D */ 14922 fis->h.features = 0; /* FIS reserve */ 14923 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 14924 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 14925 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 14926 fis->d.device = 0x40; /* FIS LBA mode set */ 14927 fis->d.lbaLowExp = LBA[0]; /* FIS LBA (31:24) */ 14928 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14929 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14930 fis->d.featuresExp = 0; /* FIS reserve */ 14931 if (satOrgIOContext->LoopNum == 1) 14932 { 14933 /* last loop */ 14934 fis->d.sectorCount = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 14935 fis->d.sectorCountExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 14936 } 14937 else 14938 { 14939 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 14940 fis->d.sectorCountExp = 0xFF; /* FIS sector count (15:8) */ 14941 } 14942 fis->d.reserved4 = 0; 14943 fis->d.control = 0; /* FIS HOB bit clear */ 14944 fis->d.reserved5 = 0; 14945 14946 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 14947 14948 break; 14949 case SAT_WRITE_SECTORS_EXT: 14950 fis->h.fisType = 0x27; /* Reg host to device */ 14951 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14952 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 14953 14954 fis->h.features = 0; /* FIS reserve */ 14955 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 14956 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 14957 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 14958 fis->d.device = 0x40; /* FIS LBA mode set */ 14959 fis->d.lbaLowExp = LBA[0]; /* FIS LBA (31:24) */ 14960 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14961 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14962 fis->d.featuresExp = 0; /* FIS reserve */ 14963 if (satOrgIOContext->LoopNum == 1) 14964 { 14965 /* last loop */ 14966 fis->d.sectorCount = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 14967 fis->d.sectorCountExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 14968 } 14969 else 14970 { 14971 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 14972 fis->d.sectorCountExp = 0xFF; /* FIS sector count (15:8) */ 14973 } 14974 fis->d.reserved4 = 0; 14975 fis->d.control = 0; /* FIS HOB bit clear */ 14976 fis->d.reserved5 = 0; 14977 14978 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 14979 14980 break; 14981 case SAT_WRITE_FPDMA_QUEUED: 14982 fis->h.fisType = 0x27; /* Reg host to device */ 14983 fis->h.c_pmPort = 0x80; /* C Bit is set */ 14984 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 14985 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 14986 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 14987 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 14988 14989 /* Check FUA bit */ 14990 if (scsiCmnd->cdb[1] & SCSI_WRITE10_FUA_MASK) 14991 fis->d.device = 0xC0; /* FIS FUA set */ 14992 else 14993 fis->d.device = 0x40; /* FIS FUA clear */ 14994 14995 fis->d.lbaLowExp = LBA[0];; /* FIS LBA (31:24) */ 14996 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 14997 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 14998 if (satOrgIOContext->LoopNum == 1) 14999 { 15000 /* last loop */ 15001 fis->h.features = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 15002 fis->d.featuresExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 15003 } 15004 else 15005 { 15006 fis->h.features = 0xFF; /* FIS sector count (7:0) */ 15007 fis->d.featuresExp = 0xFF; /* FIS sector count (15:8) */ 15008 } 15009 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 15010 fis->d.sectorCountExp = 0; 15011 fis->d.reserved4 = 0; 15012 fis->d.control = 0; /* FIS HOB bit clear */ 15013 fis->d.reserved5 = 0; 15014 15015 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 15016 break; 15017 15018 default: 15019 TI_DBG1(("satChainedWriteNVerify_Write: error incorrect ata command 0x%x\n", satIOContext->ATACmd)); 15020 return tiError; 15021 break; 15022 } 15023 15024 /* Initialize CB for SATA completion. 15025 */ 15026 /* chained data */ 15027 satIOContext->satCompleteCB = &satChainedWriteNVerifyCB; 15028 15029 15030 /* 15031 * Prepare SGL and send FIS to LL layer. 15032 */ 15033 satIOContext->reqType = agRequestType; /* Save it */ 15034 15035 status = sataLLIOStart( tiRoot, 15036 tiIORequest, 15037 tiDeviceHandle, 15038 tiScsiRequest, 15039 satIOContext); 15040 15041 TI_DBG5(("satChainedWriteNVerify_Write: return\n")); 15042 return (status); 15043 15044 } 15045 15046 /* 15047 similar to write12 and verify10; 15048 this will be similar to verify12 15049 */ 15050 GLOBAL bit32 satChainedWriteNVerify_Start_Verify( 15051 tiRoot_t *tiRoot, 15052 tiIORequest_t *tiIORequest, 15053 tiDeviceHandle_t *tiDeviceHandle, 15054 tiScsiInitiatorRequest_t *tiScsiRequest, 15055 satIOContext_t *satIOContext) 15056 { 15057 /* 15058 deal with transfer length; others have been handled previously at this point; 15059 no LBA check; no range check; 15060 */ 15061 bit32 status; 15062 bit32 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 15063 satDeviceData_t *pSatDevData; 15064 tiIniScsiCmnd_t *scsiCmnd; 15065 agsaFisRegHostToDevice_t *fis; 15066 bit32 lba = 0; 15067 bit32 tl = 0; 15068 bit32 LoopNum = 1; 15069 bit8 LBA[4]; 15070 bit8 TL[4]; 15071 15072 pSatDevData = satIOContext->pSatDevData; 15073 scsiCmnd = &tiScsiRequest->scsiCmnd; 15074 fis = satIOContext->pFis; 15075 15076 TI_DBG5(("satChainedWriteNVerify_Start_Verify: start\n")); 15077 15078 osti_memset(LBA, 0, sizeof(LBA)); 15079 osti_memset(TL, 0, sizeof(TL)); 15080 15081 /* do not use memcpy due to indexing in LBA and TL */ 15082 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 15083 LBA[1] = scsiCmnd->cdb[3]; 15084 LBA[2] = scsiCmnd->cdb[4]; 15085 LBA[3] = scsiCmnd->cdb[5]; /* LSB */ 15086 15087 TL[0] = scsiCmnd->cdb[6]; /* MSB */ 15088 TL[1] = scsiCmnd->cdb[7]; 15089 TL[2] = scsiCmnd->cdb[7]; 15090 TL[3] = scsiCmnd->cdb[8]; /* LSB */ 15091 15092 lba = satComputeCDB12LBA(satIOContext); 15093 tl = satComputeCDB12TL(satIOContext); 15094 15095 if (pSatDevData->sat48BitSupport == agTRUE) 15096 { 15097 TI_DBG5(("satChainedWriteNVerify_Start_Verify: SAT_READ_VERIFY_SECTORS_EXT\n")); 15098 fis->h.fisType = 0x27; /* Reg host to device */ 15099 fis->h.c_pmPort = 0x80; /* C Bit is set */ 15100 15101 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 15102 fis->h.features = 0; /* FIS reserve */ 15103 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 15104 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 15105 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 15106 fis->d.device = 0x40; /* FIS LBA mode set 01000000 */ 15107 fis->d.lbaLowExp = scsiCmnd->cdb[2]; /* FIS LBA (31:24) */ 15108 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 15109 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 15110 fis->d.featuresExp = 0; /* FIS reserve */ 15111 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 15112 fis->d.sectorCountExp = scsiCmnd->cdb[7]; /* FIS sector count (15:8) */ 15113 15114 fis->d.reserved4 = 0; 15115 fis->d.control = 0; /* FIS HOB bit clear */ 15116 fis->d.reserved5 = 0; 15117 15118 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 15119 satIOContext->ATACmd = SAT_READ_VERIFY_SECTORS_EXT; 15120 } 15121 else 15122 { 15123 TI_DBG5(("satChainedWriteNVerify_Start_Verify: SAT_READ_VERIFY_SECTORS\n")); 15124 fis->h.fisType = 0x27; /* Reg host to device */ 15125 fis->h.c_pmPort = 0x80; /* C bit is set */ 15126 fis->h.command = SAT_READ_VERIFY_SECTORS; /* 0x40 */ 15127 fis->h.features = 0; /* FIS reserve */ 15128 fis->d.lbaLow = scsiCmnd->cdb[5]; /* FIS LBA (7 :0 ) */ 15129 fis->d.lbaMid = scsiCmnd->cdb[4]; /* FIS LBA (15:8 ) */ 15130 fis->d.lbaHigh = scsiCmnd->cdb[3]; /* FIS LBA (23:16) */ 15131 /* FIS LBA mode set LBA (27:24) */ 15132 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[2] & 0xF)); 15133 fis->d.lbaLowExp = 0; 15134 fis->d.lbaMidExp = 0; 15135 fis->d.lbaHighExp = 0; 15136 fis->d.featuresExp = 0; 15137 fis->d.sectorCount = scsiCmnd->cdb[8]; /* FIS sector count (7:0) */ 15138 fis->d.sectorCountExp = 0; 15139 fis->d.reserved4 = 0; 15140 fis->d.control = 0; /* FIS HOB bit clear */ 15141 fis->d.reserved5 = 0; 15142 15143 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 15144 satIOContext->ATACmd = SAT_READ_VERIFY_SECTORS; 15145 15146 } 15147 15148 satIOContext->currentLBA = lba; 15149 satIOContext->OrgTL = tl; 15150 15151 /* 15152 computing number of loop and remainder for tl 15153 0xFF in case not ext 15154 0xFFFF in case EXT 15155 */ 15156 if (fis->h.command == SAT_READ_VERIFY_SECTORS) 15157 { 15158 LoopNum = satComputeLoopNum(tl, 0xFF); 15159 } 15160 else if (fis->h.command == SAT_READ_VERIFY_SECTORS_EXT) 15161 { 15162 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 15163 LoopNum = satComputeLoopNum(tl, 0xFFFF); 15164 } 15165 else 15166 { 15167 TI_DBG1(("satChainedWriteNVerify_Start_Verify: error case 1!!!\n")); 15168 LoopNum = 1; 15169 } 15170 15171 satIOContext->LoopNum = LoopNum; 15172 15173 if (LoopNum == 1) 15174 { 15175 TI_DBG5(("satChainedWriteNVerify_Start_Verify: NON CHAINED data\n")); 15176 /* Initialize CB for SATA completion. 15177 */ 15178 satIOContext->satCompleteCB = &satNonChainedWriteNVerifyCB; 15179 } 15180 else 15181 { 15182 TI_DBG1(("satChainedWriteNVerify_Start_Verify: CHAINED data\n")); 15183 /* re-setting tl */ 15184 if (fis->h.command == SAT_READ_VERIFY_SECTORS) 15185 { 15186 fis->d.sectorCount = 0xFF; 15187 } 15188 else if (fis->h.command == SAT_READ_VERIFY_SECTORS_EXT) 15189 { 15190 fis->d.sectorCount = 0xFF; 15191 fis->d.sectorCountExp = 0xFF; 15192 } 15193 else 15194 { 15195 TI_DBG1(("satChainedWriteNVerify_Start_Verify: error case 2!!!\n")); 15196 } 15197 15198 /* Initialize CB for SATA completion. 15199 */ 15200 satIOContext->satCompleteCB = &satChainedWriteNVerifyCB; 15201 } 15202 15203 15204 /* 15205 * Prepare SGL and send FIS to LL layer. 15206 */ 15207 satIOContext->reqType = agRequestType; /* Save it */ 15208 15209 status = sataLLIOStart( tiRoot, 15210 tiIORequest, 15211 tiDeviceHandle, 15212 tiScsiRequest, 15213 satIOContext); 15214 return (status); 15215 } 15216 15217 GLOBAL bit32 satChainedWriteNVerify_Verify( 15218 tiRoot_t *tiRoot, 15219 tiIORequest_t *tiIORequest, 15220 tiDeviceHandle_t *tiDeviceHandle, 15221 tiScsiInitiatorRequest_t *tiScsiRequest, 15222 satIOContext_t *satIOContext) 15223 { 15224 bit32 status; 15225 satIOContext_t *satOrgIOContext = agNULL; 15226 agsaFisRegHostToDevice_t *fis; 15227 bit32 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 15228 bit32 lba = 0; 15229 bit32 DenomTL = 0xFF; 15230 bit32 Remainder = 0; 15231 bit8 LBA[4]; /* 0 MSB, 3 LSB */ 15232 15233 TI_DBG2(("satChainedWriteNVerify_Verify: start\n")); 15234 15235 fis = satIOContext->pFis; 15236 satOrgIOContext = satIOContext->satOrgIOContext; 15237 15238 osti_memset(LBA,0, sizeof(LBA)); 15239 15240 switch (satOrgIOContext->ATACmd) 15241 { 15242 case SAT_READ_VERIFY_SECTORS: 15243 DenomTL = 0xFF; 15244 break; 15245 case SAT_READ_VERIFY_SECTORS_EXT: 15246 DenomTL = 0xFFFF; 15247 break; 15248 default: 15249 TI_DBG1(("satChainedWriteNVerify_Verify: error incorrect ata command 0x%x\n", satIOContext->ATACmd)); 15250 return tiError; 15251 break; 15252 } 15253 15254 Remainder = satOrgIOContext->OrgTL % DenomTL; 15255 satOrgIOContext->currentLBA = satOrgIOContext->currentLBA + DenomTL; 15256 lba = satOrgIOContext->currentLBA; 15257 15258 LBA[0] = (bit8)((lba & 0xF000) >> (8 * 3)); /* MSB */ 15259 LBA[1] = (bit8)((lba & 0xF00) >> (8 * 2)); 15260 LBA[2] = (bit8)((lba & 0xF0) >> 8); 15261 LBA[3] = (bit8)(lba & 0xF); /* LSB */ 15262 15263 switch (satOrgIOContext->ATACmd) 15264 { 15265 case SAT_READ_VERIFY_SECTORS: 15266 fis->h.fisType = 0x27; /* Reg host to device */ 15267 fis->h.c_pmPort = 0x80; /* C bit is set */ 15268 fis->h.command = SAT_READ_VERIFY_SECTORS; /* 0x40 */ 15269 fis->h.features = 0; /* FIS reserve */ 15270 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 15271 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 15272 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 15273 15274 /* FIS LBA mode set LBA (27:24) */ 15275 fis->d.device = (bit8)((0x4 << 4) | (LBA[0] & 0xF)); 15276 15277 fis->d.lbaLowExp = 0; 15278 fis->d.lbaMidExp = 0; 15279 fis->d.lbaHighExp = 0; 15280 fis->d.featuresExp = 0; 15281 if (satOrgIOContext->LoopNum == 1) 15282 { 15283 /* last loop */ 15284 fis->d.sectorCount = (bit8)Remainder; /* FIS sector count (7:0) */ 15285 } 15286 else 15287 { 15288 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 15289 } 15290 fis->d.sectorCountExp = 0; 15291 fis->d.reserved4 = 0; 15292 fis->d.control = 0; /* FIS HOB bit clear */ 15293 fis->d.reserved5 = 0; 15294 15295 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 15296 15297 break; 15298 case SAT_READ_VERIFY_SECTORS_EXT: 15299 fis->h.fisType = 0x27; /* Reg host to device */ 15300 fis->h.c_pmPort = 0x80; /* C Bit is set */ 15301 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT; /* 0x42 */ 15302 fis->h.features = 0; /* FIS reserve */ 15303 fis->d.lbaLow = LBA[3]; /* FIS LBA (7 :0 ) */ 15304 fis->d.lbaMid = LBA[2]; /* FIS LBA (15:8 ) */ 15305 fis->d.lbaHigh = LBA[1]; /* FIS LBA (23:16) */ 15306 fis->d.device = 0x40; /* FIS LBA mode set */ 15307 fis->d.lbaLowExp = LBA[0]; /* FIS LBA (31:24) */ 15308 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 15309 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 15310 fis->d.featuresExp = 0; /* FIS reserve */ 15311 if (satOrgIOContext->LoopNum == 1) 15312 { 15313 /* last loop */ 15314 fis->d.sectorCount = (bit8)(Remainder & 0xFF); /* FIS sector count (7:0) */ 15315 fis->d.sectorCountExp = (bit8)((Remainder & 0xFF00) >> 8); /* FIS sector count (15:8) */ 15316 } 15317 else 15318 { 15319 fis->d.sectorCount = 0xFF; /* FIS sector count (7:0) */ 15320 fis->d.sectorCountExp = 0xFF; /* FIS sector count (15:8) */ 15321 } 15322 fis->d.reserved4 = 0; 15323 fis->d.control = 0; /* FIS HOB bit clear */ 15324 fis->d.reserved5 = 0; 15325 15326 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 15327 15328 break; 15329 15330 default: 15331 TI_DBG1(("satChainedWriteNVerify_Verify: error incorrect ata command 0x%x\n", satIOContext->ATACmd)); 15332 return tiError; 15333 break; 15334 } 15335 15336 /* Initialize CB for SATA completion. 15337 */ 15338 /* chained data */ 15339 satIOContext->satCompleteCB = &satChainedWriteNVerifyCB; 15340 15341 15342 /* 15343 * Prepare SGL and send FIS to LL layer. 15344 */ 15345 satIOContext->reqType = agRequestType; /* Save it */ 15346 15347 status = sataLLIOStart( tiRoot, 15348 tiIORequest, 15349 tiDeviceHandle, 15350 tiScsiRequest, 15351 satIOContext); 15352 15353 TI_DBG5(("satChainedWriteNVerify_Verify: return\n")); 15354 return (status); 15355 15356 } 15357 15358 15359 /*****************************************************************************/ 15360 /*! \brief SAT implementation for SCSI satWriteAndVerify16. 15361 * 15362 * SAT implementation for SCSI satWriteAndVerify16. 15363 * 15364 * \param tiRoot: Pointer to TISA initiator driver/port instance. 15365 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 15366 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 15367 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 15368 * \param satIOContext_t: Pointer to the SAT IO Context 15369 * 15370 * \return If command is started successfully 15371 * - \e tiSuccess: I/O request successfully initiated. 15372 * - \e tiBusy: No resources available, try again later. 15373 * - \e tiIONoDevice: Invalid device handle. 15374 * - \e tiError: Other errors. 15375 */ 15376 /*****************************************************************************/ 15377 GLOBAL bit32 satWriteAndVerify16( 15378 tiRoot_t *tiRoot, 15379 tiIORequest_t *tiIORequest, 15380 tiDeviceHandle_t *tiDeviceHandle, 15381 tiScsiInitiatorRequest_t *tiScsiRequest, 15382 satIOContext_t *satIOContext) 15383 { 15384 /* 15385 combination of write16 and verify16 15386 since write16 has 8 bytes LBA -> problem ATA LBA(upto 6 bytes), no support 15387 */ 15388 bit32 status; 15389 bit32 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 15390 satDeviceData_t *pSatDevData; 15391 scsiRspSense_t *pSense; 15392 tiIniScsiCmnd_t *scsiCmnd; 15393 agsaFisRegHostToDevice_t *fis; 15394 bit32 lba = 0; 15395 bit32 tl = 0; 15396 bit32 LoopNum = 1; 15397 bit8 LBA[8]; 15398 bit8 TL[8]; 15399 bit32 rangeChk = agFALSE; /* lba and tl range check */ 15400 bit32 limitChk = agFALSE; /* lba and tl range check */ 15401 15402 pSense = satIOContext->pSense; 15403 pSatDevData = satIOContext->pSatDevData; 15404 scsiCmnd = &tiScsiRequest->scsiCmnd; 15405 fis = satIOContext->pFis; 15406 TI_DBG5(("satWriteAndVerify16:start\n")); 15407 15408 /* checking BYTCHK bit */ 15409 if (scsiCmnd->cdb[1] & SCSI_WRITE_N_VERIFY_BYTCHK_MASK) 15410 { 15411 satSetSensePayload( pSense, 15412 SCSI_SNSKEY_ILLEGAL_REQUEST, 15413 0, 15414 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 15415 satIOContext); 15416 15417 ostiInitiatorIOCompleted( tiRoot, 15418 tiIORequest, 15419 tiIOSuccess, 15420 SCSI_STAT_CHECK_CONDITION, 15421 satIOContext->pTiSenseData, 15422 satIOContext->interruptContext ); 15423 15424 TI_DBG1(("satWriteAndVerify16: BYTCHK bit checking \n")); 15425 return tiSuccess; 15426 } 15427 15428 15429 /* checking CONTROL */ 15430 /* NACA == 1 or LINK == 1*/ 15431 if ( (scsiCmnd->cdb[15] & SCSI_NACA_MASK) || (scsiCmnd->cdb[15] & SCSI_LINK_MASK) ) 15432 { 15433 satSetSensePayload( pSense, 15434 SCSI_SNSKEY_ILLEGAL_REQUEST, 15435 0, 15436 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 15437 satIOContext); 15438 15439 ostiInitiatorIOCompleted( tiRoot, 15440 tiIORequest, 15441 tiIOSuccess, 15442 SCSI_STAT_CHECK_CONDITION, 15443 satIOContext->pTiSenseData, 15444 satIOContext->interruptContext ); 15445 15446 TI_DBG2(("satWriteAndVerify16: return control\n")); 15447 return tiSuccess; 15448 } 15449 15450 osti_memset(LBA, 0, sizeof(LBA)); 15451 osti_memset(TL, 0, sizeof(TL)); 15452 15453 15454 /* do not use memcpy due to indexing in LBA and TL */ 15455 LBA[0] = scsiCmnd->cdb[2]; /* MSB */ 15456 LBA[1] = scsiCmnd->cdb[3]; 15457 LBA[2] = scsiCmnd->cdb[4]; 15458 LBA[3] = scsiCmnd->cdb[5]; 15459 LBA[4] = scsiCmnd->cdb[6]; 15460 LBA[5] = scsiCmnd->cdb[7]; 15461 LBA[6] = scsiCmnd->cdb[8]; 15462 LBA[7] = scsiCmnd->cdb[9]; /* LSB */ 15463 15464 TL[0] = 0; 15465 TL[1] = 0; 15466 TL[2] = 0; 15467 TL[3] = 0; 15468 TL[4] = scsiCmnd->cdb[10]; /* MSB */ 15469 TL[5] = scsiCmnd->cdb[11]; 15470 TL[6] = scsiCmnd->cdb[12]; 15471 TL[7] = scsiCmnd->cdb[13]; /* LSB */ 15472 15473 rangeChk = satAddNComparebit64(LBA, TL); 15474 15475 limitChk = satCompareLBALimitbit(LBA); 15476 15477 lba = satComputeCDB16LBA(satIOContext); 15478 tl = satComputeCDB16TL(satIOContext); 15479 15480 15481 /* Table 34, 9.1, p 46 */ 15482 /* 15483 note: As of 2/10/2006, no support for DMA QUEUED 15484 */ 15485 15486 /* 15487 Table 34, 9.1, p 46, b 15488 When no 48-bit addressing support or NCQ, if LBA is beyond (2^28 - 1), 15489 return check condition 15490 */ 15491 if (pSatDevData->satNCQ != agTRUE && 15492 pSatDevData->sat48BitSupport != agTRUE 15493 ) 15494 { 15495 if (limitChk) 15496 { 15497 TI_DBG1(("satWriteAndVerify16: return LBA out of range, not EXT\n")); 15498 satSetSensePayload( pSense, 15499 SCSI_SNSKEY_ILLEGAL_REQUEST, 15500 0, 15501 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 15502 satIOContext); 15503 15504 ostiInitiatorIOCompleted( tiRoot, 15505 tiIORequest, 15506 tiIOSuccess, 15507 SCSI_STAT_CHECK_CONDITION, 15508 satIOContext->pTiSenseData, 15509 satIOContext->interruptContext ); 15510 15511 return tiSuccess; 15512 } 15513 if (rangeChk) // if (lba + tl > SAT_TR_LBA_LIMIT) 15514 { 15515 TI_DBG1(("satWriteAndVerify16: return LBA+TL out of range, not EXT\n")); 15516 satSetSensePayload( pSense, 15517 SCSI_SNSKEY_ILLEGAL_REQUEST, 15518 0, 15519 SCSI_SNSCODE_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 15520 satIOContext); 15521 15522 ostiInitiatorIOCompleted( tiRoot, 15523 tiIORequest, 15524 tiIOSuccess, 15525 SCSI_STAT_CHECK_CONDITION, 15526 satIOContext->pTiSenseData, 15527 satIOContext->interruptContext ); 15528 15529 return tiSuccess; 15530 } 15531 } 15532 15533 15534 /* case 1 and 2 */ 15535 if (!rangeChk) // if (lba + tl <= SAT_TR_LBA_LIMIT) 15536 { 15537 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 15538 { 15539 /* case 2 */ 15540 /* WRITE DMA*/ 15541 /* In case that we can't fit the transfer length, we loop */ 15542 TI_DBG5(("satWriteAndVerify16: case 2\n")); 15543 fis->h.fisType = 0x27; /* Reg host to device */ 15544 fis->h.c_pmPort = 0x80; /* C bit is set */ 15545 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 15546 fis->h.features = 0; /* FIS reserve */ 15547 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 15548 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 15549 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 15550 15551 /* FIS LBA mode set LBA (27:24) */ 15552 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[6] & 0xF)); 15553 15554 fis->d.lbaLowExp = 0; 15555 fis->d.lbaMidExp = 0; 15556 fis->d.lbaHighExp = 0; 15557 fis->d.featuresExp = 0; 15558 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 15559 fis->d.sectorCountExp = 0; 15560 fis->d.reserved4 = 0; 15561 fis->d.control = 0; /* FIS HOB bit clear */ 15562 fis->d.reserved5 = 0; 15563 15564 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 15565 satIOContext->ATACmd = SAT_WRITE_DMA; 15566 } 15567 else 15568 { 15569 /* case 1 */ 15570 /* WRITE MULTIPLE or WRITE SECTOR(S) */ 15571 /* WRITE SECTORS for easier implemetation */ 15572 /* In case that we can't fit the transfer length, we loop */ 15573 TI_DBG5(("satWriteAndVerify16: case 1\n")); 15574 fis->h.fisType = 0x27; /* Reg host to device */ 15575 fis->h.c_pmPort = 0x80; /* C bit is set */ 15576 fis->h.command = SAT_WRITE_SECTORS; /* 0x30 */ 15577 fis->h.features = 0; /* FIS reserve */ 15578 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 15579 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 15580 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 15581 15582 /* FIS LBA mode set LBA (27:24) */ 15583 fis->d.device = (bit8)((0x4 << 4) | (scsiCmnd->cdb[6] & 0xF)); 15584 15585 fis->d.lbaLowExp = 0; 15586 fis->d.lbaMidExp = 0; 15587 fis->d.lbaHighExp = 0; 15588 fis->d.featuresExp = 0; 15589 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 15590 fis->d.sectorCountExp = 0; 15591 fis->d.reserved4 = 0; 15592 fis->d.control = 0; /* FIS HOB bit clear */ 15593 fis->d.reserved5 = 0; 15594 15595 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 15596 satIOContext->ATACmd = SAT_WRITE_SECTORS; 15597 } 15598 } 15599 15600 /* case 3 and 4 */ 15601 if (pSatDevData->sat48BitSupport == agTRUE) 15602 { 15603 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 15604 { 15605 /* case 3 */ 15606 /* WRITE DMA EXT or WRITE DMA FUA EXT */ 15607 TI_DBG5(("satWriteAndVerify16: case 3\n")); 15608 fis->h.fisType = 0x27; /* Reg host to device */ 15609 fis->h.c_pmPort = 0x80; /* C Bit is set */ 15610 15611 /* SAT_WRITE_DMA_FUA_EXT is optional and we don't support it */ 15612 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 15613 15614 fis->h.features = 0; /* FIS reserve */ 15615 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 15616 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 15617 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 15618 fis->d.device = 0x40; /* FIS LBA mode set */ 15619 fis->d.lbaLowExp = scsiCmnd->cdb[6]; /* FIS LBA (31:24) */ 15620 fis->d.lbaMidExp = scsiCmnd->cdb[5]; /* FIS LBA (39:32) */ 15621 fis->d.lbaHighExp = scsiCmnd->cdb[4]; /* FIS LBA (47:40) */ 15622 fis->d.featuresExp = 0; /* FIS reserve */ 15623 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 15624 fis->d.sectorCountExp = scsiCmnd->cdb[12]; /* FIS sector count (15:8) */ 15625 fis->d.reserved4 = 0; 15626 fis->d.control = 0; /* FIS HOB bit clear */ 15627 fis->d.reserved5 = 0; 15628 15629 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 15630 satIOContext->ATACmd = SAT_WRITE_DMA_EXT; 15631 } 15632 else 15633 { 15634 /* case 4 */ 15635 /* WRITE MULTIPLE EXT or WRITE MULTIPLE FUA EXT or WRITE SECTOR(S) EXT */ 15636 /* WRITE SECTORS EXT for easier implemetation */ 15637 TI_DBG5(("satWriteAndVerify16: case 4\n")); 15638 fis->h.fisType = 0x27; /* Reg host to device */ 15639 fis->h.c_pmPort = 0x80; /* C Bit is set */ 15640 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 15641 15642 fis->h.features = 0; /* FIS reserve */ 15643 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 15644 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 15645 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 15646 fis->d.device = 0x40; /* FIS LBA mode set */ 15647 fis->d.lbaLowExp = scsiCmnd->cdb[6]; /* FIS LBA (31:24) */ 15648 fis->d.lbaMidExp = scsiCmnd->cdb[5]; /* FIS LBA (39:32) */ 15649 fis->d.lbaHighExp = scsiCmnd->cdb[4]; /* FIS LBA (47:40) */ 15650 fis->d.featuresExp = 0; /* FIS reserve */ 15651 fis->d.sectorCount = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 15652 fis->d.sectorCountExp = scsiCmnd->cdb[12]; /* FIS sector count (15:8) */ 15653 fis->d.reserved4 = 0; 15654 fis->d.control = 0; /* FIS HOB bit clear */ 15655 fis->d.reserved5 = 0; 15656 15657 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 15658 satIOContext->ATACmd = SAT_WRITE_SECTORS_EXT; 15659 } 15660 } 15661 15662 /* case 5 */ 15663 if (pSatDevData->satNCQ == agTRUE) 15664 { 15665 /* WRITE FPDMA QUEUED */ 15666 if (pSatDevData->sat48BitSupport != agTRUE) 15667 { 15668 TI_DBG5(("satWriteAndVerify16: case 5 !!! error NCQ but 28 bit address support \n")); 15669 satSetSensePayload( pSense, 15670 SCSI_SNSKEY_ILLEGAL_REQUEST, 15671 0, 15672 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 15673 satIOContext); 15674 15675 ostiInitiatorIOCompleted( tiRoot, 15676 tiIORequest, 15677 tiIOSuccess, 15678 SCSI_STAT_CHECK_CONDITION, 15679 satIOContext->pTiSenseData, 15680 satIOContext->interruptContext ); 15681 return tiSuccess; 15682 } 15683 TI_DBG6(("satWriteAndVerify16: case 5\n")); 15684 15685 /* Support 48-bit FPDMA addressing, use WRITE FPDMA QUEUE command */ 15686 15687 fis->h.fisType = 0x27; /* Reg host to device */ 15688 fis->h.c_pmPort = 0x80; /* C Bit is set */ 15689 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 15690 fis->h.features = scsiCmnd->cdb[13]; /* FIS sector count (7:0) */ 15691 fis->d.lbaLow = scsiCmnd->cdb[9]; /* FIS LBA (7 :0 ) */ 15692 fis->d.lbaMid = scsiCmnd->cdb[8]; /* FIS LBA (15:8 ) */ 15693 fis->d.lbaHigh = scsiCmnd->cdb[7]; /* FIS LBA (23:16) */ 15694 15695 /* Check FUA bit */ 15696 if (scsiCmnd->cdb[1] & SCSI_WRITE16_FUA_MASK) 15697 fis->d.device = 0xC0; /* FIS FUA set */ 15698 else 15699 fis->d.device = 0x40; /* FIS FUA clear */ 15700 15701 fis->d.lbaLowExp = scsiCmnd->cdb[6]; /* FIS LBA (31:24) */ 15702 fis->d.lbaMidExp = scsiCmnd->cdb[5]; /* FIS LBA (39:32) */ 15703 fis->d.lbaHighExp = scsiCmnd->cdb[4]; /* FIS LBA (47:40) */ 15704 fis->d.featuresExp = scsiCmnd->cdb[12]; /* FIS sector count (15:8) */ 15705 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 15706 fis->d.sectorCountExp = 0; 15707 fis->d.reserved4 = 0; 15708 fis->d.control = 0; /* FIS HOB bit clear */ 15709 fis->d.reserved5 = 0; 15710 15711 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 15712 satIOContext->ATACmd = SAT_WRITE_FPDMA_QUEUED; 15713 } 15714 15715 satIOContext->currentLBA = lba; 15716 satIOContext->OrgTL = tl; 15717 15718 /* 15719 computing number of loop and remainder for tl 15720 0xFF in case not ext 15721 0xFFFF in case EXT 15722 */ 15723 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 15724 { 15725 LoopNum = satComputeLoopNum(tl, 0xFF); 15726 } 15727 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 15728 fis->h.command == SAT_WRITE_DMA_EXT || 15729 fis->h.command == SAT_WRITE_DMA_FUA_EXT 15730 ) 15731 { 15732 /* SAT_READ_SECTORS_EXT, SAT_READ_DMA_EXT */ 15733 LoopNum = satComputeLoopNum(tl, 0xFFFF); 15734 } 15735 else 15736 { 15737 /* SAT_WRITE_FPDMA_QUEUEDK */ 15738 LoopNum = satComputeLoopNum(tl, 0xFFFF); 15739 } 15740 15741 satIOContext->LoopNum = LoopNum; 15742 15743 15744 if (LoopNum == 1) 15745 { 15746 TI_DBG5(("satWriteAndVerify16: NON CHAINED data\n")); 15747 /* Initialize CB for SATA completion. 15748 */ 15749 satIOContext->satCompleteCB = &satNonChainedWriteNVerifyCB; 15750 } 15751 else 15752 { 15753 TI_DBG1(("satWriteAndVerify16: CHAINED data\n")); 15754 /* re-setting tl */ 15755 if (fis->h.command == SAT_WRITE_SECTORS || fis->h.command == SAT_WRITE_DMA) 15756 { 15757 fis->d.sectorCount = 0xFF; 15758 } 15759 else if (fis->h.command == SAT_WRITE_SECTORS_EXT || 15760 fis->h.command == SAT_WRITE_DMA_EXT || 15761 fis->h.command == SAT_WRITE_DMA_FUA_EXT 15762 ) 15763 { 15764 fis->d.sectorCount = 0xFF; 15765 fis->d.sectorCountExp = 0xFF; 15766 } 15767 else 15768 { 15769 /* SAT_WRITE_FPDMA_QUEUED */ 15770 fis->h.features = 0xFF; 15771 fis->d.featuresExp = 0xFF; 15772 } 15773 15774 /* Initialize CB for SATA completion. 15775 */ 15776 satIOContext->satCompleteCB = &satChainedWriteNVerifyCB; 15777 } 15778 15779 15780 /* 15781 * Prepare SGL and send FIS to LL layer. 15782 */ 15783 satIOContext->reqType = agRequestType; /* Save it */ 15784 15785 status = sataLLIOStart( tiRoot, 15786 tiIORequest, 15787 tiDeviceHandle, 15788 tiScsiRequest, 15789 satIOContext); 15790 return (status); 15791 } 15792 15793 /*****************************************************************************/ 15794 /*! \brief SAT implementation for SCSI satReadMediaSerialNumber. 15795 * 15796 * SAT implementation for SCSI Read Media Serial Number. 15797 * 15798 * \param tiRoot: Pointer to TISA initiator driver/port instance. 15799 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 15800 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 15801 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 15802 * \param satIOContext_t: Pointer to the SAT IO Context 15803 * 15804 * \return If command is started successfully 15805 * - \e tiSuccess: I/O request successfully initiated. 15806 * - \e tiBusy: No resources available, try again later. 15807 * - \e tiIONoDevice: Invalid device handle. 15808 * - \e tiError: Other errors. 15809 */ 15810 /*****************************************************************************/ 15811 GLOBAL bit32 satReadMediaSerialNumber( 15812 tiRoot_t *tiRoot, 15813 tiIORequest_t *tiIORequest, 15814 tiDeviceHandle_t *tiDeviceHandle, 15815 tiScsiInitiatorRequest_t *tiScsiRequest, 15816 satIOContext_t *satIOContext) 15817 { 15818 bit32 status; 15819 bit32 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 15820 satDeviceData_t *pSatDevData; 15821 scsiRspSense_t *pSense; 15822 tiIniScsiCmnd_t *scsiCmnd; 15823 agsaFisRegHostToDevice_t *fis; 15824 agsaSATAIdentifyData_t *pSATAIdData; 15825 bit8 *pSerialNumber; 15826 15827 pSense = satIOContext->pSense; 15828 pSatDevData = satIOContext->pSatDevData; 15829 scsiCmnd = &tiScsiRequest->scsiCmnd; 15830 fis = satIOContext->pFis; 15831 pSATAIdData = &(pSatDevData->satIdentifyData); 15832 pSerialNumber = (bit8 *) tiScsiRequest->sglVirtualAddr; 15833 15834 15835 TI_DBG1(("satReadMediaSerialNumber: start\n")); 15836 15837 /* checking CONTROL */ 15838 /* NACA == 1 or LINK == 1*/ 15839 if ( (scsiCmnd->cdb[11] & SCSI_NACA_MASK) || (scsiCmnd->cdb[11] & SCSI_LINK_MASK) ) 15840 { 15841 satSetSensePayload( pSense, 15842 SCSI_SNSKEY_ILLEGAL_REQUEST, 15843 0, 15844 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 15845 satIOContext); 15846 15847 ostiInitiatorIOCompleted( tiRoot, 15848 tiIORequest, 15849 tiIOSuccess, 15850 SCSI_STAT_CHECK_CONDITION, 15851 satIOContext->pTiSenseData, 15852 satIOContext->interruptContext ); 15853 15854 TI_DBG1(("satReadMediaSerialNumber: return control\n")); 15855 return tiSuccess; 15856 } 15857 15858 if (tiScsiRequest->scsiCmnd.expDataLength == 4) 15859 { 15860 if (pSATAIdData->commandSetFeatureDefault & 0x4) 15861 { 15862 TI_DBG1(("satReadMediaSerialNumber: Media serial number returning only length\n")); 15863 /* SPC-3 6.16 p192; filling in length */ 15864 pSerialNumber[0] = 0; 15865 pSerialNumber[1] = 0; 15866 pSerialNumber[2] = 0; 15867 pSerialNumber[3] = 0x3C; 15868 } 15869 else 15870 { 15871 /* 1 sector - 4 = 512 - 4 to avoid underflow; 0x1fc*/ 15872 pSerialNumber[0] = 0; 15873 pSerialNumber[1] = 0; 15874 pSerialNumber[2] = 0x1; 15875 pSerialNumber[3] = 0xfc; 15876 } 15877 15878 ostiInitiatorIOCompleted( tiRoot, 15879 tiIORequest, 15880 tiIOSuccess, 15881 SCSI_STAT_GOOD, 15882 agNULL, 15883 satIOContext->interruptContext); 15884 15885 return tiSuccess; 15886 } 15887 15888 if ( pSatDevData->IDDeviceValid == agTRUE) 15889 { 15890 if (pSATAIdData->commandSetFeatureDefault & 0x4) 15891 { 15892 /* word87 bit2 Media serial number is valid */ 15893 /* read word 176 to 205; length is 2*30 = 60 = 0x3C*/ 15894 tdhexdump("ID satReadMediaSerialNumber", (bit8*)pSATAIdData->currentMediaSerialNumber, 2*30); 15895 /* SPC-3 6.16 p192; filling in length */ 15896 pSerialNumber[0] = 0; 15897 pSerialNumber[1] = 0; 15898 pSerialNumber[2] = 0; 15899 pSerialNumber[3] = 0x3C; 15900 osti_memcpy(&pSerialNumber[4], (void *)pSATAIdData->currentMediaSerialNumber, 60); 15901 tdhexdump("satReadMediaSerialNumber", (bit8*)pSerialNumber, 2*30 + 4); 15902 15903 ostiInitiatorIOCompleted( tiRoot, 15904 tiIORequest, 15905 tiIOSuccess, 15906 SCSI_STAT_GOOD, 15907 agNULL, 15908 satIOContext->interruptContext); 15909 return tiSuccess; 15910 15911 15912 } 15913 else 15914 { 15915 /* word87 bit2 Media serial number is NOT valid */ 15916 TI_DBG1(("satReadMediaSerialNumber: Media serial number is NOT valid \n")); 15917 15918 if (pSatDevData->sat48BitSupport == agTRUE) 15919 { 15920 /* READ VERIFY SECTORS EXT */ 15921 fis->h.fisType = 0x27; /* Reg host to device */ 15922 fis->h.c_pmPort = 0x80; /* C Bit is set */ 15923 fis->h.command = SAT_READ_SECTORS_EXT; /* 0x24 */ 15924 15925 fis->h.features = 0; /* FIS reserve */ 15926 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 15927 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 15928 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 15929 fis->d.device = 0x40; /* FIS LBA mode set */ 15930 fis->d.lbaLowExp = 0; /* FIS LBA (31:24) */ 15931 fis->d.lbaMidExp = 0; /* FIS LBA (39:32) */ 15932 fis->d.lbaHighExp = 0; /* FIS LBA (47:40) */ 15933 fis->d.featuresExp = 0; /* FIS reserve */ 15934 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 15935 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 15936 fis->d.reserved4 = 0; 15937 fis->d.control = 0; /* FIS HOB bit clear */ 15938 fis->d.reserved5 = 0; 15939 15940 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 15941 } 15942 else 15943 { 15944 /* READ VERIFY SECTORS */ 15945 fis->h.fisType = 0x27; /* Reg host to device */ 15946 fis->h.c_pmPort = 0x80; /* C Bit is set */ 15947 fis->h.command = SAT_READ_SECTORS; /* 0x20 */ 15948 fis->h.features = 0; /* FIS reserve */ 15949 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 15950 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 15951 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 15952 fis->d.device = 0x40; /* FIS LBA (27:24) and FIS LBA mode */ 15953 fis->d.lbaLowExp = 0; 15954 fis->d.lbaMidExp = 0; 15955 fis->d.lbaHighExp = 0; 15956 fis->d.featuresExp = 0; 15957 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 15958 fis->d.sectorCountExp = 0; 15959 fis->d.reserved4 = 0; 15960 fis->d.control = 0; /* FIS HOB bit clear */ 15961 fis->d.reserved5 = 0; 15962 15963 15964 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 15965 } 15966 satIOContext->satCompleteCB = &satReadMediaSerialNumberCB; 15967 satIOContext->reqType = agRequestType; /* Save it */ 15968 status = sataLLIOStart( tiRoot, 15969 tiIORequest, 15970 tiDeviceHandle, 15971 tiScsiRequest, 15972 satIOContext); 15973 15974 return status; 15975 } 15976 } 15977 else 15978 { 15979 /* temporary failure */ 15980 ostiInitiatorIOCompleted( tiRoot, 15981 tiIORequest, 15982 tiIOFailed, 15983 tiDetailOtherError, 15984 agNULL, 15985 satIOContext->interruptContext); 15986 15987 return tiSuccess; 15988 15989 } 15990 15991 } 15992 15993 /*****************************************************************************/ 15994 /*! \brief SAT implementation for SCSI satReadBuffer. 15995 * 15996 * SAT implementation for SCSI Read Buffer. 15997 * 15998 * \param tiRoot: Pointer to TISA initiator driver/port instance. 15999 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 16000 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 16001 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 16002 * \param satIOContext_t: Pointer to the SAT IO Context 16003 * 16004 * \return If command is started successfully 16005 * - \e tiSuccess: I/O request successfully initiated. 16006 * - \e tiBusy: No resources available, try again later. 16007 * - \e tiIONoDevice: Invalid device handle. 16008 * - \e tiError: Other errors. 16009 */ 16010 /*****************************************************************************/ 16011 /* SAT-2, Revision 00*/ 16012 GLOBAL bit32 satReadBuffer( 16013 tiRoot_t *tiRoot, 16014 tiIORequest_t *tiIORequest, 16015 tiDeviceHandle_t *tiDeviceHandle, 16016 tiScsiInitiatorRequest_t *tiScsiRequest, 16017 satIOContext_t *satIOContext) 16018 { 16019 bit32 status = tiSuccess; 16020 bit32 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 16021 scsiRspSense_t *pSense; 16022 tiIniScsiCmnd_t *scsiCmnd; 16023 agsaFisRegHostToDevice_t *fis; 16024 bit32 bufferOffset; 16025 bit32 tl; 16026 bit8 mode; 16027 bit8 bufferID; 16028 bit8 *pBuff; 16029 16030 pSense = satIOContext->pSense; 16031 scsiCmnd = &tiScsiRequest->scsiCmnd; 16032 fis = satIOContext->pFis; 16033 pBuff = (bit8 *) tiScsiRequest->sglVirtualAddr; 16034 16035 TI_DBG2(("satReadBuffer: start\n")); 16036 /* checking CONTROL */ 16037 /* NACA == 1 or LINK == 1*/ 16038 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 16039 { 16040 satSetSensePayload( pSense, 16041 SCSI_SNSKEY_ILLEGAL_REQUEST, 16042 0, 16043 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 16044 satIOContext); 16045 ostiInitiatorIOCompleted( tiRoot, 16046 tiIORequest, 16047 tiIOSuccess, 16048 SCSI_STAT_CHECK_CONDITION, 16049 satIOContext->pTiSenseData, 16050 satIOContext->interruptContext ); 16051 TI_DBG1(("satReadBuffer: return control\n")); 16052 return tiSuccess; 16053 } 16054 16055 bufferOffset = (scsiCmnd->cdb[3] << (8*2)) + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 16056 tl = (scsiCmnd->cdb[6] << (8*2)) + (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 16057 16058 mode = (bit8)(scsiCmnd->cdb[1] & SCSI_READ_BUFFER_MODE_MASK); 16059 bufferID = scsiCmnd->cdb[2]; 16060 16061 if (mode == READ_BUFFER_DATA_MODE) /* 2 */ 16062 { 16063 if (bufferID == 0 && bufferOffset == 0 && tl == 512) 16064 { 16065 /* send ATA READ BUFFER */ 16066 fis->h.fisType = 0x27; /* Reg host to device */ 16067 fis->h.c_pmPort = 0x80; /* C Bit is set */ 16068 fis->h.command = SAT_READ_BUFFER; /* 0xE4 */ 16069 fis->h.features = 0; /* FIS reserve */ 16070 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 16071 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 16072 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 16073 fis->d.device = 0x40; /* FIS LBA (27:24) and FIS LBA mode */ 16074 fis->d.lbaLowExp = 0; 16075 fis->d.lbaMidExp = 0; 16076 fis->d.lbaHighExp = 0; 16077 fis->d.featuresExp = 0; 16078 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 16079 fis->d.sectorCountExp = 0; 16080 fis->d.reserved4 = 0; 16081 fis->d.control = 0; /* FIS HOB bit clear */ 16082 fis->d.reserved5 = 0; 16083 16084 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 16085 satIOContext->satCompleteCB = &satReadBufferCB; 16086 satIOContext->reqType = agRequestType; /* Save it */ 16087 16088 status = sataLLIOStart( tiRoot, 16089 tiIORequest, 16090 tiDeviceHandle, 16091 tiScsiRequest, 16092 satIOContext); 16093 return status; 16094 } 16095 if (bufferID == 0 && bufferOffset == 0 && tl != 512) 16096 { 16097 satSetSensePayload( pSense, 16098 SCSI_SNSKEY_ILLEGAL_REQUEST, 16099 0, 16100 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 16101 satIOContext); 16102 ostiInitiatorIOCompleted( tiRoot, 16103 tiIORequest, 16104 tiIOSuccess, 16105 SCSI_STAT_CHECK_CONDITION, 16106 satIOContext->pTiSenseData, 16107 satIOContext->interruptContext ); 16108 TI_DBG1(("satReadBuffer: allocation length is not 512; it is %d\n", tl)); 16109 return tiSuccess; 16110 } 16111 if (bufferID == 0 && bufferOffset != 0) 16112 { 16113 satSetSensePayload( pSense, 16114 SCSI_SNSKEY_ILLEGAL_REQUEST, 16115 0, 16116 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 16117 satIOContext); 16118 ostiInitiatorIOCompleted( tiRoot, 16119 tiIORequest, 16120 tiIOSuccess, 16121 SCSI_STAT_CHECK_CONDITION, 16122 satIOContext->pTiSenseData, 16123 satIOContext->interruptContext ); 16124 TI_DBG1(("satReadBuffer: buffer offset is not 0; it is %d\n", bufferOffset)); 16125 return tiSuccess; 16126 } 16127 /* all other cases unsupported */ 16128 TI_DBG1(("satReadBuffer: unsupported case 1\n")); 16129 satSetSensePayload( pSense, 16130 SCSI_SNSKEY_ILLEGAL_REQUEST, 16131 0, 16132 SCSI_SNSCODE_INVALID_COMMAND, 16133 satIOContext); 16134 16135 ostiInitiatorIOCompleted( tiRoot, 16136 tiIORequest, 16137 tiIOSuccess, 16138 SCSI_STAT_CHECK_CONDITION, 16139 satIOContext->pTiSenseData, 16140 satIOContext->interruptContext ); 16141 return tiSuccess; 16142 } 16143 else if (mode == READ_BUFFER_DESCRIPTOR_MODE) /* 3 */ 16144 { 16145 if (tl < READ_BUFFER_DESCRIPTOR_MODE_DATA_LEN) /* 4 */ 16146 { 16147 satSetSensePayload( pSense, 16148 SCSI_SNSKEY_ILLEGAL_REQUEST, 16149 0, 16150 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 16151 satIOContext); 16152 ostiInitiatorIOCompleted( tiRoot, 16153 tiIORequest, 16154 tiIOSuccess, 16155 SCSI_STAT_CHECK_CONDITION, 16156 satIOContext->pTiSenseData, 16157 satIOContext->interruptContext ); 16158 TI_DBG1(("satReadBuffer: tl < 4; tl is %d\n", tl)); 16159 return tiSuccess; 16160 } 16161 if (bufferID == 0) 16162 { 16163 /* SPC-4, 6.15.5, p189; SAT-2 Rev00, 8.7.2.3, p41*/ 16164 pBuff[0] = 0xFF; 16165 pBuff[1] = 0x00; 16166 pBuff[2] = 0x02; 16167 pBuff[3] = 0x00; 16168 if (READ_BUFFER_DESCRIPTOR_MODE_DATA_LEN < tl) 16169 { 16170 /* underrrun */ 16171 TI_DBG1(("satReadBuffer: underrun tl %d data %d\n", tl, READ_BUFFER_DESCRIPTOR_MODE_DATA_LEN)); 16172 ostiInitiatorIOCompleted( tiRoot, 16173 tiIORequest, 16174 tiIOUnderRun, 16175 tl - READ_BUFFER_DESCRIPTOR_MODE_DATA_LEN, 16176 agNULL, 16177 satIOContext->interruptContext ); 16178 return tiSuccess; 16179 } 16180 else 16181 { 16182 ostiInitiatorIOCompleted( tiRoot, 16183 tiIORequest, 16184 tiIOSuccess, 16185 SCSI_STAT_GOOD, 16186 agNULL, 16187 satIOContext->interruptContext); 16188 return tiSuccess; 16189 } 16190 } 16191 else 16192 { 16193 /* We don't support other than bufferID 0 */ 16194 satSetSensePayload( pSense, 16195 SCSI_SNSKEY_ILLEGAL_REQUEST, 16196 0, 16197 SCSI_SNSCODE_INVALID_COMMAND, 16198 satIOContext); 16199 16200 ostiInitiatorIOCompleted( tiRoot, 16201 tiIORequest, 16202 tiIOSuccess, 16203 SCSI_STAT_CHECK_CONDITION, 16204 satIOContext->pTiSenseData, 16205 satIOContext->interruptContext ); 16206 return tiSuccess; 16207 } 16208 } 16209 else 16210 { 16211 /* We don't support any other mode */ 16212 TI_DBG1(("satReadBuffer: unsupported mode %d\n", mode)); 16213 satSetSensePayload( pSense, 16214 SCSI_SNSKEY_ILLEGAL_REQUEST, 16215 0, 16216 SCSI_SNSCODE_INVALID_COMMAND, 16217 satIOContext); 16218 16219 ostiInitiatorIOCompleted( tiRoot, 16220 tiIORequest, 16221 tiIOSuccess, 16222 SCSI_STAT_CHECK_CONDITION, 16223 satIOContext->pTiSenseData, 16224 satIOContext->interruptContext ); 16225 return tiSuccess; 16226 } 16227 } 16228 16229 /*****************************************************************************/ 16230 /*! \brief SAT implementation for SCSI satWriteBuffer. 16231 * 16232 * SAT implementation for SCSI Write Buffer. 16233 * 16234 * \param tiRoot: Pointer to TISA initiator driver/port instance. 16235 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 16236 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 16237 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 16238 * \param satIOContext_t: Pointer to the SAT IO Context 16239 * 16240 * \return If command is started successfully 16241 * - \e tiSuccess: I/O request successfully initiated. 16242 * - \e tiBusy: No resources available, try again later. 16243 * - \e tiIONoDevice: Invalid device handle. 16244 * - \e tiError: Other errors. 16245 */ 16246 /*****************************************************************************/ 16247 /* SAT-2, Revision 00*/ 16248 GLOBAL bit32 satWriteBuffer( 16249 tiRoot_t *tiRoot, 16250 tiIORequest_t *tiIORequest, 16251 tiDeviceHandle_t *tiDeviceHandle, 16252 tiScsiInitiatorRequest_t *tiScsiRequest, 16253 satIOContext_t *satIOContext) 16254 { 16255 #ifdef NOT_YET 16256 bit32 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 16257 #endif 16258 scsiRspSense_t *pSense; 16259 tiIniScsiCmnd_t *scsiCmnd; 16260 bit32 bufferOffset; 16261 bit32 parmLen; 16262 bit8 mode; 16263 bit8 bufferID; 16264 bit8 *pBuff; 16265 16266 pSense = satIOContext->pSense; 16267 scsiCmnd = &tiScsiRequest->scsiCmnd; 16268 pBuff = (bit8 *) tiScsiRequest->sglVirtualAddr; 16269 16270 TI_DBG2(("satWriteBuffer: start\n")); 16271 16272 /* checking CONTROL */ 16273 /* NACA == 1 or LINK == 1*/ 16274 if ( (scsiCmnd->cdb[9] & SCSI_NACA_MASK) || (scsiCmnd->cdb[9] & SCSI_LINK_MASK) ) 16275 { 16276 satSetSensePayload( pSense, 16277 SCSI_SNSKEY_ILLEGAL_REQUEST, 16278 0, 16279 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 16280 satIOContext); 16281 16282 ostiInitiatorIOCompleted( tiRoot, 16283 tiIORequest, 16284 tiIOSuccess, 16285 SCSI_STAT_CHECK_CONDITION, 16286 satIOContext->pTiSenseData, 16287 satIOContext->interruptContext ); 16288 16289 TI_DBG1(("satWriteBuffer: return control\n")); 16290 return tiSuccess; 16291 } 16292 16293 bufferOffset = (scsiCmnd->cdb[3] << (8*2)) + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 16294 parmLen = (scsiCmnd->cdb[6] << (8*2)) + (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 16295 16296 mode = (bit8)(scsiCmnd->cdb[1] & SCSI_READ_BUFFER_MODE_MASK); 16297 bufferID = scsiCmnd->cdb[2]; 16298 16299 /* for debugging only */ 16300 tdhexdump("satWriteBuffer pBuff", (bit8 *)pBuff, 24); 16301 16302 if (mode == WRITE_BUFFER_DATA_MODE) /* 2 */ 16303 { 16304 if (bufferID == 0 && bufferOffset == 0 && parmLen == 512) 16305 { 16306 TI_DBG1(("satWriteBuffer: sending ATA WRITE BUFFER\n")); 16307 /* send ATA WRITE BUFFER */ 16308 #ifdef NOT_YET 16309 fis->h.fisType = 0x27; /* Reg host to device */ 16310 fis->h.c_pmPort = 0x80; /* C Bit is set */ 16311 fis->h.command = SAT_WRITE_BUFFER; /* 0xE8 */ 16312 fis->h.features = 0; /* FIS reserve */ 16313 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 16314 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 16315 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 16316 fis->d.device = 0x40; /* FIS LBA (27:24) and FIS LBA mode */ 16317 fis->d.lbaLowExp = 0; 16318 fis->d.lbaMidExp = 0; 16319 fis->d.lbaHighExp = 0; 16320 fis->d.featuresExp = 0; 16321 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 16322 fis->d.sectorCountExp = 0; 16323 fis->d.reserved4 = 0; 16324 fis->d.control = 0; /* FIS HOB bit clear */ 16325 fis->d.reserved5 = 0; 16326 16327 16328 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 16329 16330 satIOContext->satCompleteCB = &satWriteBufferCB; 16331 16332 satIOContext->reqType = agRequestType; /* Save it */ 16333 16334 status = sataLLIOStart( tiRoot, 16335 tiIORequest, 16336 tiDeviceHandle, 16337 tiScsiRequest, 16338 satIOContext); 16339 return status; 16340 #endif 16341 /* temp */ 16342 ostiInitiatorIOCompleted( tiRoot, 16343 tiIORequest, 16344 tiIOSuccess, 16345 SCSI_STAT_GOOD, 16346 agNULL, 16347 satIOContext->interruptContext); 16348 return tiSuccess; 16349 } 16350 if ( (bufferID == 0 && bufferOffset != 0) || 16351 (bufferID == 0 && parmLen != 512) 16352 ) 16353 { 16354 satSetSensePayload( pSense, 16355 SCSI_SNSKEY_ILLEGAL_REQUEST, 16356 0, 16357 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 16358 satIOContext); 16359 16360 ostiInitiatorIOCompleted( tiRoot, 16361 tiIORequest, 16362 tiIOSuccess, 16363 SCSI_STAT_CHECK_CONDITION, 16364 satIOContext->pTiSenseData, 16365 satIOContext->interruptContext ); 16366 16367 TI_DBG1(("satWriteBuffer: wrong buffer offset %d or parameter length parmLen %d\n", bufferOffset, parmLen)); 16368 return tiSuccess; 16369 } 16370 16371 /* all other cases unsupported */ 16372 TI_DBG1(("satWriteBuffer: unsupported case 1\n")); 16373 satSetSensePayload( pSense, 16374 SCSI_SNSKEY_ILLEGAL_REQUEST, 16375 0, 16376 SCSI_SNSCODE_INVALID_COMMAND, 16377 satIOContext); 16378 16379 ostiInitiatorIOCompleted( tiRoot, 16380 tiIORequest, 16381 tiIOSuccess, 16382 SCSI_STAT_CHECK_CONDITION, 16383 satIOContext->pTiSenseData, 16384 satIOContext->interruptContext ); 16385 16386 return tiSuccess; 16387 16388 } 16389 else if (mode == WRITE_BUFFER_DL_MICROCODE_SAVE_MODE) /* 5 */ 16390 { 16391 TI_DBG1(("satWriteBuffer: not yet supported mode %d\n", mode)); 16392 satSetSensePayload( pSense, 16393 SCSI_SNSKEY_ILLEGAL_REQUEST, 16394 0, 16395 SCSI_SNSCODE_INVALID_COMMAND, 16396 satIOContext); 16397 16398 ostiInitiatorIOCompleted( tiRoot, 16399 tiIORequest, 16400 tiIOSuccess, 16401 SCSI_STAT_CHECK_CONDITION, 16402 satIOContext->pTiSenseData, 16403 satIOContext->interruptContext ); 16404 16405 return tiSuccess; 16406 } 16407 else 16408 { 16409 /* We don't support any other mode */ 16410 TI_DBG1(("satWriteBuffer: unsupported mode %d\n", mode)); 16411 satSetSensePayload( pSense, 16412 SCSI_SNSKEY_ILLEGAL_REQUEST, 16413 0, 16414 SCSI_SNSCODE_INVALID_COMMAND, 16415 satIOContext); 16416 16417 ostiInitiatorIOCompleted( tiRoot, 16418 tiIORequest, 16419 tiIOSuccess, 16420 SCSI_STAT_CHECK_CONDITION, 16421 satIOContext->pTiSenseData, 16422 satIOContext->interruptContext ); 16423 16424 return tiSuccess; 16425 } 16426 16427 } 16428 16429 /*****************************************************************************/ 16430 /*! \brief SAT implementation for SCSI satReassignBlocks. 16431 * 16432 * SAT implementation for SCSI Reassign Blocks. 16433 * 16434 * \param tiRoot: Pointer to TISA initiator driver/port instance. 16435 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 16436 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 16437 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 16438 * \param satIOContext_t: Pointer to the SAT IO Context 16439 * 16440 * \return If command is started successfully 16441 * - \e tiSuccess: I/O request successfully initiated. 16442 * - \e tiBusy: No resources available, try again later. 16443 * - \e tiIONoDevice: Invalid device handle. 16444 * - \e tiError: Other errors. 16445 */ 16446 /*****************************************************************************/ 16447 GLOBAL bit32 satReassignBlocks( 16448 tiRoot_t *tiRoot, 16449 tiIORequest_t *tiIORequest, 16450 tiDeviceHandle_t *tiDeviceHandle, 16451 tiScsiInitiatorRequest_t *tiScsiRequest, 16452 satIOContext_t *satIOContext) 16453 { 16454 /* 16455 assumes all LBA fits in ATA command; no boundary condition is checked here yet 16456 */ 16457 bit32 status; 16458 bit32 agRequestType; 16459 satDeviceData_t *pSatDevData; 16460 scsiRspSense_t *pSense; 16461 tiIniScsiCmnd_t *scsiCmnd; 16462 agsaFisRegHostToDevice_t *fis; 16463 bit8 *pParmList; /* Log Page data buffer */ 16464 bit8 LongLBA; 16465 bit8 LongList; 16466 bit32 defectListLen; 16467 bit8 LBA[8]; 16468 bit32 startingIndex; 16469 16470 pSense = satIOContext->pSense; 16471 pSatDevData = satIOContext->pSatDevData; 16472 scsiCmnd = &tiScsiRequest->scsiCmnd; 16473 fis = satIOContext->pFis; 16474 pParmList = (bit8 *) tiScsiRequest->sglVirtualAddr; 16475 16476 TI_DBG5(("satReassignBlocks: start\n")); 16477 16478 /* checking CONTROL */ 16479 /* NACA == 1 or LINK == 1*/ 16480 if ( (scsiCmnd->cdb[5] & SCSI_NACA_MASK) || (scsiCmnd->cdb[5] & SCSI_LINK_MASK) ) 16481 { 16482 satSetSensePayload( pSense, 16483 SCSI_SNSKEY_ILLEGAL_REQUEST, 16484 0, 16485 SCSI_SNSCODE_INVALID_FIELD_IN_CDB, 16486 satIOContext); 16487 16488 ostiInitiatorIOCompleted( tiRoot, 16489 tiIORequest, 16490 tiIOSuccess, 16491 SCSI_STAT_CHECK_CONDITION, 16492 satIOContext->pTiSenseData, 16493 satIOContext->interruptContext ); 16494 16495 TI_DBG1(("satReassignBlocks: return control\n")); 16496 return tiSuccess; 16497 } 16498 16499 osti_memset(satIOContext->LBA, 0, 8); 16500 satIOContext->ParmIndex = 0; 16501 satIOContext->ParmLen = 0; 16502 16503 LongList = (bit8)(scsiCmnd->cdb[1] & SCSI_REASSIGN_BLOCKS_LONGLIST_MASK); 16504 LongLBA = (bit8)(scsiCmnd->cdb[1] & SCSI_REASSIGN_BLOCKS_LONGLBA_MASK); 16505 osti_memset(LBA, 0, sizeof(LBA)); 16506 16507 if (LongList == 0) 16508 { 16509 defectListLen = (pParmList[2] << 8) + pParmList[3]; 16510 } 16511 else 16512 { 16513 defectListLen = (pParmList[0] << (8*3)) + (pParmList[1] << (8*2)) 16514 + (pParmList[2] << 8) + pParmList[3]; 16515 } 16516 /* SBC 5.16.2, p61*/ 16517 satIOContext->ParmLen = defectListLen + 4 /* header size */; 16518 16519 startingIndex = 4; 16520 16521 if (LongLBA == 0) 16522 { 16523 LBA[4] = pParmList[startingIndex]; /* MSB */ 16524 LBA[5] = pParmList[startingIndex+1]; 16525 LBA[6] = pParmList[startingIndex+2]; 16526 LBA[7] = pParmList[startingIndex+3]; /* LSB */ 16527 startingIndex = startingIndex + 4; 16528 } 16529 else 16530 { 16531 LBA[0] = pParmList[startingIndex]; /* MSB */ 16532 LBA[1] = pParmList[startingIndex+1]; 16533 LBA[2] = pParmList[startingIndex+2]; 16534 LBA[3] = pParmList[startingIndex+3]; 16535 LBA[4] = pParmList[startingIndex+4]; 16536 LBA[5] = pParmList[startingIndex+5]; 16537 LBA[6] = pParmList[startingIndex+6]; 16538 LBA[7] = pParmList[startingIndex+7]; /* LSB */ 16539 startingIndex = startingIndex + 8; 16540 } 16541 16542 tdhexdump("satReassignBlocks Parameter list", (bit8 *)pParmList, 4 + defectListLen); 16543 16544 if (pSatDevData->sat48BitSupport == agTRUE) 16545 { 16546 /* sends READ VERIFY SECTOR(S) EXT*/ 16547 fis->h.fisType = 0x27; /* Reg host to device */ 16548 fis->h.c_pmPort = 0x80; /* C Bit is set */ 16549 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 16550 fis->h.features = 0; /* FIS reserve */ 16551 fis->d.lbaLow = LBA[7]; /* FIS LBA (7 :0 ) */ 16552 fis->d.lbaMid = LBA[6]; /* FIS LBA (15:8 ) */ 16553 fis->d.lbaHigh = LBA[5]; /* FIS LBA (23:16) */ 16554 fis->d.lbaLowExp = LBA[4]; /* FIS LBA (31:24) */ 16555 fis->d.lbaMidExp = LBA[3]; /* FIS LBA (39:32) */ 16556 fis->d.lbaHighExp = LBA[2]; /* FIS LBA (47:40) */ 16557 fis->d.featuresExp = 0; /* FIS reserve */ 16558 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 16559 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 16560 fis->d.reserved4 = 0; 16561 fis->d.device = 0x40; /* 01000000 */ 16562 fis->d.control = 0; /* FIS HOB bit clear */ 16563 fis->d.reserved5 = 0; 16564 } 16565 else 16566 { 16567 /* READ VERIFY SECTOR(S)*/ 16568 fis->h.fisType = 0x27; /* Reg host to device */ 16569 fis->h.c_pmPort = 0x80; /* C Bit is set */ 16570 fis->h.command = SAT_READ_VERIFY_SECTORS;/* 0x40 */ 16571 fis->h.features = 0; /* FIS features NA */ 16572 fis->d.lbaLow = LBA[7]; /* FIS LBA (7 :0 ) */ 16573 fis->d.lbaMid = LBA[6]; /* FIS LBA (15:8 ) */ 16574 fis->d.lbaHigh = LBA[5]; /* FIS LBA (23:16) */ 16575 fis->d.lbaLowExp = 0; 16576 fis->d.lbaMidExp = 0; 16577 fis->d.lbaHighExp = 0; 16578 fis->d.featuresExp = 0; 16579 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 16580 fis->d.sectorCountExp = 0; 16581 fis->d.reserved4 = 0; 16582 fis->d.device = (bit8)((0x4 << 4) | (LBA[4] & 0xF)); 16583 /* DEV and LBA 27:24 */ 16584 fis->d.control = 0; /* FIS HOB bit clear */ 16585 fis->d.reserved5 = 0; 16586 } 16587 16588 osti_memcpy(satIOContext->LBA, LBA, 8); 16589 satIOContext->ParmIndex = startingIndex; 16590 16591 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 16592 16593 /* Initialize CB for SATA completion. 16594 */ 16595 satIOContext->satCompleteCB = &satReassignBlocksCB; 16596 16597 /* 16598 * Prepare SGL and send FIS to LL layer. 16599 */ 16600 satIOContext->reqType = agRequestType; /* Save it */ 16601 16602 status = sataLLIOStart( tiRoot, 16603 tiIORequest, 16604 tiDeviceHandle, 16605 tiScsiRequest, 16606 satIOContext); 16607 16608 return status; 16609 } 16610 16611 /*****************************************************************************/ 16612 /*! \brief SAT implementation for SCSI satReassignBlocks_1. 16613 * 16614 * SAT implementation for SCSI Reassign Blocks. This is helper function for 16615 * satReassignBlocks and satReassignBlocksCB. This sends ATA verify command. 16616 * 16617 * \param tiRoot: Pointer to TISA initiator driver/port instance. 16618 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 16619 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 16620 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 16621 * \param satIOContext_t: Pointer to the SAT IO Context 16622 * 16623 * \return If command is started successfully 16624 * - \e tiSuccess: I/O request successfully initiated. 16625 * - \e tiBusy: No resources available, try again later. 16626 * - \e tiIONoDevice: Invalid device handle. 16627 * - \e tiError: Other errors. 16628 */ 16629 /*****************************************************************************/ 16630 /* next LBA; sends READ VERIFY SECTOR; update LBA and ParmIdx */ 16631 GLOBAL bit32 satReassignBlocks_1( 16632 tiRoot_t *tiRoot, 16633 tiIORequest_t *tiIORequest, 16634 tiDeviceHandle_t *tiDeviceHandle, 16635 tiScsiInitiatorRequest_t *tiScsiRequest, 16636 satIOContext_t *satIOContext, 16637 satIOContext_t *satOrgIOContext 16638 ) 16639 { 16640 /* 16641 assumes all LBA fits in ATA command; no boundary condition is checked here yet 16642 tiScsiRequest is OS generated; needs for accessing parameter list 16643 */ 16644 bit32 agRequestType; 16645 satDeviceData_t *pSatDevData; 16646 tiIniScsiCmnd_t *scsiCmnd; 16647 agsaFisRegHostToDevice_t *fis; 16648 bit8 *pParmList; /* Log Page data buffer */ 16649 bit8 LongLBA; 16650 bit8 LBA[8]; 16651 bit32 startingIndex; 16652 16653 pSatDevData = satIOContext->pSatDevData; 16654 scsiCmnd = &tiScsiRequest->scsiCmnd; 16655 fis = satIOContext->pFis; 16656 pParmList = (bit8 *) tiScsiRequest->sglVirtualAddr; 16657 16658 TI_DBG5(("satReassignBlocks_1: start\n")); 16659 16660 LongLBA = (bit8)(scsiCmnd->cdb[1] & SCSI_REASSIGN_BLOCKS_LONGLBA_MASK); 16661 osti_memset(LBA, 0, sizeof(LBA)); 16662 16663 startingIndex = satOrgIOContext->ParmIndex; 16664 16665 if (LongLBA == 0) 16666 { 16667 LBA[4] = pParmList[startingIndex]; 16668 LBA[5] = pParmList[startingIndex+1]; 16669 LBA[6] = pParmList[startingIndex+2]; 16670 LBA[7] = pParmList[startingIndex+3]; 16671 startingIndex = startingIndex + 4; 16672 } 16673 else 16674 { 16675 LBA[0] = pParmList[startingIndex]; 16676 LBA[1] = pParmList[startingIndex+1]; 16677 LBA[2] = pParmList[startingIndex+2]; 16678 LBA[3] = pParmList[startingIndex+3]; 16679 LBA[4] = pParmList[startingIndex+4]; 16680 LBA[5] = pParmList[startingIndex+5]; 16681 LBA[6] = pParmList[startingIndex+6]; 16682 LBA[7] = pParmList[startingIndex+7]; 16683 startingIndex = startingIndex + 8; 16684 } 16685 16686 if (pSatDevData->sat48BitSupport == agTRUE) 16687 { 16688 /* sends READ VERIFY SECTOR(S) EXT*/ 16689 fis->h.fisType = 0x27; /* Reg host to device */ 16690 fis->h.c_pmPort = 0x80; /* C Bit is set */ 16691 fis->h.command = SAT_READ_VERIFY_SECTORS_EXT;/* 0x42 */ 16692 fis->h.features = 0; /* FIS reserve */ 16693 fis->d.lbaLow = LBA[7]; /* FIS LBA (7 :0 ) */ 16694 fis->d.lbaMid = LBA[6]; /* FIS LBA (15:8 ) */ 16695 fis->d.lbaHigh = LBA[5]; /* FIS LBA (23:16) */ 16696 fis->d.lbaLowExp = LBA[4]; /* FIS LBA (31:24) */ 16697 fis->d.lbaMidExp = LBA[3]; /* FIS LBA (39:32) */ 16698 fis->d.lbaHighExp = LBA[2]; /* FIS LBA (47:40) */ 16699 fis->d.featuresExp = 0; /* FIS reserve */ 16700 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 16701 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 16702 fis->d.reserved4 = 0; 16703 fis->d.device = 0x40; /* 01000000 */ 16704 fis->d.control = 0; /* FIS HOB bit clear */ 16705 fis->d.reserved5 = 0; 16706 } 16707 else 16708 { 16709 /* READ VERIFY SECTOR(S)*/ 16710 fis->h.fisType = 0x27; /* Reg host to device */ 16711 fis->h.c_pmPort = 0x80; /* C Bit is set */ 16712 fis->h.command = SAT_READ_VERIFY_SECTORS;/* 0x40 */ 16713 fis->h.features = 0; /* FIS features NA */ 16714 fis->d.lbaLow = LBA[7]; /* FIS LBA (7 :0 ) */ 16715 fis->d.lbaMid = LBA[6]; /* FIS LBA (15:8 ) */ 16716 fis->d.lbaHigh = LBA[5]; /* FIS LBA (23:16) */ 16717 fis->d.lbaLowExp = 0; 16718 fis->d.lbaMidExp = 0; 16719 fis->d.lbaHighExp = 0; 16720 fis->d.featuresExp = 0; 16721 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 16722 fis->d.sectorCountExp = 0; 16723 fis->d.reserved4 = 0; 16724 fis->d.device = (bit8)((0x4 << 4) | (LBA[4] & 0xF)); 16725 /* DEV and LBA 27:24 */ 16726 fis->d.control = 0; /* FIS HOB bit clear */ 16727 fis->d.reserved5 = 0; 16728 } 16729 osti_memcpy(satOrgIOContext->LBA, LBA, 8); 16730 satOrgIOContext->ParmIndex = startingIndex; 16731 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 16732 /* Initialize CB for SATA completion. 16733 */ 16734 satIOContext->satCompleteCB = &satReassignBlocksCB; 16735 /* 16736 * Prepare SGL and send FIS to LL layer. 16737 */ 16738 satIOContext->reqType = agRequestType; /* Save it */ 16739 16740 sataLLIOStart( tiRoot, 16741 tiIORequest, 16742 tiDeviceHandle, 16743 tiScsiRequest, 16744 satIOContext ); 16745 return tiSuccess; 16746 } 16747 16748 /*****************************************************************************/ 16749 /*! \brief SAT implementation for SCSI satReassignBlocks_2. 16750 * 16751 * SAT implementation for SCSI Reassign Blocks. This is helper function for 16752 * satReassignBlocks and satReassignBlocksCB. This sends ATA write command. 16753 * 16754 * \param tiRoot: Pointer to TISA initiator driver/port instance. 16755 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 16756 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 16757 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 16758 * \param satIOContext_t: Pointer to the SAT IO Context 16759 * \param LBA: Pointer to the LBA to be processed 16760 * 16761 * \return If command is started successfully 16762 * - \e tiSuccess: I/O request successfully initiated. 16763 * - \e tiBusy: No resources available, try again later. 16764 * - \e tiIONoDevice: Invalid device handle. 16765 * - \e tiError: Other errors. 16766 */ 16767 /*****************************************************************************/ 16768 /* current LBA; sends WRITE */ 16769 GLOBAL bit32 satReassignBlocks_2( 16770 tiRoot_t *tiRoot, 16771 tiIORequest_t *tiIORequest, 16772 tiDeviceHandle_t *tiDeviceHandle, 16773 tiScsiInitiatorRequest_t *tiScsiRequest, 16774 satIOContext_t *satIOContext, 16775 bit8 *LBA 16776 ) 16777 { 16778 /* 16779 assumes all LBA fits in ATA command; no boundary condition is checked here yet 16780 tiScsiRequest is TD generated for writing 16781 */ 16782 bit32 status; 16783 bit32 agRequestType; 16784 satDeviceData_t *pSatDevData; 16785 scsiRspSense_t *pSense; 16786 agsaFisRegHostToDevice_t *fis; 16787 16788 pSense = satIOContext->pSense; 16789 pSatDevData = satIOContext->pSatDevData; 16790 fis = satIOContext->pFis; 16791 16792 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 16793 { 16794 /* case 2 */ 16795 /* WRITE DMA*/ 16796 /* can't fit the transfer length */ 16797 TI_DBG5(("satReassignBlocks_2: case 2\n")); 16798 fis->h.fisType = 0x27; /* Reg host to device */ 16799 fis->h.c_pmPort = 0x80; /* C bit is set */ 16800 fis->h.command = SAT_WRITE_DMA; /* 0xCA */ 16801 fis->h.features = 0; /* FIS reserve */ 16802 fis->d.lbaLow = LBA[7]; /* FIS LBA (7 :0 ) */ 16803 fis->d.lbaMid = LBA[6]; /* FIS LBA (15:8 ) */ 16804 fis->d.lbaHigh = LBA[5]; /* FIS LBA (23:16) */ 16805 16806 /* FIS LBA mode set LBA (27:24) */ 16807 fis->d.device = (bit8)((0x4 << 4) | (LBA[4] & 0xF)); 16808 16809 fis->d.lbaLowExp = 0; 16810 fis->d.lbaMidExp = 0; 16811 fis->d.lbaHighExp = 0; 16812 fis->d.featuresExp = 0; 16813 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 16814 fis->d.sectorCountExp = 0; 16815 fis->d.reserved4 = 0; 16816 fis->d.control = 0; /* FIS HOB bit clear */ 16817 fis->d.reserved5 = 0; 16818 16819 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 16820 satIOContext->ATACmd = SAT_WRITE_DMA; 16821 } 16822 else 16823 { 16824 /* case 1 */ 16825 /* WRITE MULTIPLE or WRITE SECTOR(S) */ 16826 /* WRITE SECTORS for easier implemetation */ 16827 /* can't fit the transfer length */ 16828 TI_DBG5(("satReassignBlocks_2: case 1\n")); 16829 fis->h.fisType = 0x27; /* Reg host to device */ 16830 fis->h.c_pmPort = 0x80; /* C bit is set */ 16831 fis->h.command = SAT_WRITE_SECTORS; /* 0x30 */ 16832 fis->h.features = 0; /* FIS reserve */ 16833 fis->d.lbaLow = LBA[7]; /* FIS LBA (7 :0 ) */ 16834 fis->d.lbaMid = LBA[6]; /* FIS LBA (15:8 ) */ 16835 fis->d.lbaHigh = LBA[7]; /* FIS LBA (23:16) */ 16836 16837 /* FIS LBA mode set LBA (27:24) */ 16838 fis->d.device = (bit8)((0x4 << 4) | (LBA[4] & 0xF)); 16839 16840 fis->d.lbaLowExp = 0; 16841 fis->d.lbaMidExp = 0; 16842 fis->d.lbaHighExp = 0; 16843 fis->d.featuresExp = 0; 16844 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 16845 fis->d.sectorCountExp = 0; 16846 fis->d.reserved4 = 0; 16847 fis->d.control = 0; /* FIS HOB bit clear */ 16848 fis->d.reserved5 = 0; 16849 16850 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 16851 satIOContext->ATACmd = SAT_WRITE_SECTORS; 16852 } 16853 16854 /* case 3 and 4 */ 16855 if (pSatDevData->sat48BitSupport == agTRUE) 16856 { 16857 if (pSatDevData->satDMASupport == agTRUE && pSatDevData->satDMAEnabled == agTRUE) 16858 { 16859 /* case 3 */ 16860 /* WRITE DMA EXT or WRITE DMA FUA EXT */ 16861 TI_DBG5(("satReassignBlocks_2: case 3\n")); 16862 fis->h.fisType = 0x27; /* Reg host to device */ 16863 fis->h.c_pmPort = 0x80; /* C Bit is set */ 16864 16865 /* SAT_WRITE_DMA_FUA_EXT is optional and we don't support it */ 16866 fis->h.command = SAT_WRITE_DMA_EXT; /* 0x35 */ 16867 satIOContext->ATACmd = SAT_WRITE_DMA_EXT; 16868 16869 fis->h.features = 0; /* FIS reserve */ 16870 fis->d.lbaLow = LBA[7]; /* FIS LBA (7 :0 ) */ 16871 fis->d.lbaMid = LBA[6]; /* FIS LBA (15:8 ) */ 16872 fis->d.lbaHigh = LBA[5]; /* FIS LBA (23:16) */ 16873 fis->d.device = 0x40; /* FIS LBA mode set */ 16874 fis->d.lbaLowExp = LBA[4]; /* FIS LBA (31:24) */ 16875 fis->d.lbaMidExp = LBA[3]; /* FIS LBA (39:32) */ 16876 fis->d.lbaHighExp = LBA[2]; /* FIS LBA (47:40) */ 16877 fis->d.featuresExp = 0; /* FIS reserve */ 16878 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 16879 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 16880 fis->d.reserved4 = 0; 16881 fis->d.control = 0; /* FIS HOB bit clear */ 16882 fis->d.reserved5 = 0; 16883 16884 agRequestType = AGSA_SATA_PROTOCOL_DMA_WRITE; 16885 } 16886 else 16887 { 16888 /* case 4 */ 16889 /* WRITE MULTIPLE EXT or WRITE MULTIPLE FUA EXT or WRITE SECTOR(S) EXT */ 16890 /* WRITE SECTORS EXT for easier implemetation */ 16891 TI_DBG5(("satReassignBlocks_2: case 4\n")); 16892 fis->h.fisType = 0x27; /* Reg host to device */ 16893 fis->h.c_pmPort = 0x80; /* C Bit is set */ 16894 fis->h.command = SAT_WRITE_SECTORS_EXT; /* 0x34 */ 16895 16896 fis->h.features = 0; /* FIS reserve */ 16897 fis->d.lbaLow = LBA[7]; /* FIS LBA (7 :0 ) */ 16898 fis->d.lbaMid = LBA[6]; /* FIS LBA (15:8 ) */ 16899 fis->d.lbaHigh = LBA[5]; /* FIS LBA (23:16) */ 16900 fis->d.device = 0x40; /* FIS LBA mode set */ 16901 fis->d.lbaLowExp = LBA[4]; /* FIS LBA (31:24) */ 16902 fis->d.lbaMidExp = LBA[3]; /* FIS LBA (39:32) */ 16903 fis->d.lbaHighExp = LBA[2]; /* FIS LBA (47:40) */ 16904 fis->d.featuresExp = 0; /* FIS reserve */ 16905 fis->d.sectorCount = 1; /* FIS sector count (7:0) */ 16906 fis->d.sectorCountExp = 0; /* FIS sector count (15:8) */ 16907 fis->d.reserved4 = 0; 16908 fis->d.control = 0; /* FIS HOB bit clear */ 16909 fis->d.reserved5 = 0; 16910 16911 agRequestType = AGSA_SATA_PROTOCOL_PIO_WRITE; 16912 satIOContext->ATACmd = SAT_WRITE_SECTORS_EXT; 16913 } 16914 } 16915 /* case 5 */ 16916 if (pSatDevData->satNCQ == agTRUE) 16917 { 16918 /* WRITE FPDMA QUEUED */ 16919 if (pSatDevData->sat48BitSupport != agTRUE) 16920 { 16921 TI_DBG5(("satReassignBlocks_2: case 5 !!! error NCQ but 28 bit address support \n")); 16922 satSetSensePayload( pSense, 16923 SCSI_SNSKEY_HARDWARE_ERROR, 16924 0, 16925 SCSI_SNSCODE_WRITE_ERROR_AUTO_REALLOCATION_FAILED, 16926 satIOContext); 16927 16928 ostiInitiatorIOCompleted( tiRoot, 16929 tiIORequest, 16930 tiIOSuccess, 16931 SCSI_STAT_CHECK_CONDITION, 16932 satIOContext->pTiSenseData, 16933 satIOContext->interruptContext ); 16934 return tiSuccess; 16935 } 16936 TI_DBG6(("satWrite10: case 5\n")); 16937 16938 /* Support 48-bit FPDMA addressing, use WRITE FPDMA QUEUE command */ 16939 16940 fis->h.fisType = 0x27; /* Reg host to device */ 16941 fis->h.c_pmPort = 0x80; /* C Bit is set */ 16942 fis->h.command = SAT_WRITE_FPDMA_QUEUED; /* 0x61 */ 16943 fis->h.features = 1; /* FIS sector count (7:0) */ 16944 fis->d.lbaLow = LBA[7]; /* FIS LBA (7 :0 ) */ 16945 fis->d.lbaMid = LBA[6]; /* FIS LBA (15:8 ) */ 16946 fis->d.lbaHigh = LBA[5]; /* FIS LBA (23:16) */ 16947 16948 /* Check FUA bit */ 16949 fis->d.device = 0x40; /* FIS FUA clear */ 16950 16951 fis->d.lbaLowExp = LBA[4]; /* FIS LBA (31:24) */ 16952 fis->d.lbaMidExp = LBA[3]; /* FIS LBA (39:32) */ 16953 fis->d.lbaHighExp = LBA[2]; /* FIS LBA (47:40) */ 16954 fis->d.featuresExp = 0; /* FIS sector count (15:8) */ 16955 fis->d.sectorCount = 0; /* Tag (7:3) set by LL layer */ 16956 fis->d.sectorCountExp = 0; 16957 fis->d.reserved4 = 0; 16958 fis->d.control = 0; /* FIS HOB bit clear */ 16959 fis->d.reserved5 = 0; 16960 16961 agRequestType = AGSA_SATA_PROTOCOL_FPDMA_WRITE; 16962 satIOContext->ATACmd = SAT_WRITE_FPDMA_QUEUED; 16963 } 16964 16965 satIOContext->satCompleteCB = &satReassignBlocksCB; 16966 16967 /* 16968 * Prepare SGL and send FIS to LL layer. 16969 */ 16970 satIOContext->reqType = agRequestType; /* Save it */ 16971 16972 status = sataLLIOStart( tiRoot, 16973 tiIORequest, 16974 tiDeviceHandle, 16975 /* not the original, should be the TD generated one */ 16976 tiScsiRequest, 16977 satIOContext); 16978 return (status); 16979 } 16980 16981 16982 /*****************************************************************************/ 16983 /*! \brief SAT implementation for SCSI satPrepareNewIO. 16984 * 16985 * This function fills in the fields of internal IO generated by TD layer. 16986 * This is mostly used in the callback functions. 16987 * 16988 * \param satNewIntIo: Pointer to the internal IO structure. 16989 * \param tiOrgIORequest: Pointer to the original tiIOrequest sent by OS layer 16990 * \param satDevData: Pointer to the device data. 16991 * \param scsiCmnd: Pointer to SCSI command. 16992 * \param satOrgIOContext: Pointer to the original SAT IO Context 16993 * 16994 * \return 16995 * - \e Pointer to the new SAT IO Context 16996 */ 16997 /*****************************************************************************/ 16998 GLOBAL satIOContext_t *satPrepareNewIO( 16999 satInternalIo_t *satNewIntIo, 17000 tiIORequest_t *tiOrgIORequest, 17001 satDeviceData_t *satDevData, 17002 tiIniScsiCmnd_t *scsiCmnd, 17003 satIOContext_t *satOrgIOContext 17004 ) 17005 { 17006 satIOContext_t *satNewIOContext; 17007 tdIORequestBody_t *tdNewIORequestBody; 17008 17009 TI_DBG2(("satPrepareNewIO: start\n")); 17010 17011 /* the one to be used; good 8/2/07 */ 17012 satNewIntIo->satOrgTiIORequest = tiOrgIORequest; /* this is already done in 17013 satAllocIntIoResource() */ 17014 17015 tdNewIORequestBody = (tdIORequestBody_t *)satNewIntIo->satIntRequestBody; 17016 satNewIOContext = &(tdNewIORequestBody->transport.SATA.satIOContext); 17017 17018 satNewIOContext->pSatDevData = satDevData; 17019 satNewIOContext->pFis = &(tdNewIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 17020 satNewIOContext->pScsiCmnd = &(satNewIntIo->satIntTiScsiXchg.scsiCmnd); 17021 if (scsiCmnd != agNULL) 17022 { 17023 /* saves only CBD; not scsi command for LBA and number of blocks */ 17024 osti_memcpy(satNewIOContext->pScsiCmnd->cdb, scsiCmnd->cdb, 16); 17025 } 17026 satNewIOContext->pSense = &(tdNewIORequestBody->transport.SATA.sensePayload); 17027 satNewIOContext->pTiSenseData = &(tdNewIORequestBody->transport.SATA.tiSenseData); 17028 satNewIOContext->pTiSenseData->senseData = satNewIOContext->pSense; 17029 satNewIOContext->tiRequestBody = satNewIntIo->satIntRequestBody; 17030 satNewIOContext->interruptContext = satNewIOContext->interruptContext; 17031 satNewIOContext->satIntIoContext = satNewIntIo; 17032 satNewIOContext->ptiDeviceHandle = satOrgIOContext->ptiDeviceHandle; 17033 satNewIOContext->satOrgIOContext = satOrgIOContext; 17034 /* saves tiScsiXchg; only for writesame10() */ 17035 satNewIOContext->tiScsiXchg = satOrgIOContext->tiScsiXchg; 17036 17037 return satNewIOContext; 17038 } 17039 /***************************************************************************** 17040 *! \brief satIOAbort 17041 * 17042 * This routine is called to initiate a I/O abort to SATL. 17043 * This routine is independent of HW/LL API. 17044 * 17045 * \param tiRoot: Pointer to TISA initiator driver/port instance. 17046 * \param taskTag: Pointer to TISA I/O request context/tag to be aborted. 17047 * 17048 * \return: 17049 * 17050 * \e tiSuccess: I/O request successfully initiated. 17051 * \e tiBusy: No resources available, try again later. 17052 * \e tiError: Other errors that prevent the I/O request to be started. 17053 * 17054 * 17055 *****************************************************************************/ 17056 GLOBAL bit32 satIOAbort( 17057 tiRoot_t *tiRoot, 17058 tiIORequest_t *taskTag ) 17059 { 17060 17061 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 17062 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 17063 agsaRoot_t *agRoot; 17064 tdIORequestBody_t *tdIORequestBody; 17065 tdIORequestBody_t *tdIONewRequestBody; 17066 agsaIORequest_t *agIORequest; 17067 bit32 status; 17068 agsaIORequest_t *agAbortIORequest; 17069 tdIORequestBody_t *tdAbortIORequestBody; 17070 bit32 PhysUpper32; 17071 bit32 PhysLower32; 17072 bit32 memAllocStatus; 17073 void *osMemHandle; 17074 satIOContext_t *satIOContext; 17075 satInternalIo_t *satIntIo; 17076 17077 TI_DBG2(("satIOAbort: start\n")); 17078 17079 agRoot = &(tdsaAllShared->agRootNonInt); 17080 tdIORequestBody = (tdIORequestBody_t *)taskTag->tdData; 17081 17082 /* needs to distinguish internally generated or externally generated */ 17083 satIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 17084 satIntIo = satIOContext->satIntIoContext; 17085 if (satIntIo == agNULL) 17086 { 17087 TI_DBG1(("satIOAbort: External, OS generated\n")); 17088 agIORequest = &(tdIORequestBody->agIORequest); 17089 } 17090 else 17091 { 17092 TI_DBG1(("satIOAbort: Internal, TD generated\n")); 17093 tdIONewRequestBody = (tdIORequestBody_t *)satIntIo->satIntRequestBody; 17094 agIORequest = &(tdIONewRequestBody->agIORequest); 17095 } 17096 17097 /* allocating agIORequest for abort itself */ 17098 memAllocStatus = ostiAllocMemory( 17099 tiRoot, 17100 &osMemHandle, 17101 (void **)&tdAbortIORequestBody, 17102 &PhysUpper32, 17103 &PhysLower32, 17104 8, 17105 sizeof(tdIORequestBody_t), 17106 agTRUE 17107 ); 17108 if (memAllocStatus != tiSuccess) 17109 { 17110 /* let os process IO */ 17111 TI_DBG1(("satIOAbort: ostiAllocMemory failed...\n")); 17112 return tiError; 17113 } 17114 17115 if (tdAbortIORequestBody == agNULL) 17116 { 17117 /* let os process IO */ 17118 TI_DBG1(("satIOAbort: ostiAllocMemory returned NULL tdAbortIORequestBody\n")); 17119 return tiError; 17120 } 17121 17122 /* setup task management structure */ 17123 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 17124 tdAbortIORequestBody->tiDevHandle = tdIORequestBody->tiDevHandle; 17125 17126 /* initialize agIORequest */ 17127 agAbortIORequest = &(tdAbortIORequestBody->agIORequest); 17128 agAbortIORequest->osData = (void *) tdAbortIORequestBody; 17129 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */ 17130 17131 /* remember IO to be aborted */ 17132 tdAbortIORequestBody->tiIOToBeAbortedRequest = taskTag; 17133 17134 status = saSATAAbort( agRoot, agAbortIORequest, 0, agNULL, 0, agIORequest, agNULL ); 17135 17136 TI_DBG5(("satIOAbort: return status=0x%x\n", status)); 17137 17138 if (status == AGSA_RC_SUCCESS) 17139 return tiSuccess; 17140 else 17141 return tiError; 17142 17143 } 17144 17145 17146 /***************************************************************************** 17147 *! \brief satTM 17148 * 17149 * This routine is called to initiate a TM request to SATL. 17150 * This routine is independent of HW/LL API. 17151 * 17152 * \param tiRoot: Pointer to TISA initiator driver/port instance. 17153 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 17154 * \param task: SAM-3 task management request. 17155 * \param lun: Pointer to LUN. 17156 * \param taskTag: Pointer to the associated task where the TM 17157 * command is to be applied. 17158 * \param currentTaskTag: Pointer to tag/context for this TM request. 17159 * 17160 * \return: 17161 * 17162 * \e tiSuccess: I/O request successfully initiated. 17163 * \e tiBusy: No resources available, try again later. 17164 * \e tiIONoDevice: Invalid device handle. 17165 * \e tiError: Other errors that prevent the I/O request to be started. 17166 * 17167 * 17168 *****************************************************************************/ 17169 /* save task in satIOContext */ 17170 osGLOBAL bit32 satTM( 17171 tiRoot_t *tiRoot, 17172 tiDeviceHandle_t *tiDeviceHandle, 17173 bit32 task, 17174 tiLUN_t *lun, 17175 tiIORequest_t *taskTag, 17176 tiIORequest_t *currentTaskTag, 17177 tdIORequestBody_t *tiRequestBody, 17178 bit32 NotifyOS 17179 ) 17180 { 17181 tdIORequestBody_t *tdIORequestBody = agNULL; 17182 satIOContext_t *satIOContext = agNULL; 17183 tdsaDeviceData_t *oneDeviceData = agNULL; 17184 bit32 status; 17185 17186 TI_DBG3(("satTM: tiDeviceHandle=%p task=0x%x\n", tiDeviceHandle, task )); 17187 17188 /* set satIOContext fields and etc */ 17189 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 17190 17191 17192 tdIORequestBody = (tdIORequestBody_t *)tiRequestBody; 17193 satIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 17194 17195 satIOContext->pSatDevData = &oneDeviceData->satDevData; 17196 satIOContext->pFis = 17197 &tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev; 17198 17199 17200 satIOContext->tiRequestBody = tiRequestBody; 17201 satIOContext->ptiDeviceHandle = tiDeviceHandle; 17202 satIOContext->satIntIoContext = agNULL; 17203 satIOContext->satOrgIOContext = agNULL; 17204 17205 /* followings are used only for internal IO */ 17206 satIOContext->currentLBA = 0; 17207 satIOContext->OrgTL = 0; 17208 17209 /* saving task in satIOContext */ 17210 satIOContext->TMF = task; 17211 17212 satIOContext->satToBeAbortedIOContext = agNULL; 17213 17214 if (NotifyOS == agTRUE) 17215 { 17216 satIOContext->NotifyOS = agTRUE; 17217 } 17218 else 17219 { 17220 satIOContext->NotifyOS = agFALSE; 17221 } 17222 /* 17223 * Our SAT supports RESET LUN and partially support ABORT TASK (only if there 17224 * is no more than one I/O pending on the drive. 17225 */ 17226 17227 if (task == AG_LOGICAL_UNIT_RESET) 17228 { 17229 status = satTmResetLUN( tiRoot, 17230 currentTaskTag, 17231 tiDeviceHandle, 17232 agNULL, 17233 satIOContext, 17234 lun); 17235 return status; 17236 } 17237 #ifdef TO_BE_REMOVED 17238 else if (task == AG_TARGET_WARM_RESET) 17239 { 17240 status = satTmWarmReset( tiRoot, 17241 currentTaskTag, 17242 tiDeviceHandle, 17243 agNULL, 17244 satIOContext); 17245 17246 return status; 17247 } 17248 #endif 17249 else if (task == AG_ABORT_TASK) 17250 { 17251 status = satTmAbortTask( tiRoot, 17252 currentTaskTag, 17253 tiDeviceHandle, 17254 agNULL, 17255 satIOContext, 17256 taskTag); 17257 17258 return status; 17259 } 17260 else if (task == TD_INTERNAL_TM_RESET) 17261 { 17262 status = satTDInternalTmReset( tiRoot, 17263 currentTaskTag, 17264 tiDeviceHandle, 17265 agNULL, 17266 satIOContext); 17267 return status; 17268 } 17269 else 17270 { 17271 TI_DBG1(("satTM: tiDeviceHandle=%p UNSUPPORTED TM task=0x%x\n", 17272 tiDeviceHandle, task )); 17273 17274 /* clean up TD layer's IORequestBody */ 17275 ostiFreeMemory( 17276 tiRoot, 17277 tiRequestBody->IOType.InitiatorTMIO.osMemHandle, 17278 sizeof(tdIORequestBody_t) 17279 ); 17280 return tiError; 17281 } 17282 17283 } 17284 17285 17286 /***************************************************************************** 17287 *! \brief satTmResetLUN 17288 * 17289 * This routine is called to initiate a TM RESET LUN request to SATL. 17290 * This routine is independent of HW/LL API. 17291 * 17292 * \param tiRoot: Pointer to TISA initiator driver/port instance. 17293 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 17294 * \param lun: Pointer to LUN. 17295 * \param currentTaskTag: Pointer to tag/context for this TM request. 17296 * 17297 * \return: 17298 * 17299 * \e tiSuccess: I/O request successfully initiated. 17300 * \e tiBusy: No resources available, try again later. 17301 * \e tiIONoDevice: Invalid device handle. 17302 * \e tiError: Other errors that prevent the I/O request to be started. 17303 * 17304 * 17305 *****************************************************************************/ 17306 osGLOBAL bit32 satTmResetLUN( 17307 tiRoot_t *tiRoot, 17308 tiIORequest_t *tiIORequest, /* current task tag */ 17309 tiDeviceHandle_t *tiDeviceHandle, 17310 tiScsiInitiatorRequest_t *tiScsiRequest, 17311 satIOContext_t *satIOContext, 17312 tiLUN_t *lun) 17313 { 17314 17315 tdsaDeviceData_t *tdsaDeviceData; 17316 satDeviceData_t *satDevData; 17317 17318 tdsaDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 17319 satDevData = &tdsaDeviceData->satDevData; 17320 17321 TI_DBG1(("satTmResetLUN: tiDeviceHandle=%p.\n", tiDeviceHandle )); 17322 17323 /* 17324 * Only support LUN 0 17325 */ 17326 if ( (lun->lun[0] | lun->lun[1] | lun->lun[2] | lun->lun[3] | 17327 lun->lun[4] | lun->lun[5] | lun->lun[6] | lun->lun[7] ) != 0 ) 17328 { 17329 TI_DBG1(("satTmResetLUN: *** REJECT *** LUN not zero, tiDeviceHandle=%p\n", 17330 tiDeviceHandle)); 17331 return tiError; 17332 } 17333 17334 /* 17335 * Check if there is other TM request pending 17336 */ 17337 if (satDevData->satTmTaskTag != agNULL) 17338 { 17339 TI_DBG1(("satTmResetLUN: *** REJECT *** other TM pending, tiDeviceHandle=%p\n", 17340 tiDeviceHandle)); 17341 return tiError; 17342 } 17343 17344 /* 17345 * Save tiIORequest, will be returned at device reset completion to return 17346 * the TM completion. 17347 */ 17348 satDevData->satTmTaskTag = tiIORequest; 17349 17350 /* 17351 * Set flag to indicate device in recovery mode. 17352 */ 17353 satDevData->satDriveState = SAT_DEV_STATE_IN_RECOVERY; 17354 17355 /* 17356 * Issue SATA device reset. Set flag to indicate NOT to automatically abort 17357 * at the completion of SATA device reset. 17358 */ 17359 satDevData->satAbortAfterReset = agFALSE; 17360 17361 /* SAT rev8 6.3.6 p22 */ 17362 satStartResetDevice( 17363 tiRoot, 17364 tiIORequest, /* currentTaskTag */ 17365 tiDeviceHandle, 17366 tiScsiRequest, 17367 satIOContext 17368 ); 17369 17370 17371 return tiSuccess; 17372 17373 } 17374 17375 /***************************************************************************** 17376 *! \brief satTmWarmReset 17377 * 17378 * This routine is called to initiate a TM warm RESET request to SATL. 17379 * This routine is independent of HW/LL API. 17380 * 17381 * \param tiRoot: Pointer to TISA initiator driver/port instance. 17382 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 17383 * \param currentTaskTag: Pointer to tag/context for this TM request. 17384 * 17385 * \return: 17386 * 17387 * \e tiSuccess: I/O request successfully initiated. 17388 * \e tiBusy: No resources available, try again later. 17389 * \e tiIONoDevice: Invalid device handle. 17390 * \e tiError: Other errors that prevent the I/O request to be started. 17391 * 17392 * 17393 *****************************************************************************/ 17394 osGLOBAL bit32 satTmWarmReset( 17395 tiRoot_t *tiRoot, 17396 tiIORequest_t *tiIORequest, /* current task tag */ 17397 tiDeviceHandle_t *tiDeviceHandle, 17398 tiScsiInitiatorRequest_t *tiScsiRequest, 17399 satIOContext_t *satIOContext) 17400 { 17401 17402 tdsaDeviceData_t *tdsaDeviceData; 17403 satDeviceData_t *satDevData; 17404 17405 tdsaDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 17406 satDevData = &tdsaDeviceData->satDevData; 17407 17408 TI_DBG1(("satTmWarmReset: tiDeviceHandle=%p.\n", tiDeviceHandle )); 17409 17410 /* 17411 * Check if there is other TM request pending 17412 */ 17413 if (satDevData->satTmTaskTag != agNULL) 17414 { 17415 TI_DBG1(("satTmWarmReset: *** REJECT *** other TM pending, tiDeviceHandle=%p\n", 17416 tiDeviceHandle)); 17417 return tiError; 17418 } 17419 17420 /* 17421 * Save tiIORequest, will be returned at device reset completion to return 17422 * the TM completion. 17423 */ 17424 satDevData->satTmTaskTag = tiIORequest; 17425 17426 /* 17427 * Set flag to indicate device in recovery mode. 17428 */ 17429 satDevData->satDriveState = SAT_DEV_STATE_IN_RECOVERY; 17430 17431 /* 17432 * Issue SATA device reset. Set flag to indicate NOT to automatically abort 17433 * at the completion of SATA device reset. 17434 */ 17435 satDevData->satAbortAfterReset = agFALSE; 17436 17437 /* SAT rev8 6.3.6 p22 */ 17438 satStartResetDevice( 17439 tiRoot, 17440 tiIORequest, /* currentTaskTag */ 17441 tiDeviceHandle, 17442 tiScsiRequest, 17443 satIOContext 17444 ); 17445 17446 return tiSuccess; 17447 17448 } 17449 17450 osGLOBAL bit32 satTDInternalTmReset( 17451 tiRoot_t *tiRoot, 17452 tiIORequest_t *tiIORequest, /* current task tag */ 17453 tiDeviceHandle_t *tiDeviceHandle, 17454 tiScsiInitiatorRequest_t *tiScsiRequest, 17455 satIOContext_t *satIOContext) 17456 { 17457 17458 tdsaDeviceData_t *tdsaDeviceData; 17459 satDeviceData_t *satDevData; 17460 17461 tdsaDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 17462 satDevData = &tdsaDeviceData->satDevData; 17463 17464 TI_DBG1(("satTmWarmReset: tiDeviceHandle=%p.\n", tiDeviceHandle )); 17465 17466 /* 17467 * Check if there is other TM request pending 17468 */ 17469 if (satDevData->satTmTaskTag != agNULL) 17470 { 17471 TI_DBG1(("satTmWarmReset: *** REJECT *** other TM pending, tiDeviceHandle=%p\n", 17472 tiDeviceHandle)); 17473 return tiError; 17474 } 17475 17476 /* 17477 * Save tiIORequest, will be returned at device reset completion to return 17478 * the TM completion. 17479 */ 17480 satDevData->satTmTaskTag = tiIORequest; 17481 17482 /* 17483 * Set flag to indicate device in recovery mode. 17484 */ 17485 satDevData->satDriveState = SAT_DEV_STATE_IN_RECOVERY; 17486 17487 /* 17488 * Issue SATA device reset. Set flag to indicate NOT to automatically abort 17489 * at the completion of SATA device reset. 17490 */ 17491 satDevData->satAbortAfterReset = agFALSE; 17492 17493 /* SAT rev8 6.3.6 p22 */ 17494 satStartResetDevice( 17495 tiRoot, 17496 tiIORequest, /* currentTaskTag */ 17497 tiDeviceHandle, 17498 tiScsiRequest, 17499 satIOContext 17500 ); 17501 17502 return tiSuccess; 17503 17504 } 17505 17506 /***************************************************************************** 17507 *! \brief satTmAbortTask 17508 * 17509 * This routine is called to initiate a TM ABORT TASK request to SATL. 17510 * This routine is independent of HW/LL API. 17511 * 17512 * \param tiRoot: Pointer to TISA initiator driver/port instance. 17513 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 17514 * \param taskTag: Pointer to the associated task where the TM 17515 * command is to be applied. 17516 * \param currentTaskTag: Pointer to tag/context for this TM request. 17517 * 17518 * \return: 17519 * 17520 * \e tiSuccess: I/O request successfully initiated. 17521 * \e tiBusy: No resources available, try again later. 17522 * \e tiIONoDevice: Invalid device handle. 17523 * \e tiError: Other errors that prevent the I/O request to be started. 17524 * 17525 * 17526 *****************************************************************************/ 17527 osGLOBAL bit32 satTmAbortTask( 17528 tiRoot_t *tiRoot, 17529 tiIORequest_t *tiIORequest, /* current task tag */ 17530 tiDeviceHandle_t *tiDeviceHandle, 17531 tiScsiInitiatorRequest_t *tiScsiRequest, /* NULL */ 17532 satIOContext_t *satIOContext, 17533 tiIORequest_t *taskTag) 17534 { 17535 17536 tdsaDeviceData_t *tdsaDeviceData; 17537 satDeviceData_t *satDevData; 17538 satIOContext_t *satTempIOContext = agNULL; 17539 tdIORequestBody_t *tdIORequestBody; 17540 tdIORequestBody_t *TMtdIORequestBody; 17541 tdList_t *elementHdr; 17542 bit32 found = agFALSE; 17543 tiIORequest_t *tiIOReq; 17544 17545 tdsaDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 17546 satDevData = &tdsaDeviceData->satDevData; 17547 TMtdIORequestBody = (tdIORequestBody_t *)tiIORequest->tdData; 17548 17549 TI_DBG1(("satTmAbortTask: tiDeviceHandle=%p taskTag=%p.\n", tiDeviceHandle, taskTag )); 17550 /* 17551 * Check if there is other TM request pending 17552 */ 17553 if (satDevData->satTmTaskTag != agNULL) 17554 { 17555 TI_DBG1(("satTmAbortTask: REJECT other TM pending, tiDeviceHandle=%p\n", 17556 tiDeviceHandle)); 17557 /* clean up TD layer's IORequestBody */ 17558 ostiFreeMemory( 17559 tiRoot, 17560 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle, 17561 sizeof(tdIORequestBody_t) 17562 ); 17563 return tiError; 17564 } 17565 17566 #ifdef REMOVED 17567 /* 17568 * Check if there is only one I/O pending. 17569 */ 17570 if (satDevData->satPendingIO > 0) 17571 { 17572 TI_DBG1(("satTmAbortTask: REJECT num pending I/O, tiDeviceHandle=%p, satPendingIO=0x%x\n", 17573 tiDeviceHandle, satDevData->satPendingIO)); 17574 /* clean up TD layer's IORequestBody */ 17575 ostiFreeMemory( 17576 tiRoot, 17577 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle, 17578 sizeof(tdIORequestBody_t) 17579 ); 17580 17581 return tiError; 17582 } 17583 #endif 17584 17585 /* 17586 * Check that the only pending I/O matches taskTag. If not return tiError. 17587 */ 17588 elementHdr = satDevData->satIoLinkList.flink; 17589 17590 while (elementHdr != &satDevData->satIoLinkList) 17591 { 17592 satTempIOContext = TDLIST_OBJECT_BASE( satIOContext_t, 17593 satIoContextLink, 17594 elementHdr ); 17595 17596 tdIORequestBody = (tdIORequestBody_t *) satTempIOContext->tiRequestBody; 17597 tiIOReq = tdIORequestBody->tiIORequest; 17598 17599 elementHdr = elementHdr->flink; /* for the next while loop */ 17600 17601 /* 17602 * Check if the tag matches 17603 */ 17604 if ( tiIOReq == taskTag) 17605 { 17606 found = agTRUE; 17607 satIOContext->satToBeAbortedIOContext = satTempIOContext; 17608 TI_DBG1(("satTmAbortTask: found matching tag.\n")); 17609 17610 break; 17611 17612 } /* if matching tag */ 17613 17614 } /* while loop */ 17615 17616 17617 if (found == agFALSE ) 17618 { 17619 TI_DBG1(("satTmAbortTask: *** REJECT *** no match, tiDeviceHandle=%p\n", 17620 tiDeviceHandle )); 17621 17622 /* clean up TD layer's IORequestBody */ 17623 ostiFreeMemory( 17624 tiRoot, 17625 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle, 17626 sizeof(tdIORequestBody_t) 17627 ); 17628 17629 return tiError; 17630 } 17631 17632 /* 17633 * Save tiIORequest, will be returned at device reset completion to return 17634 * the TM completion. 17635 */ 17636 satDevData->satTmTaskTag = tiIORequest; 17637 17638 /* 17639 * Set flag to indicate device in recovery mode. 17640 */ 17641 satDevData->satDriveState = SAT_DEV_STATE_IN_RECOVERY; 17642 17643 17644 /* 17645 * Issue SATA device reset or check power mode. Set flag to to automatically abort 17646 * at the completion of SATA device reset. 17647 * SAT r09 p25 17648 */ 17649 satDevData->satAbortAfterReset = agTRUE; 17650 17651 if ( (satTempIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 17652 (satTempIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) 17653 ) 17654 { 17655 TI_DBG1(("satTmAbortTask: calling satStartCheckPowerMode\n")); 17656 /* send check power mode */ 17657 satStartCheckPowerMode( 17658 tiRoot, 17659 tiIORequest, /* currentTaskTag */ 17660 tiDeviceHandle, 17661 tiScsiRequest, 17662 satIOContext 17663 ); 17664 } 17665 else 17666 { 17667 TI_DBG1(("satTmAbortTask: calling satStartResetDevice\n")); 17668 /* send AGSA_SATA_PROTOCOL_SRST_ASSERT */ 17669 satStartResetDevice( 17670 tiRoot, 17671 tiIORequest, /* currentTaskTag */ 17672 tiDeviceHandle, 17673 tiScsiRequest, 17674 satIOContext 17675 ); 17676 } 17677 17678 17679 return tiSuccess; 17680 } 17681 17682 /***************************************************************************** 17683 *! \brief osSatResetCB 17684 * 17685 * This routine is called to notify the completion of SATA device reset 17686 * which was initiated previously through the call to sataLLReset(). 17687 * This routine is independent of HW/LL API. 17688 * 17689 * \param tiRoot: Pointer to TISA initiator driver/port instance. 17690 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 17691 * \param resetStatus: Reset status either tiSuccess or tiError. 17692 * \param respFis: Pointer to the Register Device-To-Host FIS 17693 * received from the device. 17694 * 17695 * \return: None 17696 * 17697 *****************************************************************************/ 17698 osGLOBAL void osSatResetCB( 17699 tiRoot_t *tiRoot, 17700 tiDeviceHandle_t *tiDeviceHandle, 17701 bit32 resetStatus, 17702 void *respFis) 17703 { 17704 17705 agsaRoot_t *agRoot; 17706 tdsaDeviceData_t *tdsaDeviceData; 17707 satDeviceData_t *satDevData; 17708 satIOContext_t *satIOContext; 17709 tdIORequestBody_t *tdIORequestBodyTmp; 17710 tdList_t *elementHdr; 17711 agsaIORequest_t *agAbortIORequest; 17712 tdIORequestBody_t *tdAbortIORequestBody; 17713 bit32 PhysUpper32; 17714 bit32 PhysLower32; 17715 bit32 memAllocStatus; 17716 void *osMemHandle; 17717 17718 tdsaDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 17719 agRoot = tdsaDeviceData->agRoot; 17720 satDevData = &tdsaDeviceData->satDevData; 17721 17722 TI_DBG5(("osSatResetCB: tiDeviceHandle=%p resetStatus=0x%x\n", 17723 tiDeviceHandle, resetStatus )); 17724 17725 /* We may need to check FIS to check device operating condition */ 17726 17727 17728 /* 17729 * Check if need to abort all pending I/Os 17730 */ 17731 if ( satDevData->satAbortAfterReset == agTRUE ) 17732 { 17733 /* 17734 * Issue abort to LL layer to all other pending I/Os for the same SATA drive 17735 */ 17736 elementHdr = satDevData->satIoLinkList.flink; 17737 while (elementHdr != &satDevData->satIoLinkList) 17738 { 17739 satIOContext = TDLIST_OBJECT_BASE( satIOContext_t, 17740 satIoContextLink, 17741 elementHdr ); 17742 17743 tdIORequestBodyTmp = (tdIORequestBody_t *)satIOContext->tiRequestBody; 17744 17745 /* 17746 * Issue abort 17747 */ 17748 TI_DBG5(("osSatResetCB: issuing ABORT tiDeviceHandle=%p agIORequest=%p\n", 17749 tiDeviceHandle, &tdIORequestBodyTmp->agIORequest )); 17750 17751 /* allocating agIORequest for abort itself */ 17752 memAllocStatus = ostiAllocMemory( 17753 tiRoot, 17754 &osMemHandle, 17755 (void **)&tdAbortIORequestBody, 17756 &PhysUpper32, 17757 &PhysLower32, 17758 8, 17759 sizeof(tdIORequestBody_t), 17760 agTRUE 17761 ); 17762 17763 if (memAllocStatus != tiSuccess) 17764 { 17765 /* let os process IO */ 17766 TI_DBG1(("osSatResetCB: ostiAllocMemory failed...\n")); 17767 return; 17768 } 17769 17770 if (tdAbortIORequestBody == agNULL) 17771 { 17772 /* let os process IO */ 17773 TI_DBG1(("osSatResetCB: ostiAllocMemory returned NULL tdAbortIORequestBody\n")); 17774 return; 17775 } 17776 /* setup task management structure */ 17777 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 17778 tdAbortIORequestBody->tiDevHandle = tiDeviceHandle; 17779 17780 /* initialize agIORequest */ 17781 agAbortIORequest = &(tdAbortIORequestBody->agIORequest); 17782 agAbortIORequest->osData = (void *) tdAbortIORequestBody; 17783 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */ 17784 17785 saSATAAbort( agRoot, agAbortIORequest, 0, agNULL, 0, &(tdIORequestBodyTmp->agIORequest), agNULL ); 17786 elementHdr = elementHdr->flink; /* for the next while loop */ 17787 17788 } /* while */ 17789 17790 /* Reset flag */ 17791 satDevData->satAbortAfterReset = agFALSE; 17792 17793 } 17794 17795 17796 /* 17797 * Check if the device reset if the result of TM request. 17798 */ 17799 if ( satDevData->satTmTaskTag != agNULL ) 17800 { 17801 TI_DBG5(("osSatResetCB: calling TM completion tiDeviceHandle=%p satTmTaskTag=%p\n", 17802 tiDeviceHandle, satDevData->satTmTaskTag )); 17803 17804 ostiInitiatorEvent( tiRoot, 17805 agNULL, /* portalContext not used */ 17806 tiDeviceHandle, 17807 tiIntrEventTypeTaskManagement, 17808 tiTMOK, 17809 satDevData->satTmTaskTag); 17810 /* 17811 * Reset flag 17812 */ 17813 satDevData->satTmTaskTag = agNULL; 17814 } 17815 17816 } 17817 17818 17819 /***************************************************************************** 17820 *! \brief osSatIOCompleted 17821 * 17822 * This routine is a callback for SATA completion that required FIS status 17823 * translation to SCSI status. 17824 * 17825 * \param tiRoot: Pointer to TISA initiator driver/port instance. 17826 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 17827 * \param respFis: Pointer to status FIS to read. 17828 * \param respFisLen: Length of response FIS to read. 17829 * \param satIOContext: Pointer to SAT context. 17830 * \param interruptContext: Interrupt context 17831 * 17832 * \return: None 17833 * 17834 *****************************************************************************/ 17835 osGLOBAL void osSatIOCompleted( 17836 tiRoot_t *tiRoot, 17837 tiIORequest_t *tiIORequest, 17838 agsaFisHeader_t *agFirstDword, 17839 bit32 respFisLen, 17840 agsaFrameHandle_t agFrameHandle, 17841 satIOContext_t *satIOContext, 17842 bit32 interruptContext) 17843 17844 { 17845 satDeviceData_t *pSatDevData; 17846 scsiRspSense_t *pSense; 17847 #ifdef TD_DEBUG_ENABLE 17848 tiIniScsiCmnd_t *pScsiCmnd; 17849 #endif 17850 agsaFisRegHostToDevice_t *hostToDevFis = agNULL; 17851 bit32 ataStatus = 0; 17852 bit32 ataError; 17853 satInternalIo_t *satIntIo = agNULL; 17854 bit32 status; 17855 tiDeviceHandle_t *tiDeviceHandle; 17856 satIOContext_t *satIOContext2; 17857 tdIORequestBody_t *tdIORequestBody; 17858 agsaFisRegD2HHeader_t *statDevToHostFisHeader = agNULL; 17859 agsaFisSetDevBitsHeader_t *statSetDevBitFisHeader = agNULL; 17860 tiIORequest_t tiIORequestTMP; 17861 17862 pSense = satIOContext->pSense; 17863 pSatDevData = satIOContext->pSatDevData; 17864 #ifdef TD_DEBUG_ENABLE 17865 pScsiCmnd = satIOContext->pScsiCmnd; 17866 #endif 17867 hostToDevFis = satIOContext->pFis; 17868 17869 tiDeviceHandle = &((tdsaDeviceData_t *)(pSatDevData->satSaDeviceData))->tiDeviceHandle; 17870 /* 17871 * Find out the type of response FIS: 17872 * Set Device Bit FIS or Reg Device To Host FIS. 17873 */ 17874 17875 /* First assume it is Reg Device to Host FIS */ 17876 statDevToHostFisHeader = (agsaFisRegD2HHeader_t *)&(agFirstDword->D2H); 17877 ataStatus = statDevToHostFisHeader->status; /* ATA Status register */ 17878 ataError = statDevToHostFisHeader->error; /* ATA Eror register */ 17879 17880 /* for debugging */ 17881 TI_DBG1(("osSatIOCompleted: H to D command 0x%x\n", hostToDevFis->h.command)); 17882 TI_DBG1(("osSatIOCompleted: D to H fistype 0x%x\n", statDevToHostFisHeader->fisType)); 17883 17884 17885 if (statDevToHostFisHeader->fisType == SET_DEV_BITS_FIS) 17886 { 17887 /* It is Set Device Bits FIS */ 17888 statSetDevBitFisHeader = (agsaFisSetDevBitsHeader_t *)&(agFirstDword->D2H); 17889 /* Get ATA Status register */ 17890 ataStatus = (statSetDevBitFisHeader->statusHi_Lo & 0x70); /* bits 4,5,6 */ 17891 ataStatus = ataStatus | (statSetDevBitFisHeader->statusHi_Lo & 0x07); /* bits 0,1,2 */ 17892 17893 /* ATA Eror register */ 17894 ataError = statSetDevBitFisHeader->error; 17895 17896 statDevToHostFisHeader = agNULL; 17897 } 17898 17899 else if (statDevToHostFisHeader->fisType != REG_DEV_TO_HOST_FIS) 17900 { 17901 TI_DBG1(("osSatIOCompleted: *** UNEXPECTED RESP FIS TYPE 0x%x *** tiIORequest=%p\n", 17902 statDevToHostFisHeader->fisType, tiIORequest)); 17903 17904 satSetSensePayload( pSense, 17905 SCSI_SNSKEY_HARDWARE_ERROR, 17906 0, 17907 SCSI_SNSCODE_INTERNAL_TARGET_FAILURE, 17908 satIOContext); 17909 17910 ostiInitiatorIOCompleted( tiRoot, 17911 tiIORequest, 17912 tiIOSuccess, 17913 SCSI_STAT_CHECK_CONDITION, 17914 satIOContext->pTiSenseData, 17915 interruptContext ); 17916 return; 17917 17918 } 17919 17920 if ( ataStatus & DF_ATA_STATUS_MASK ) 17921 { 17922 pSatDevData->satDeviceFaultState = agTRUE; 17923 } 17924 else 17925 { 17926 pSatDevData->satDeviceFaultState = agFALSE; 17927 } 17928 17929 TI_DBG5(("osSatIOCompleted: tiIORequest=%p CDB=0x%x ATA CMD =0x%x\n", 17930 tiIORequest, pScsiCmnd->cdb[0], hostToDevFis->h.command)); 17931 17932 /* 17933 * Decide which ATA command is the translation needed 17934 */ 17935 switch(hostToDevFis->h.command) 17936 { 17937 case SAT_READ_FPDMA_QUEUED: 17938 case SAT_WRITE_FPDMA_QUEUED: 17939 17940 /************************************************************************ 17941 * 17942 * !!!! See Section 13.5.2.4 of SATA 2.5 specs. !!!! 17943 * !!!! If the NCQ error ends up here, it means that the device sent !!!! 17944 * !!!! Set Device Bit FIS (which has SActive register) instead of !!!! 17945 * !!!! Register Device To Host FIS (which does not have SActive !!!! 17946 * !!!! register). The callback ossaSATAEvent() deals with the case !!!! 17947 * !!!! where Register Device To Host FIS was sent by the device. !!!! 17948 * 17949 * For NCQ we need to issue READ LOG EXT command with log page 10h 17950 * to get the error and to allow other I/Os to continue. 17951 * 17952 * Here is the basic flow or sequence of error recovery, note that due 17953 * to the SATA HW assist that we have, this sequence is slighly different 17954 * from the one described in SATA 2.5: 17955 * 17956 * 1. Set SATA device flag to indicate error condition and returning busy 17957 * for all new request. 17958 * return tiSuccess; 17959 17960 * 2. Because the HW/LL layer received Set Device Bit FIS, it can get the 17961 * tag or I/O context for NCQ request, SATL would translate the ATA error 17962 * to SCSI status and return the original NCQ I/O with the appopriate 17963 * SCSI status. 17964 * 17965 * 3. Prepare READ LOG EXT page 10h command. Set flag to indicate that 17966 * the failed I/O has been returned to the OS Layer. Send command. 17967 * 17968 * 4. When the device receives READ LOG EXT page 10h request all other 17969 * pending I/O are implicitly aborted. No completion (aborted) status 17970 * will be sent to the host for these aborted commands. 17971 * 17972 * 5. SATL receives the completion for READ LOG EXT command in 17973 * satReadLogExtCB(). Steps 6,7,8,9 below are the step 1,2,3,4 in 17974 * satReadLogExtCB(). 17975 * 17976 * 6. Check flag that indicates whether the failed I/O has been returned 17977 * to the OS Layer. If not, search the I/O context in device data 17978 * looking for a matched tag. Then return the completion of the failed 17979 * NCQ command with the appopriate/trasnlated SCSI status. 17980 * 17981 * 7. Issue abort to LL layer to all other pending I/Os for the same SATA 17982 * drive. 17983 * 17984 * 8. Free resource allocated for the internally generated READ LOG EXT. 17985 * 17986 * 9. At the completion of abort, in the context of ossaSATACompleted(), 17987 * return the I/O with error status to the OS-App Specific layer. 17988 * When all I/O aborts are completed, clear SATA device flag to 17989 * indicate ready to process new request. 17990 * 17991 ***********************************************************************/ 17992 17993 TI_DBG1(("osSatIOCompleted: NCQ ERROR tiIORequest=%p ataStatus=0x%x ataError=0x%x\n", 17994 tiIORequest, ataStatus, ataError )); 17995 17996 /* Set flag to indicate we are in recovery */ 17997 pSatDevData->satDriveState = SAT_DEV_STATE_IN_RECOVERY; 17998 17999 /* Return the failed NCQ I/O to OS-Apps Specifiic layer */ 18000 osSatDefaultTranslation( tiRoot, 18001 tiIORequest, 18002 satIOContext, 18003 pSense, 18004 (bit8)ataStatus, 18005 (bit8)ataError, 18006 interruptContext ); 18007 18008 /* 18009 * Allocate resource for READ LOG EXT page 10h 18010 */ 18011 satIntIo = satAllocIntIoResource( tiRoot, 18012 &(tiIORequestTMP), /* anything but NULL */ 18013 pSatDevData, 18014 sizeof (satReadLogExtPage10h_t), 18015 satIntIo); 18016 18017 if (satIntIo == agNULL) 18018 { 18019 TI_DBG1(("osSatIOCompleted: can't send RLE due to resource lack\n")); 18020 18021 /* Abort I/O after completion of device reset */ 18022 pSatDevData->satAbortAfterReset = agTRUE; 18023 #ifdef NOT_YET 18024 /* needs further investigation */ 18025 /* no report to OS layer */ 18026 satSubTM(tiRoot, 18027 tiDeviceHandle, 18028 TD_INTERNAL_TM_RESET, 18029 agNULL, 18030 agNULL, 18031 agNULL, 18032 agFALSE); 18033 #endif 18034 18035 18036 TI_DBG1(("osSatIOCompleted: calling saSATADeviceReset 1\n")); 18037 return; 18038 } 18039 18040 18041 /* 18042 * Set flag to indicate that the failed I/O has been returned to the 18043 * OS-App specific Layer. 18044 */ 18045 satIntIo->satIntFlag = AG_SAT_INT_IO_FLAG_ORG_IO_COMPLETED; 18046 18047 /* compare to satPrepareNewIO() */ 18048 /* Send READ LOG EXIT page 10h command */ 18049 18050 /* 18051 * Need to initialize all the fields within satIOContext except 18052 * reqType and satCompleteCB which will be set depending on cmd. 18053 */ 18054 18055 tdIORequestBody = (tdIORequestBody_t *)satIntIo->satIntRequestBody; 18056 satIOContext2 = &(tdIORequestBody->transport.SATA.satIOContext); 18057 18058 satIOContext2->pSatDevData = pSatDevData; 18059 satIOContext2->pFis = &(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 18060 satIOContext2->pScsiCmnd = &(satIntIo->satIntTiScsiXchg.scsiCmnd); 18061 satIOContext2->pSense = &(tdIORequestBody->transport.SATA.sensePayload); 18062 satIOContext2->pTiSenseData = &(tdIORequestBody->transport.SATA.tiSenseData); 18063 satIOContext2->pTiSenseData->senseData = satIOContext2->pSense; 18064 18065 satIOContext2->tiRequestBody = satIntIo->satIntRequestBody; 18066 satIOContext2->interruptContext = interruptContext; 18067 satIOContext2->satIntIoContext = satIntIo; 18068 18069 satIOContext2->ptiDeviceHandle = tiDeviceHandle; 18070 satIOContext2->satOrgIOContext = agNULL; 18071 satIOContext2->tiScsiXchg = agNULL; 18072 18073 status = satSendReadLogExt( tiRoot, 18074 &satIntIo->satIntTiIORequest, 18075 tiDeviceHandle, 18076 &satIntIo->satIntTiScsiXchg, 18077 satIOContext2); 18078 18079 if (status != tiSuccess) 18080 { 18081 TI_DBG1(("osSatIOCompleted: can't send RLE due to LL api failure\n")); 18082 satFreeIntIoResource( tiRoot, 18083 pSatDevData, 18084 satIntIo); 18085 18086 /* Abort I/O after completion of device reset */ 18087 pSatDevData->satAbortAfterReset = agTRUE; 18088 #ifdef NOT_YET 18089 /* needs further investigation */ 18090 /* no report to OS layer */ 18091 satSubTM(tiRoot, 18092 tiDeviceHandle, 18093 TD_INTERNAL_TM_RESET, 18094 agNULL, 18095 agNULL, 18096 agNULL, 18097 agFALSE); 18098 #endif 18099 18100 TI_DBG1(("osSatIOCompleted: calling saSATADeviceReset 2\n")); 18101 return; 18102 } 18103 18104 break; 18105 18106 case SAT_READ_DMA_EXT: 18107 /* fall through */ 18108 /* Use default status/error translation */ 18109 18110 case SAT_READ_DMA: 18111 /* fall through */ 18112 /* Use default status/error translation */ 18113 18114 default: 18115 osSatDefaultTranslation( tiRoot, 18116 tiIORequest, 18117 satIOContext, 18118 pSense, 18119 (bit8)ataStatus, 18120 (bit8)ataError, 18121 interruptContext ); 18122 break; 18123 18124 } /* end switch */ 18125 } 18126 18127 18128 /*****************************************************************************/ 18129 /*! \brief SAT implementation for SCSI STANDARD INQUIRY. 18130 * 18131 * SAT implementation for SCSI STANDARD INQUIRY. 18132 * 18133 * \param pInquiry: Pointer to Inquiry Data buffer. 18134 * \param pSATAIdData: Pointer to ATA IDENTIFY DEVICE data. 18135 * 18136 * \return None. 18137 */ 18138 /*****************************************************************************/ 18139 GLOBAL void satInquiryStandard( 18140 bit8 *pInquiry, 18141 agsaSATAIdentifyData_t *pSATAIdData, 18142 tiIniScsiCmnd_t *scsiCmnd 18143 ) 18144 { 18145 tiLUN_t *pLun; 18146 pLun = &scsiCmnd->lun; 18147 18148 /* 18149 Assumption: Basic Task Mangement is supported 18150 -> BQUE 1 and CMDQUE 0, SPC-4, Table96, p147 18151 */ 18152 /* 18153 See SPC-4, 6.4.2, p 143 18154 and SAT revision 8, 8.1.2, p 28 18155 */ 18156 18157 TI_DBG5(("satInquiryStandard: start\n")); 18158 18159 if (pInquiry == agNULL) 18160 { 18161 TI_DBG1(("satInquiryStandard: pInquiry is NULL, wrong\n")); 18162 return; 18163 } 18164 else 18165 { 18166 TI_DBG5(("satInquiryStandard: pInquiry is NOT NULL\n")); 18167 } 18168 /* 18169 * Reject all other LUN other than LUN 0. 18170 */ 18171 if ( ((pLun->lun[0] | pLun->lun[1] | pLun->lun[2] | pLun->lun[3] | 18172 pLun->lun[4] | pLun->lun[5] | pLun->lun[6] | pLun->lun[7] ) != 0) ) 18173 { 18174 /* SAT Spec Table 8, p27, footnote 'a' */ 18175 pInquiry[0] = 0x7F; 18176 18177 } 18178 else 18179 { 18180 pInquiry[0] = 0x00; 18181 } 18182 18183 if (pSATAIdData->rm_ataDevice & ATA_REMOVABLE_MEDIA_DEVICE_MASK ) 18184 { 18185 pInquiry[1] = 0x80; 18186 } 18187 else 18188 { 18189 pInquiry[1] = 0x00; 18190 } 18191 pInquiry[2] = 0x05; /* SPC-3 */ 18192 pInquiry[3] = 0x12; /* set HiSup 1; resp data format set to 2 */ 18193 pInquiry[4] = 0x1F; /* 35 - 4 = 31; Additional length */ 18194 pInquiry[5] = 0x00; 18195 /* The following two are for task management. SAT Rev8, p20 */ 18196 if (pSATAIdData->sataCapabilities & 0x100) 18197 { 18198 /* NCQ supported; multiple outstanding SCSI IO are supported */ 18199 pInquiry[6] = 0x00; /* BQUE bit is not set */ 18200 pInquiry[7] = 0x02; /* CMDQUE bit is set */ 18201 } 18202 else 18203 { 18204 pInquiry[6] = 0x80; /* BQUE bit is set */ 18205 pInquiry[7] = 0x00; /* CMDQUE bit is not set */ 18206 } 18207 /* 18208 * Vendor ID. 18209 */ 18210 osti_strncpy((char*)&pInquiry[8], AG_SAT_VENDOR_ID_STRING,8); /* 8 bytes */ 18211 18212 /* 18213 * Product ID 18214 */ 18215 /* when flipped by LL */ 18216 pInquiry[16] = pSATAIdData->modelNumber[1]; 18217 pInquiry[17] = pSATAIdData->modelNumber[0]; 18218 pInquiry[18] = pSATAIdData->modelNumber[3]; 18219 pInquiry[19] = pSATAIdData->modelNumber[2]; 18220 pInquiry[20] = pSATAIdData->modelNumber[5]; 18221 pInquiry[21] = pSATAIdData->modelNumber[4]; 18222 pInquiry[22] = pSATAIdData->modelNumber[7]; 18223 pInquiry[23] = pSATAIdData->modelNumber[6]; 18224 pInquiry[24] = pSATAIdData->modelNumber[9]; 18225 pInquiry[25] = pSATAIdData->modelNumber[8]; 18226 pInquiry[26] = pSATAIdData->modelNumber[11]; 18227 pInquiry[27] = pSATAIdData->modelNumber[10]; 18228 pInquiry[28] = pSATAIdData->modelNumber[13]; 18229 pInquiry[29] = pSATAIdData->modelNumber[12]; 18230 pInquiry[30] = pSATAIdData->modelNumber[15]; 18231 pInquiry[31] = pSATAIdData->modelNumber[14]; 18232 18233 /* when flipped */ 18234 /* 18235 * Product Revision level. 18236 */ 18237 18238 /* 18239 * If the IDENTIFY DEVICE data received in words 25 and 26 from the ATA 18240 * device are ASCII spaces (20h), do this translation. 18241 */ 18242 if ( (pSATAIdData->firmwareVersion[4] == 0x20 ) && 18243 (pSATAIdData->firmwareVersion[5] == 0x00 ) && 18244 (pSATAIdData->firmwareVersion[6] == 0x20 ) && 18245 (pSATAIdData->firmwareVersion[7] == 0x00 ) 18246 ) 18247 { 18248 pInquiry[32] = pSATAIdData->firmwareVersion[1]; 18249 pInquiry[33] = pSATAIdData->firmwareVersion[0]; 18250 pInquiry[34] = pSATAIdData->firmwareVersion[3]; 18251 pInquiry[35] = pSATAIdData->firmwareVersion[2]; 18252 } 18253 else 18254 { 18255 pInquiry[32] = pSATAIdData->firmwareVersion[5]; 18256 pInquiry[33] = pSATAIdData->firmwareVersion[4]; 18257 pInquiry[34] = pSATAIdData->firmwareVersion[7]; 18258 pInquiry[35] = pSATAIdData->firmwareVersion[6]; 18259 } 18260 18261 18262 #ifdef REMOVED 18263 /* 18264 * Product ID 18265 */ 18266 /* when flipped by LL */ 18267 pInquiry[16] = pSATAIdData->modelNumber[0]; 18268 pInquiry[17] = pSATAIdData->modelNumber[1]; 18269 pInquiry[18] = pSATAIdData->modelNumber[2]; 18270 pInquiry[19] = pSATAIdData->modelNumber[3]; 18271 pInquiry[20] = pSATAIdData->modelNumber[4]; 18272 pInquiry[21] = pSATAIdData->modelNumber[5]; 18273 pInquiry[22] = pSATAIdData->modelNumber[6]; 18274 pInquiry[23] = pSATAIdData->modelNumber[7]; 18275 pInquiry[24] = pSATAIdData->modelNumber[8]; 18276 pInquiry[25] = pSATAIdData->modelNumber[9]; 18277 pInquiry[26] = pSATAIdData->modelNumber[10]; 18278 pInquiry[27] = pSATAIdData->modelNumber[11]; 18279 pInquiry[28] = pSATAIdData->modelNumber[12]; 18280 pInquiry[29] = pSATAIdData->modelNumber[13]; 18281 pInquiry[30] = pSATAIdData->modelNumber[14]; 18282 pInquiry[31] = pSATAIdData->modelNumber[15]; 18283 18284 /* when flipped */ 18285 /* 18286 * Product Revision level. 18287 */ 18288 18289 /* 18290 * If the IDENTIFY DEVICE data received in words 25 and 26 from the ATA 18291 * device are ASCII spaces (20h), do this translation. 18292 */ 18293 if ( (pSATAIdData->firmwareVersion[4] == 0x20 ) && 18294 (pSATAIdData->firmwareVersion[5] == 0x00 ) && 18295 (pSATAIdData->firmwareVersion[6] == 0x20 ) && 18296 (pSATAIdData->firmwareVersion[7] == 0x00 ) 18297 ) 18298 { 18299 pInquiry[32] = pSATAIdData->firmwareVersion[0]; 18300 pInquiry[33] = pSATAIdData->firmwareVersion[1]; 18301 pInquiry[34] = pSATAIdData->firmwareVersion[2]; 18302 pInquiry[35] = pSATAIdData->firmwareVersion[3]; 18303 } 18304 else 18305 { 18306 pInquiry[32] = pSATAIdData->firmwareVersion[4]; 18307 pInquiry[33] = pSATAIdData->firmwareVersion[5]; 18308 pInquiry[34] = pSATAIdData->firmwareVersion[6]; 18309 pInquiry[35] = pSATAIdData->firmwareVersion[7]; 18310 } 18311 #endif 18312 18313 TI_DBG5(("satInquiryStandard: end\n")); 18314 18315 } 18316 18317 18318 /*****************************************************************************/ 18319 /*! \brief SAT implementation for SCSI INQUIRY page 0. 18320 * 18321 * SAT implementation for SCSI INQUIRY page 0. 18322 * 18323 * \param pInquiry: Pointer to Inquiry Data buffer. 18324 * \param pSATAIdData: Pointer to ATA IDENTIFY DEVICE data. 18325 * 18326 * \return None. 18327 */ 18328 /*****************************************************************************/ 18329 GLOBAL void satInquiryPage0( 18330 bit8 *pInquiry, 18331 agsaSATAIdentifyData_t *pSATAIdData) 18332 { 18333 18334 TI_DBG5(("satInquiryPage0: entry\n")); 18335 18336 /* 18337 See SPC-4, 7.6.9, p 345 18338 and SAT revision 8, 10.3.2, p 77 18339 */ 18340 pInquiry[0] = 0x00; 18341 pInquiry[1] = 0x00; /* page code */ 18342 pInquiry[2] = 0x00; /* reserved */ 18343 pInquiry[3] = 7 - 3; /* last index(in this case, 6) - 3; page length */ 18344 18345 /* supported vpd page list */ 18346 pInquiry[4] = 0x00; /* page 0x00 supported */ 18347 pInquiry[5] = 0x80; /* page 0x80 supported */ 18348 pInquiry[6] = 0x83; /* page 0x83 supported */ 18349 pInquiry[7] = 0x89; /* page 0x89 supported */ 18350 18351 } 18352 18353 18354 /*****************************************************************************/ 18355 /*! \brief SAT implementation for SCSI INQUIRY page 83. 18356 * 18357 * SAT implementation for SCSI INQUIRY page 83. 18358 * 18359 * \param pInquiry: Pointer to Inquiry Data buffer. 18360 * \param pSATAIdData: Pointer to ATA IDENTIFY DEVICE data. 18361 * 18362 * \return None. 18363 */ 18364 /*****************************************************************************/ 18365 GLOBAL void satInquiryPage83( 18366 bit8 *pInquiry, 18367 agsaSATAIdentifyData_t *pSATAIdData, 18368 satDeviceData_t *pSatDevData) 18369 { 18370 18371 satSimpleSATAIdentifyData_t *pSimpleData; 18372 18373 /* 18374 * When translating the fields, in some cases using the simple form of SATA 18375 * Identify Device Data is easier. So we define it here. 18376 * Both pSimpleData and pSATAIdData points to the same data. 18377 */ 18378 pSimpleData = ( satSimpleSATAIdentifyData_t *)pSATAIdData; 18379 18380 TI_DBG5(("satInquiryPage83: entry\n")); 18381 18382 pInquiry[0] = 0x00; 18383 pInquiry[1] = 0x83; /* page code */ 18384 pInquiry[2] = 0; /* Reserved */ 18385 18386 /* 18387 * If the ATA device returns word 87 bit 8 set to one in its IDENTIFY DEVICE 18388 * data indicating that it supports the WORLD WIDE NAME field 18389 * (i.e., words 108-111), the SATL shall include an identification descriptor 18390 * containing a logical unit name. 18391 */ 18392 if ( pSatDevData->satWWNSupport) 18393 { 18394 /* Fill in SAT Rev8 Table85 */ 18395 /* 18396 * Logical unit name derived from the world wide name. 18397 */ 18398 pInquiry[3] = 12; /* 15-3; page length, no addition ID descriptor assumed*/ 18399 18400 /* 18401 * Identifier descriptor 18402 */ 18403 pInquiry[4] = 0x01; /* Code set: binary codes */ 18404 pInquiry[5] = 0x03; /* Identifier type : NAA */ 18405 pInquiry[6] = 0x00; /* Reserved */ 18406 pInquiry[7] = 0x08; /* Identifier length */ 18407 18408 /* Bit 4-7 NAA field, bit 0-3 MSB of IEEE Company ID */ 18409 pInquiry[8] = (bit8)((pSATAIdData->namingAuthority) >> 8); 18410 pInquiry[9] = (bit8)((pSATAIdData->namingAuthority) & 0xFF); /* IEEE Company ID */ 18411 pInquiry[10] = (bit8)((pSATAIdData->namingAuthority1) >> 8); /* IEEE Company ID */ 18412 /* Bit 4-7 LSB of IEEE Company ID, bit 0-3 MSB of Vendor Specific ID */ 18413 pInquiry[11] = (bit8)((pSATAIdData->namingAuthority1) & 0xFF); 18414 pInquiry[12] = (bit8)((pSATAIdData->uniqueID_bit16_31) >> 8); /* Vendor Specific ID */ 18415 pInquiry[13] = (bit8)((pSATAIdData->uniqueID_bit16_31) & 0xFF); /* Vendor Specific ID */ 18416 pInquiry[14] = (bit8)((pSATAIdData->uniqueID_bit0_15) >> 8); /* Vendor Specific ID */ 18417 pInquiry[15] = (bit8)((pSATAIdData->uniqueID_bit0_15) & 0xFF); /* Vendor Specific ID */ 18418 18419 } 18420 else 18421 { 18422 /* Fill in SAT Rev8 Table86 */ 18423 /* 18424 * Logical unit name derived from the model number and serial number. 18425 */ 18426 pInquiry[3] = 72; /* 75 - 3; page length */ 18427 18428 /* 18429 * Identifier descriptor 18430 */ 18431 pInquiry[4] = 0x02; /* Code set: ASCII codes */ 18432 pInquiry[5] = 0x01; /* Identifier type : T10 vendor ID based */ 18433 pInquiry[6] = 0x00; /* Reserved */ 18434 pInquiry[7] = 0x44; /* 0x44, 68 Identifier length */ 18435 18436 /* Byte 8 to 15 is the vendor id string 'ATA '. */ 18437 osti_strncpy((char *)&pInquiry[8], AG_SAT_VENDOR_ID_STRING, 8); 18438 18439 18440 /* 18441 * Byte 16 to 75 is vendor specific id 18442 */ 18443 pInquiry[16] = (bit8)((pSimpleData->word[27]) >> 8); 18444 pInquiry[17] = (bit8)((pSimpleData->word[27]) & 0x00ff); 18445 pInquiry[18] = (bit8)((pSimpleData->word[28]) >> 8); 18446 pInquiry[19] = (bit8)((pSimpleData->word[28]) & 0x00ff); 18447 pInquiry[20] = (bit8)((pSimpleData->word[29]) >> 8); 18448 pInquiry[21] = (bit8)((pSimpleData->word[29]) & 0x00ff); 18449 pInquiry[22] = (bit8)((pSimpleData->word[30]) >> 8); 18450 pInquiry[23] = (bit8)((pSimpleData->word[30]) & 0x00ff); 18451 pInquiry[24] = (bit8)((pSimpleData->word[31]) >> 8); 18452 pInquiry[25] = (bit8)((pSimpleData->word[31]) & 0x00ff); 18453 pInquiry[26] = (bit8)((pSimpleData->word[32]) >> 8); 18454 pInquiry[27] = (bit8)((pSimpleData->word[32]) & 0x00ff); 18455 pInquiry[28] = (bit8)((pSimpleData->word[33]) >> 8); 18456 pInquiry[29] = (bit8)((pSimpleData->word[33]) & 0x00ff); 18457 pInquiry[30] = (bit8)((pSimpleData->word[34]) >> 8); 18458 pInquiry[31] = (bit8)((pSimpleData->word[34]) & 0x00ff); 18459 pInquiry[32] = (bit8)((pSimpleData->word[35]) >> 8); 18460 pInquiry[33] = (bit8)((pSimpleData->word[35]) & 0x00ff); 18461 pInquiry[34] = (bit8)((pSimpleData->word[36]) >> 8); 18462 pInquiry[35] = (bit8)((pSimpleData->word[36]) & 0x00ff); 18463 pInquiry[36] = (bit8)((pSimpleData->word[37]) >> 8); 18464 pInquiry[37] = (bit8)((pSimpleData->word[37]) & 0x00ff); 18465 pInquiry[38] = (bit8)((pSimpleData->word[38]) >> 8); 18466 pInquiry[39] = (bit8)((pSimpleData->word[38]) & 0x00ff); 18467 pInquiry[40] = (bit8)((pSimpleData->word[39]) >> 8); 18468 pInquiry[41] = (bit8)((pSimpleData->word[39]) & 0x00ff); 18469 pInquiry[42] = (bit8)((pSimpleData->word[40]) >> 8); 18470 pInquiry[43] = (bit8)((pSimpleData->word[40]) & 0x00ff); 18471 pInquiry[44] = (bit8)((pSimpleData->word[41]) >> 8); 18472 pInquiry[45] = (bit8)((pSimpleData->word[41]) & 0x00ff); 18473 pInquiry[46] = (bit8)((pSimpleData->word[42]) >> 8); 18474 pInquiry[47] = (bit8)((pSimpleData->word[42]) & 0x00ff); 18475 pInquiry[48] = (bit8)((pSimpleData->word[43]) >> 8); 18476 pInquiry[49] = (bit8)((pSimpleData->word[43]) & 0x00ff); 18477 pInquiry[50] = (bit8)((pSimpleData->word[44]) >> 8); 18478 pInquiry[51] = (bit8)((pSimpleData->word[44]) & 0x00ff); 18479 pInquiry[52] = (bit8)((pSimpleData->word[45]) >> 8); 18480 pInquiry[53] = (bit8)((pSimpleData->word[45]) & 0x00ff); 18481 pInquiry[54] = (bit8)((pSimpleData->word[46]) >> 8); 18482 pInquiry[55] = (bit8)((pSimpleData->word[46]) & 0x00ff); 18483 18484 pInquiry[56] = (bit8)((pSimpleData->word[10]) >> 8); 18485 pInquiry[57] = (bit8)((pSimpleData->word[10]) & 0x00ff); 18486 pInquiry[58] = (bit8)((pSimpleData->word[11]) >> 8); 18487 pInquiry[59] = (bit8)((pSimpleData->word[11]) & 0x00ff); 18488 pInquiry[60] = (bit8)((pSimpleData->word[12]) >> 8); 18489 pInquiry[61] = (bit8)((pSimpleData->word[12]) & 0x00ff); 18490 pInquiry[62] = (bit8)((pSimpleData->word[13]) >> 8); 18491 pInquiry[63] = (bit8)((pSimpleData->word[13]) & 0x00ff); 18492 pInquiry[64] = (bit8)((pSimpleData->word[14]) >> 8); 18493 pInquiry[65] = (bit8)((pSimpleData->word[14]) & 0x00ff); 18494 pInquiry[66] = (bit8)((pSimpleData->word[15]) >> 8); 18495 pInquiry[67] = (bit8)((pSimpleData->word[15]) & 0x00ff); 18496 pInquiry[68] = (bit8)((pSimpleData->word[16]) >> 8); 18497 pInquiry[69] = (bit8)((pSimpleData->word[16]) & 0x00ff); 18498 pInquiry[70] = (bit8)((pSimpleData->word[17]) >> 8); 18499 pInquiry[71] = (bit8)((pSimpleData->word[17]) & 0x00ff); 18500 pInquiry[72] = (bit8)((pSimpleData->word[18]) >> 8); 18501 pInquiry[73] = (bit8)((pSimpleData->word[18]) & 0x00ff); 18502 pInquiry[74] = (bit8)((pSimpleData->word[19]) >> 8); 18503 pInquiry[75] = (bit8)((pSimpleData->word[19]) & 0x00ff); 18504 } 18505 18506 } 18507 18508 /*****************************************************************************/ 18509 /*! \brief SAT implementation for SCSI INQUIRY page 89. 18510 * 18511 * SAT implementation for SCSI INQUIRY page 89. 18512 * 18513 * \param pInquiry: Pointer to Inquiry Data buffer. 18514 * \param pSATAIdData: Pointer to ATA IDENTIFY DEVICE data. 18515 * \param pSatDevData Pointer to internal device data structure 18516 * 18517 * \return None. 18518 */ 18519 /*****************************************************************************/ 18520 GLOBAL void satInquiryPage89( 18521 bit8 *pInquiry, 18522 agsaSATAIdentifyData_t *pSATAIdData, 18523 satDeviceData_t *pSatDevData) 18524 { 18525 /* 18526 SAT revision 8, 10.3.5, p 83 18527 */ 18528 satSimpleSATAIdentifyData_t *pSimpleData; 18529 18530 /* 18531 * When translating the fields, in some cases using the simple form of SATA 18532 * Identify Device Data is easier. So we define it here. 18533 * Both pSimpleData and pSATAIdData points to the same data. 18534 */ 18535 pSimpleData = ( satSimpleSATAIdentifyData_t *)pSATAIdData; 18536 18537 TI_DBG5(("satInquiryPage89: start\n")); 18538 18539 pInquiry[0] = 0x00; /* Peripheral Qualifier and Peripheral Device Type */ 18540 pInquiry[1] = 0x89; /* page code */ 18541 18542 /* Page length 0x238 */ 18543 pInquiry[2] = 0x02; 18544 pInquiry[3] = 0x38; 18545 18546 pInquiry[4] = 0x0; /* reserved */ 18547 pInquiry[5] = 0x0; /* reserved */ 18548 pInquiry[6] = 0x0; /* reserved */ 18549 pInquiry[7] = 0x0; /* reserved */ 18550 18551 /* SAT Vendor Identification */ 18552 osti_strncpy((char*)&pInquiry[8], "PMC-SIERRA", 8); /* 8 bytes */ 18553 18554 /* SAT Product Idetification */ 18555 osti_strncpy((char*)&pInquiry[16], "Tachyon-SPC ", 16); /* 16 bytes */ 18556 18557 /* SAT Product Revision Level */ 18558 osti_strncpy((char*)&pInquiry[32], "01", 4); /* 4 bytes */ 18559 18560 /* Signature, SAT revision8, Table88, p85 */ 18561 18562 18563 pInquiry[36] = 0x34; /* FIS type */ 18564 if (pSatDevData->satDeviceType == SATA_ATA_DEVICE) 18565 { 18566 /* interrupt assume to be 0 */ 18567 pInquiry[37] = (bit8)((pSatDevData->satPMField) >> (4 * 7)); /* first four bits of PM field */ 18568 } 18569 else 18570 { 18571 /* interrupt assume to be 1 */ 18572 pInquiry[37] = (bit8)(0x40 + (bit8)(((pSatDevData->satPMField) >> (4 * 7)))); /* first four bits of PM field */ 18573 } 18574 pInquiry[38] = 0; 18575 pInquiry[39] = 0; 18576 18577 if (pSatDevData->satDeviceType == SATA_ATA_DEVICE) 18578 { 18579 pInquiry[40] = 0x01; /* LBA Low */ 18580 pInquiry[41] = 0x00; /* LBA Mid */ 18581 pInquiry[42] = 0x00; /* LBA High */ 18582 pInquiry[43] = 0x00; /* Device */ 18583 pInquiry[44] = 0x00; /* LBA Low Exp */ 18584 pInquiry[45] = 0x00; /* LBA Mid Exp */ 18585 pInquiry[46] = 0x00; /* LBA High Exp */ 18586 pInquiry[47] = 0x00; /* Reserved */ 18587 pInquiry[48] = 0x01; /* Sector Count */ 18588 pInquiry[49] = 0x00; /* Sector Count Exp */ 18589 } 18590 else 18591 { 18592 pInquiry[40] = 0x01; /* LBA Low */ 18593 pInquiry[41] = 0x00; /* LBA Mid */ 18594 pInquiry[42] = 0x00; /* LBA High */ 18595 pInquiry[43] = 0x00; /* Device */ 18596 pInquiry[44] = 0x00; /* LBA Low Exp */ 18597 pInquiry[45] = 0x00; /* LBA Mid Exp */ 18598 pInquiry[46] = 0x00; /* LBA High Exp */ 18599 pInquiry[47] = 0x00; /* Reserved */ 18600 pInquiry[48] = 0x01; /* Sector Count */ 18601 pInquiry[49] = 0x00; /* Sector Count Exp */ 18602 } 18603 18604 /* Reserved */ 18605 pInquiry[50] = 0x00; 18606 pInquiry[51] = 0x00; 18607 pInquiry[52] = 0x00; 18608 pInquiry[53] = 0x00; 18609 pInquiry[54] = 0x00; 18610 pInquiry[55] = 0x00; 18611 18612 /* Command Code */ 18613 if (pSatDevData->satDeviceType == SATA_ATA_DEVICE) 18614 { 18615 pInquiry[56] = 0xEC; /* IDENTIFY DEVICE */ 18616 } 18617 else 18618 { 18619 pInquiry[56] = 0xA1; /* IDENTIFY PACKET DEVICE */ 18620 } 18621 /* Reserved */ 18622 pInquiry[57] = 0x0; 18623 pInquiry[58] = 0x0; 18624 pInquiry[59] = 0x0; 18625 18626 /* Identify Device */ 18627 osti_memcpy(&pInquiry[60], pSimpleData, sizeof(satSimpleSATAIdentifyData_t)); 18628 return; 18629 } 18630 18631 /*****************************************************************************/ 18632 /*! \brief SAT implementation for SCSI INQUIRY page 0. 18633 * 18634 * SAT implementation for SCSI INQUIRY page 0. 18635 * 18636 * \param pInquiry: Pointer to Inquiry Data buffer. 18637 * \param pSATAIdData: Pointer to ATA IDENTIFY DEVICE data. 18638 * 18639 * \return None. 18640 */ 18641 /*****************************************************************************/ 18642 GLOBAL void satInquiryPage80( 18643 bit8 *pInquiry, 18644 agsaSATAIdentifyData_t *pSATAIdData) 18645 { 18646 18647 TI_DBG5(("satInquiryPage80: entry\n")); 18648 18649 /* 18650 See SPC-4, 7.6.9, p 345 18651 and SAT revision 8, 10.3.3, p 77 18652 */ 18653 pInquiry[0] = 0x00; 18654 pInquiry[1] = 0x80; /* page code */ 18655 pInquiry[2] = 0x00; /* reserved */ 18656 pInquiry[3] = 0x14; /* page length */ 18657 18658 /* supported vpd page list */ 18659 pInquiry[4] = pSATAIdData->serialNumber[1]; 18660 pInquiry[5] = pSATAIdData->serialNumber[0]; 18661 pInquiry[6] = pSATAIdData->serialNumber[3]; 18662 pInquiry[7] = pSATAIdData->serialNumber[2]; 18663 pInquiry[8] = pSATAIdData->serialNumber[5]; 18664 pInquiry[9] = pSATAIdData->serialNumber[4]; 18665 pInquiry[10] = pSATAIdData->serialNumber[7]; 18666 pInquiry[11] = pSATAIdData->serialNumber[6]; 18667 pInquiry[12] = pSATAIdData->serialNumber[9]; 18668 pInquiry[13] = pSATAIdData->serialNumber[8]; 18669 pInquiry[14] = pSATAIdData->serialNumber[11]; 18670 pInquiry[15] = pSATAIdData->serialNumber[10]; 18671 pInquiry[16] = pSATAIdData->serialNumber[13]; 18672 pInquiry[17] = pSATAIdData->serialNumber[12]; 18673 pInquiry[18] = pSATAIdData->serialNumber[15]; 18674 pInquiry[19] = pSATAIdData->serialNumber[14]; 18675 pInquiry[20] = pSATAIdData->serialNumber[17]; 18676 pInquiry[21] = pSATAIdData->serialNumber[16]; 18677 pInquiry[22] = pSATAIdData->serialNumber[19]; 18678 pInquiry[23] = pSATAIdData->serialNumber[18]; 18679 18680 18681 } 18682 18683 18684 18685 /*****************************************************************************/ 18686 /*! \brief Send READ LOG EXT ATA PAGE 10h command to sata drive. 18687 * 18688 * Send READ LOG EXT ATA command PAGE 10h request to LL layer. 18689 * 18690 * \param tiRoot: Pointer to TISA initiator driver/port instance. 18691 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 18692 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 18693 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 18694 * \param satIOContext_t: Pointer to the SAT IO Context 18695 * 18696 * \return If command is started successfully 18697 * - \e tiSuccess: I/O request successfully initiated. 18698 * - \e tiBusy: No resources available, try again later. 18699 * - \e tiIONoDevice: Invalid device handle. 18700 * - \e tiError: Other errors. 18701 */ 18702 /*****************************************************************************/ 18703 GLOBAL bit32 satSendReadLogExt( 18704 tiRoot_t *tiRoot, 18705 tiIORequest_t *tiIORequest, 18706 tiDeviceHandle_t *tiDeviceHandle, 18707 tiScsiInitiatorRequest_t *tiScsiRequest, 18708 satIOContext_t *satIOContext) 18709 18710 { 18711 18712 bit32 status; 18713 bit32 agRequestType; 18714 agsaFisRegHostToDevice_t *fis; 18715 18716 fis = satIOContext->pFis; 18717 18718 TI_DBG1(("satSendReadLogExt: tiDeviceHandle=%p tiIORequest=%p\n", 18719 tiDeviceHandle, tiIORequest)); 18720 18721 fis->h.fisType = 0x27; /* Reg host to device */ 18722 fis->h.c_pmPort = 0x80; /* C Bit is set */ 18723 fis->h.command = SAT_READ_LOG_EXT; /* 0x2F */ 18724 fis->h.features = 0; /* FIS reserve */ 18725 fis->d.lbaLow = 0x10; /* Page number */ 18726 fis->d.lbaMid = 0; /* */ 18727 fis->d.lbaHigh = 0; /* */ 18728 fis->d.device = 0; /* DEV is ignored in SATA */ 18729 fis->d.lbaLowExp = 0; /* */ 18730 fis->d.lbaMidExp = 0; /* */ 18731 fis->d.lbaHighExp = 0; /* */ 18732 fis->d.featuresExp = 0; /* FIS reserve */ 18733 fis->d.sectorCount = 0x01; /* 1 sector counts*/ 18734 fis->d.sectorCountExp = 0x00; /* 1 sector counts */ 18735 fis->d.reserved4 = 0; 18736 fis->d.control = 0; /* FIS HOB bit clear */ 18737 fis->d.reserved5 = 0; 18738 18739 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 18740 18741 /* Initialize CB for SATA completion. 18742 */ 18743 satIOContext->satCompleteCB = &satReadLogExtCB; 18744 18745 /* 18746 * Prepare SGL and send FIS to LL layer. 18747 */ 18748 satIOContext->reqType = agRequestType; /* Save it */ 18749 18750 status = sataLLIOStart( tiRoot, 18751 tiIORequest, 18752 tiDeviceHandle, 18753 tiScsiRequest, 18754 satIOContext); 18755 18756 TI_DBG1(("satSendReadLogExt: end status %d\n", status)); 18757 18758 return (status); 18759 18760 } 18761 18762 18763 /*****************************************************************************/ 18764 /*! \brief SAT default ATA status and ATA error translation to SCSI. 18765 * 18766 * SSAT default ATA status and ATA error translation to SCSI. 18767 * 18768 * \param tiRoot: Pointer to TISA initiator driver/port instance. 18769 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 18770 * \param satIOContext: Pointer to the SAT IO Context 18771 * \param pSense: Pointer to scsiRspSense_t 18772 * \param ataStatus: ATA status register 18773 * \param ataError: ATA error register 18774 * \param interruptContext: Interrupt context 18775 * 18776 * \return None 18777 */ 18778 /*****************************************************************************/ 18779 GLOBAL void osSatDefaultTranslation( 18780 tiRoot_t *tiRoot, 18781 tiIORequest_t *tiIORequest, 18782 satIOContext_t *satIOContext, 18783 scsiRspSense_t *pSense, 18784 bit8 ataStatus, 18785 bit8 ataError, 18786 bit32 interruptContext ) 18787 { 18788 18789 /* 18790 * Check for device fault case 18791 */ 18792 if ( ataStatus & DF_ATA_STATUS_MASK ) 18793 { 18794 satSetSensePayload( pSense, 18795 SCSI_SNSKEY_HARDWARE_ERROR, 18796 0, 18797 SCSI_SNSCODE_INTERNAL_TARGET_FAILURE, 18798 satIOContext); 18799 18800 ostiInitiatorIOCompleted( tiRoot, 18801 tiIORequest, 18802 tiIOSuccess, 18803 SCSI_STAT_CHECK_CONDITION, 18804 satIOContext->pTiSenseData, 18805 interruptContext ); 18806 return; 18807 } 18808 18809 /* 18810 * If status error bit it set, need to check the error register 18811 */ 18812 if ( ataStatus & ERR_ATA_STATUS_MASK ) 18813 { 18814 if ( ataError & NM_ATA_ERROR_MASK ) 18815 { 18816 TI_DBG1(("osSatDefaultTranslation: NM_ATA_ERROR ataError= 0x%x, tiIORequest=%p\n", 18817 ataError, tiIORequest)); 18818 satSetSensePayload( pSense, 18819 SCSI_SNSKEY_NOT_READY, 18820 0, 18821 SCSI_SNSCODE_MEDIUM_NOT_PRESENT, 18822 satIOContext); 18823 } 18824 18825 else if (ataError & UNC_ATA_ERROR_MASK) 18826 { 18827 TI_DBG1(("osSatDefaultTranslation: UNC_ATA_ERROR ataError= 0x%x, tiIORequest=%p\n", 18828 ataError, tiIORequest)); 18829 satSetSensePayload( pSense, 18830 SCSI_SNSKEY_MEDIUM_ERROR, 18831 0, 18832 SCSI_SNSCODE_UNRECOVERED_READ_ERROR, 18833 satIOContext); 18834 } 18835 18836 else if (ataError & IDNF_ATA_ERROR_MASK) 18837 { 18838 TI_DBG1(("osSatDefaultTranslation: IDNF_ATA_ERROR ataError= 0x%x, tiIORequest=%p\n", 18839 ataError, tiIORequest)); 18840 satSetSensePayload( pSense, 18841 SCSI_SNSKEY_MEDIUM_ERROR, 18842 0, 18843 SCSI_SNSCODE_RECORD_NOT_FOUND, 18844 satIOContext); 18845 } 18846 18847 else if (ataError & MC_ATA_ERROR_MASK) 18848 { 18849 TI_DBG1(("osSatDefaultTranslation: MC_ATA_ERROR ataError= 0x%x, tiIORequest=%p\n", 18850 ataError, tiIORequest)); 18851 satSetSensePayload( pSense, 18852 SCSI_SNSKEY_UNIT_ATTENTION, 18853 0, 18854 SCSI_SNSCODE_NOT_READY_TO_READY_CHANGE, 18855 satIOContext); 18856 } 18857 18858 else if (ataError & MCR_ATA_ERROR_MASK) 18859 { 18860 TI_DBG1(("osSatDefaultTranslation: MCR_ATA_ERROR ataError= 0x%x, tiIORequest=%p\n", 18861 ataError, tiIORequest)); 18862 satSetSensePayload( pSense, 18863 SCSI_SNSKEY_UNIT_ATTENTION, 18864 0, 18865 SCSI_SNSCODE_OPERATOR_MEDIUM_REMOVAL_REQUEST, 18866 satIOContext); 18867 } 18868 18869 else if (ataError & ICRC_ATA_ERROR_MASK) 18870 { 18871 TI_DBG1(("osSatDefaultTranslation: ICRC_ATA_ERROR ataError= 0x%x, tiIORequest=%p\n", 18872 ataError, tiIORequest)); 18873 satSetSensePayload( pSense, 18874 SCSI_SNSKEY_ABORTED_COMMAND, 18875 0, 18876 SCSI_SNSCODE_INFORMATION_UNIT_CRC_ERROR, 18877 satIOContext); 18878 } 18879 18880 else if (ataError & ABRT_ATA_ERROR_MASK) 18881 { 18882 TI_DBG1(("osSatDefaultTranslation: ABRT_ATA_ERROR ataError= 0x%x, tiIORequest=%p\n", 18883 ataError, tiIORequest)); 18884 satSetSensePayload( pSense, 18885 SCSI_SNSKEY_ABORTED_COMMAND, 18886 0, 18887 SCSI_SNSCODE_NO_ADDITIONAL_INFO, 18888 satIOContext); 18889 } 18890 18891 else 18892 { 18893 TI_DBG1(("osSatDefaultTranslation: **** UNEXPECTED ATA_ERROR **** ataError= 0x%x, tiIORequest=%p\n", 18894 ataError, tiIORequest)); 18895 satSetSensePayload( pSense, 18896 SCSI_SNSKEY_HARDWARE_ERROR, 18897 0, 18898 SCSI_SNSCODE_INTERNAL_TARGET_FAILURE, 18899 satIOContext); 18900 } 18901 18902 /* Send the completion response now */ 18903 ostiInitiatorIOCompleted( tiRoot, 18904 tiIORequest, 18905 tiIOSuccess, 18906 SCSI_STAT_CHECK_CONDITION, 18907 satIOContext->pTiSenseData, 18908 interruptContext ); 18909 return; 18910 18911 18912 } 18913 18914 else /* (ataStatus & ERR_ATA_STATUS_MASK ) is false */ 18915 { 18916 /* This case should never happen */ 18917 TI_DBG1(("osSatDefaultTranslation: *** UNEXPECTED ATA status 0x%x *** tiIORequest=%p\n", 18918 ataStatus, tiIORequest)); 18919 satSetSensePayload( pSense, 18920 SCSI_SNSKEY_HARDWARE_ERROR, 18921 0, 18922 SCSI_SNSCODE_INTERNAL_TARGET_FAILURE, 18923 satIOContext); 18924 18925 ostiInitiatorIOCompleted( tiRoot, 18926 tiIORequest, 18927 tiIOSuccess, 18928 SCSI_STAT_CHECK_CONDITION, 18929 satIOContext->pTiSenseData, 18930 interruptContext ); 18931 return; 18932 18933 } 18934 18935 18936 } 18937 18938 /*****************************************************************************/ 18939 /*! \brief Allocate resource for SAT intervally generated I/O. 18940 * 18941 * Allocate resource for SAT intervally generated I/O. 18942 * 18943 * \param tiRoot: Pointer to TISA driver/port instance. 18944 * \param satDevData: Pointer to SAT specific device data. 18945 * \param allocLength: Length in byte of the DMA mem to allocate, upto 18946 * one page size. 18947 * \param satIntIo: Pointer (output) to context for SAT internally 18948 * generated I/O that is allocated by this routine. 18949 * 18950 * \return If command is started successfully 18951 * - \e tiSuccess: Success. 18952 * - \e tiError: Failed allocating resource. 18953 */ 18954 /*****************************************************************************/ 18955 GLOBAL satInternalIo_t * satAllocIntIoResource( 18956 tiRoot_t *tiRoot, 18957 tiIORequest_t *tiIORequest, 18958 satDeviceData_t *satDevData, 18959 bit32 dmaAllocLength, 18960 satInternalIo_t *satIntIo) 18961 { 18962 tdList_t *tdList = agNULL; 18963 bit32 memAllocStatus; 18964 18965 TI_DBG1(("satAllocIntIoResource: start\n")); 18966 TI_DBG6(("satAllocIntIoResource: satIntIo %p\n", satIntIo)); 18967 if (satDevData == agNULL) 18968 { 18969 TI_DBG1(("satAllocIntIoResource: ***** ASSERT satDevData is null\n")); 18970 return agNULL; 18971 } 18972 18973 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 18974 if (!TDLIST_EMPTY(&(satDevData->satFreeIntIoLinkList))) 18975 { 18976 TDLIST_DEQUEUE_FROM_HEAD(&tdList, &(satDevData->satFreeIntIoLinkList)); 18977 } 18978 else 18979 { 18980 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 18981 TI_DBG1(("satAllocIntIoResource() no more internal free link.\n")); 18982 return agNULL; 18983 } 18984 18985 if (tdList == agNULL) 18986 { 18987 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 18988 TI_DBG1(("satAllocIntIoResource() FAIL to alloc satIntIo.\n")); 18989 return agNULL; 18990 } 18991 18992 satIntIo = TDLIST_OBJECT_BASE( satInternalIo_t, satIntIoLink, tdList); 18993 TI_DBG6(("satAllocIntIoResource: satDevData %p satIntIo id %d\n", satDevData, satIntIo->id)); 18994 18995 /* Put in active list */ 18996 TDLIST_DEQUEUE_THIS (&(satIntIo->satIntIoLink)); 18997 TDLIST_ENQUEUE_AT_TAIL (&(satIntIo->satIntIoLink), &(satDevData->satActiveIntIoLinkList)); 18998 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 18999 19000 #ifdef REMOVED 19001 /* Put in active list */ 19002 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 19003 TDLIST_DEQUEUE_THIS (tdList); 19004 TDLIST_ENQUEUE_AT_TAIL (tdList, &(satDevData->satActiveIntIoLinkList)); 19005 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 19006 19007 satIntIo = TDLIST_OBJECT_BASE( satInternalIo_t, satIntIoLink, tdList); 19008 TI_DBG6(("satAllocIntIoResource: satDevData %p satIntIo id %d\n", satDevData, satIntIo->id)); 19009 #endif 19010 19011 /* 19012 typedef struct 19013 { 19014 tdList_t satIntIoLink; 19015 tiIORequest_t satIntTiIORequest; 19016 void *satIntRequestBody; 19017 tiScsiInitiatorRequest_t satIntTiScsiXchg; 19018 tiMem_t satIntDmaMem; 19019 tiMem_t satIntReqBodyMem; 19020 bit32 satIntFlag; 19021 } satInternalIo_t; 19022 */ 19023 19024 /* 19025 * Allocate mem for Request Body 19026 */ 19027 satIntIo->satIntReqBodyMem.totalLength = sizeof(tdIORequestBody_t); 19028 19029 memAllocStatus = ostiAllocMemory( tiRoot, 19030 &satIntIo->satIntReqBodyMem.osHandle, 19031 (void **)&satIntIo->satIntRequestBody, 19032 &satIntIo->satIntReqBodyMem.physAddrUpper, 19033 &satIntIo->satIntReqBodyMem.physAddrLower, 19034 8, 19035 satIntIo->satIntReqBodyMem.totalLength, 19036 agTRUE ); 19037 19038 if (memAllocStatus != tiSuccess) 19039 { 19040 TI_DBG1(("satAllocIntIoResource() FAIL to alloc mem for Req Body.\n")); 19041 /* 19042 * Return satIntIo to the free list 19043 */ 19044 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 19045 TDLIST_DEQUEUE_THIS (&satIntIo->satIntIoLink); 19046 TDLIST_ENQUEUE_AT_HEAD(&satIntIo->satIntIoLink, &satDevData->satFreeIntIoLinkList); 19047 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 19048 19049 return agNULL; 19050 } 19051 19052 /* 19053 * Allocate DMA memory if required 19054 */ 19055 if (dmaAllocLength != 0) 19056 { 19057 satIntIo->satIntDmaMem.totalLength = dmaAllocLength; 19058 19059 memAllocStatus = ostiAllocMemory( tiRoot, 19060 &satIntIo->satIntDmaMem.osHandle, 19061 (void **)&satIntIo->satIntDmaMem.virtPtr, 19062 &satIntIo->satIntDmaMem.physAddrUpper, 19063 &satIntIo->satIntDmaMem.physAddrLower, 19064 8, 19065 satIntIo->satIntDmaMem.totalLength, 19066 agFALSE); 19067 TI_DBG6(("satAllocIntIoResource: len %d \n", satIntIo->satIntDmaMem.totalLength)); 19068 TI_DBG6(("satAllocIntIoResource: pointer %p \n", satIntIo->satIntDmaMem.osHandle)); 19069 19070 if (memAllocStatus != tiSuccess) 19071 { 19072 TI_DBG1(("satAllocIntIoResource() FAIL to alloc mem for DMA mem.\n")); 19073 /* 19074 * Return satIntIo to the free list 19075 */ 19076 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 19077 TDLIST_DEQUEUE_THIS (&satIntIo->satIntIoLink); 19078 TDLIST_ENQUEUE_AT_HEAD(&satIntIo->satIntIoLink, &satDevData->satFreeIntIoLinkList); 19079 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 19080 19081 /* 19082 * Free mem allocated for Req body 19083 */ 19084 ostiFreeMemory( tiRoot, 19085 satIntIo->satIntReqBodyMem.osHandle, 19086 satIntIo->satIntReqBodyMem.totalLength); 19087 19088 return agNULL; 19089 } 19090 } 19091 19092 /* 19093 typedef struct 19094 { 19095 tdList_t satIntIoLink; 19096 tiIORequest_t satIntTiIORequest; 19097 void *satIntRequestBody; 19098 tiScsiInitiatorRequest_t satIntTiScsiXchg; 19099 tiMem_t satIntDmaMem; 19100 tiMem_t satIntReqBodyMem; 19101 bit32 satIntFlag; 19102 } satInternalIo_t; 19103 */ 19104 19105 /* 19106 * Initialize satIntTiIORequest field 19107 */ 19108 satIntIo->satIntTiIORequest.osData = agNULL; /* Not used for internal SAT I/O */ 19109 satIntIo->satIntTiIORequest.tdData = satIntIo->satIntRequestBody; 19110 19111 /* 19112 * saves the original tiIOrequest 19113 */ 19114 satIntIo->satOrgTiIORequest = tiIORequest; 19115 /* 19116 typedef struct tiIniScsiCmnd 19117 { 19118 tiLUN_t lun; 19119 bit32 expDataLength; 19120 bit32 taskAttribute; 19121 bit32 crn; 19122 bit8 cdb[16]; 19123 } tiIniScsiCmnd_t; 19124 19125 typedef struct tiScsiInitiatorExchange 19126 { 19127 void *sglVirtualAddr; 19128 tiIniScsiCmnd_t scsiCmnd; 19129 tiSgl_t agSgl1; 19130 tiSgl_t agSgl2; 19131 tiDataDirection_t dataDirection; 19132 } tiScsiInitiatorRequest_t; 19133 19134 */ 19135 19136 /* 19137 * Initialize satIntTiScsiXchg. Since the internal SAT request is NOT 19138 * originated from SCSI request, only the following fields are initialized: 19139 * - sglVirtualAddr if DMA transfer is involved 19140 * - agSgl1 if DMA transfer is involved 19141 * - expDataLength in scsiCmnd since this field is read by sataLLIOStart() 19142 */ 19143 if (dmaAllocLength != 0) 19144 { 19145 satIntIo->satIntTiScsiXchg.sglVirtualAddr = satIntIo->satIntDmaMem.virtPtr; 19146 19147 OSSA_WRITE_LE_32(agNULL, &satIntIo->satIntTiScsiXchg.agSgl1.len, 0, 19148 satIntIo->satIntDmaMem.totalLength); 19149 satIntIo->satIntTiScsiXchg.agSgl1.lower = satIntIo->satIntDmaMem.physAddrLower; 19150 satIntIo->satIntTiScsiXchg.agSgl1.upper = satIntIo->satIntDmaMem.physAddrUpper; 19151 satIntIo->satIntTiScsiXchg.agSgl1.type = tiSgl; 19152 19153 satIntIo->satIntTiScsiXchg.scsiCmnd.expDataLength = satIntIo->satIntDmaMem.totalLength; 19154 } 19155 else 19156 { 19157 satIntIo->satIntTiScsiXchg.sglVirtualAddr = agNULL; 19158 19159 satIntIo->satIntTiScsiXchg.agSgl1.len = 0; 19160 satIntIo->satIntTiScsiXchg.agSgl1.lower = 0; 19161 satIntIo->satIntTiScsiXchg.agSgl1.upper = 0; 19162 satIntIo->satIntTiScsiXchg.agSgl1.type = tiSgl; 19163 19164 satIntIo->satIntTiScsiXchg.scsiCmnd.expDataLength = 0; 19165 } 19166 19167 TI_DBG5(("satAllocIntIoResource: satIntIo->satIntTiScsiXchg.agSgl1.len %d\n", satIntIo->satIntTiScsiXchg.agSgl1.len)); 19168 19169 TI_DBG5(("satAllocIntIoResource: satIntIo->satIntTiScsiXchg.agSgl1.upper %d\n", satIntIo->satIntTiScsiXchg.agSgl1.upper)); 19170 19171 TI_DBG5(("satAllocIntIoResource: satIntIo->satIntTiScsiXchg.agSgl1.lower %d\n", satIntIo->satIntTiScsiXchg.agSgl1.lower)); 19172 19173 TI_DBG5(("satAllocIntIoResource: satIntIo->satIntTiScsiXchg.agSgl1.type %d\n", satIntIo->satIntTiScsiXchg.agSgl1.type)); 19174 TI_DBG5(("satAllocIntIoResource: return satIntIo %p\n", satIntIo)); 19175 return satIntIo; 19176 19177 } 19178 19179 /*****************************************************************************/ 19180 /*! \brief Free resource for SAT intervally generated I/O. 19181 * 19182 * Free resource for SAT intervally generated I/O that was previously 19183 * allocated in satAllocIntIoResource(). 19184 * 19185 * \param tiRoot: Pointer to TISA driver/port instance. 19186 * \param satDevData: Pointer to SAT specific device data. 19187 * \param satIntIo: Pointer to context for SAT internal I/O that was 19188 * previously allocated in satAllocIntIoResource(). 19189 * 19190 * \return None 19191 */ 19192 /*****************************************************************************/ 19193 GLOBAL void satFreeIntIoResource( 19194 tiRoot_t *tiRoot, 19195 satDeviceData_t *satDevData, 19196 satInternalIo_t *satIntIo) 19197 { 19198 TI_DBG6(("satFreeIntIoResource: start\n")); 19199 19200 if (satIntIo == agNULL) 19201 { 19202 TI_DBG6(("satFreeIntIoResource: allowed call\n")); 19203 return; 19204 } 19205 19206 /* sets the original tiIOrequest to agNULL for internally generated ATA cmnd */ 19207 satIntIo->satOrgTiIORequest = agNULL; 19208 19209 /* 19210 * Free DMA memory if previosly alocated 19211 */ 19212 if (satIntIo->satIntTiScsiXchg.scsiCmnd.expDataLength != 0) 19213 { 19214 TI_DBG1(("satFreeIntIoResource: DMA len %d\n", satIntIo->satIntDmaMem.totalLength)); 19215 TI_DBG6(("satFreeIntIoResource: pointer %p\n", satIntIo->satIntDmaMem.osHandle)); 19216 19217 ostiFreeMemory( tiRoot, 19218 satIntIo->satIntDmaMem.osHandle, 19219 satIntIo->satIntDmaMem.totalLength); 19220 satIntIo->satIntTiScsiXchg.scsiCmnd.expDataLength = 0; 19221 } 19222 19223 if (satIntIo->satIntReqBodyMem.totalLength != 0) 19224 { 19225 TI_DBG1(("satFreeIntIoResource: req body len %d\n", satIntIo->satIntReqBodyMem.totalLength)); 19226 /* 19227 * Free mem allocated for Req body 19228 */ 19229 ostiFreeMemory( tiRoot, 19230 satIntIo->satIntReqBodyMem.osHandle, 19231 satIntIo->satIntReqBodyMem.totalLength); 19232 19233 satIntIo->satIntReqBodyMem.totalLength = 0; 19234 } 19235 19236 TI_DBG6(("satFreeIntIoResource: satDevData %p satIntIo id %d\n", satDevData, satIntIo->id)); 19237 /* 19238 * Return satIntIo to the free list 19239 */ 19240 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 19241 TDLIST_DEQUEUE_THIS (&(satIntIo->satIntIoLink)); 19242 TDLIST_ENQUEUE_AT_TAIL (&(satIntIo->satIntIoLink), &(satDevData->satFreeIntIoLinkList)); 19243 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 19244 19245 } 19246 19247 19248 /*****************************************************************************/ 19249 /*! \brief SAT implementation for SCSI INQUIRY. 19250 * 19251 * SAT implementation for SCSI INQUIRY. 19252 * This function sends ATA Identify Device data command for SCSI INQUIRY 19253 * 19254 * \param tiRoot: Pointer to TISA initiator driver/port instance. 19255 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 19256 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 19257 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 19258 * \param satIOContext_t: Pointer to the SAT IO Context 19259 * 19260 * \return If command is started successfully 19261 * - \e tiSuccess: I/O request successfully initiated. 19262 * - \e tiBusy: No resources available, try again later. 19263 * - \e tiIONoDevice: Invalid device handle. 19264 * - \e tiError: Other errors. 19265 */ 19266 /*****************************************************************************/ 19267 GLOBAL bit32 satSendIDDev( 19268 tiRoot_t *tiRoot, 19269 tiIORequest_t *tiIORequest, 19270 tiDeviceHandle_t *tiDeviceHandle, 19271 tiScsiInitiatorRequest_t *tiScsiRequest, 19272 satIOContext_t *satIOContext) 19273 19274 { 19275 bit32 status; 19276 bit32 agRequestType; 19277 satDeviceData_t *pSatDevData; 19278 agsaFisRegHostToDevice_t *fis; 19279 #ifdef TD_DEBUG_ENABLE 19280 satInternalIo_t *satIntIoContext; 19281 tdsaDeviceData_t *oneDeviceData; 19282 tdIORequestBody_t *tdIORequestBody; 19283 #endif 19284 19285 pSatDevData = satIOContext->pSatDevData; 19286 fis = satIOContext->pFis; 19287 19288 TI_DBG5(("satSendIDDev: start\n")); 19289 #ifdef TD_DEBUG_ENABLE 19290 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 19291 #endif 19292 TI_DBG5(("satSendIDDev: did %d\n", oneDeviceData->id)); 19293 19294 19295 #ifdef TD_DEBUG_ENABLE 19296 satIntIoContext = satIOContext->satIntIoContext; 19297 tdIORequestBody = satIntIoContext->satIntRequestBody; 19298 #endif 19299 19300 TI_DBG5(("satSendIDDev: satIOContext %p tdIORequestBody %p\n", satIOContext, tdIORequestBody)); 19301 19302 fis->h.fisType = 0x27; /* Reg host to device */ 19303 fis->h.c_pmPort = 0x80; /* C Bit is set */ 19304 if (pSatDevData->satDeviceType == SATA_ATAPI_DEVICE) 19305 fis->h.command = SAT_IDENTIFY_PACKET_DEVICE; /* 0x40 */ 19306 else 19307 fis->h.command = SAT_IDENTIFY_DEVICE; /* 0xEC */ 19308 fis->h.features = 0; /* FIS reserve */ 19309 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 19310 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 19311 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 19312 fis->d.device = 0; /* FIS LBA mode */ 19313 fis->d.lbaLowExp = 0; 19314 fis->d.lbaMidExp = 0; 19315 fis->d.lbaHighExp = 0; 19316 fis->d.featuresExp = 0; 19317 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 19318 fis->d.sectorCountExp = 0; 19319 fis->d.reserved4 = 0; 19320 fis->d.control = 0; /* FIS HOB bit clear */ 19321 fis->d.reserved5 = 0; 19322 19323 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 19324 19325 /* Initialize CB for SATA completion. 19326 */ 19327 satIOContext->satCompleteCB = &satInquiryCB; 19328 19329 /* 19330 * Prepare SGL and send FIS to LL layer. 19331 */ 19332 satIOContext->reqType = agRequestType; /* Save it */ 19333 19334 #ifdef TD_INTERNAL_DEBUG 19335 tdhexdump("satSendIDDev", (bit8 *)satIOContext->pFis, sizeof(agsaFisRegHostToDevice_t)); 19336 #ifdef TD_DEBUG_ENABLE 19337 tdhexdump("satSendIDDev LL", (bit8 *)&(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev), sizeof(agsaFisRegHostToDevice_t)); 19338 #endif 19339 #endif 19340 19341 status = sataLLIOStart( tiRoot, 19342 tiIORequest, 19343 tiDeviceHandle, 19344 tiScsiRequest, 19345 satIOContext); 19346 19347 TI_DBG6(("satSendIDDev: end status %d\n", status)); 19348 return status; 19349 } 19350 19351 19352 /*****************************************************************************/ 19353 /*! \brief SAT implementation for SCSI INQUIRY. 19354 * 19355 * SAT implementation for SCSI INQUIRY. 19356 * This function prepares TD layer internal resource to send ATA 19357 * Identify Device data command for SCSI INQUIRY 19358 * 19359 * \param tiRoot: Pointer to TISA initiator driver/port instance. 19360 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 19361 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 19362 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 19363 * \param satIOContext_t: Pointer to the SAT IO Context 19364 * 19365 * \return If command is started successfully 19366 * - \e tiSuccess: I/O request successfully initiated. 19367 * - \e tiBusy: No resources available, try again later. 19368 * - \e tiIONoDevice: Invalid device handle. 19369 * - \e tiError: Other errors. 19370 */ 19371 /*****************************************************************************/ 19372 /* prerequsite: tdsaDeviceData and agdevhandle must exist; in other words, LL discovered the device 19373 already */ 19374 /* 19375 convert OS generated IO to TD generated IO due to difference in sgl 19376 */ 19377 GLOBAL bit32 satStartIDDev( 19378 tiRoot_t *tiRoot, 19379 tiIORequest_t *tiIORequest, 19380 tiDeviceHandle_t *tiDeviceHandle, 19381 tiScsiInitiatorRequest_t *tiScsiRequest, 19382 satIOContext_t *satIOContext 19383 ) 19384 { 19385 satInternalIo_t *satIntIo = agNULL; 19386 satDeviceData_t *satDevData = agNULL; 19387 tdIORequestBody_t *tdIORequestBody; 19388 satIOContext_t *satNewIOContext; 19389 bit32 status; 19390 19391 TI_DBG6(("satStartIDDev: start\n")); 19392 19393 satDevData = satIOContext->pSatDevData; 19394 19395 TI_DBG6(("satStartIDDev: before alloc\n")); 19396 19397 /* allocate identify device command */ 19398 satIntIo = satAllocIntIoResource( tiRoot, 19399 tiIORequest, 19400 satDevData, 19401 sizeof(agsaSATAIdentifyData_t), /* 512; size of identify device data */ 19402 satIntIo); 19403 19404 TI_DBG6(("satStartIDDev: before after\n")); 19405 19406 if (satIntIo == agNULL) 19407 { 19408 TI_DBG1(("satStartIDDev: can't alloacate\n")); 19409 19410 #if 0 19411 ostiInitiatorIOCompleted ( 19412 tiRoot, 19413 tiIORequest, 19414 tiIOFailed, 19415 tiDetailOtherError, 19416 agNULL, 19417 satIOContext->interruptContext 19418 ); 19419 #endif 19420 19421 return tiError; 19422 } 19423 19424 /* fill in fields */ 19425 /* real ttttttthe one worked and the same; 5/21/07/ */ 19426 satIntIo->satOrgTiIORequest = tiIORequest; /* changed */ 19427 tdIORequestBody = satIntIo->satIntRequestBody; 19428 satNewIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 19429 19430 satNewIOContext->pSatDevData = satDevData; 19431 satNewIOContext->pFis = &(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 19432 satNewIOContext->pScsiCmnd = &(satIntIo->satIntTiScsiXchg.scsiCmnd); 19433 satNewIOContext->pSense = &(tdIORequestBody->transport.SATA.sensePayload); 19434 satNewIOContext->pTiSenseData = &(tdIORequestBody->transport.SATA.tiSenseData); 19435 satNewIOContext->tiRequestBody = satIntIo->satIntRequestBody; /* key fix */ 19436 satNewIOContext->interruptContext = tiInterruptContext; 19437 satNewIOContext->satIntIoContext = satIntIo; 19438 19439 satNewIOContext->ptiDeviceHandle = agNULL; 19440 satNewIOContext->satOrgIOContext = satIOContext; /* changed */ 19441 19442 /* this is valid only for TD layer generated (not triggered by OS at all) IO */ 19443 satNewIOContext->tiScsiXchg = &(satIntIo->satIntTiScsiXchg); 19444 19445 19446 TI_DBG6(("satStartIDDev: OS satIOContext %p \n", satIOContext)); 19447 TI_DBG6(("satStartIDDev: TD satNewIOContext %p \n", satNewIOContext)); 19448 TI_DBG6(("satStartIDDev: OS tiScsiXchg %p \n", satIOContext->tiScsiXchg)); 19449 TI_DBG6(("satStartIDDev: TD tiScsiXchg %p \n", satNewIOContext->tiScsiXchg)); 19450 19451 19452 19453 TI_DBG1(("satStartIDDev: satNewIOContext %p tdIORequestBody %p\n", satNewIOContext, tdIORequestBody)); 19454 19455 status = satSendIDDev( tiRoot, 19456 &satIntIo->satIntTiIORequest, /* New tiIORequest */ 19457 tiDeviceHandle, 19458 satNewIOContext->tiScsiXchg, /* New tiScsiInitiatorRequest_t *tiScsiRequest, */ 19459 satNewIOContext); 19460 19461 if (status != tiSuccess) 19462 { 19463 TI_DBG1(("satStartIDDev: failed in sending\n")); 19464 19465 satFreeIntIoResource( tiRoot, 19466 satDevData, 19467 satIntIo); 19468 19469 #if 0 19470 ostiInitiatorIOCompleted ( 19471 tiRoot, 19472 tiIORequest, 19473 tiIOFailed, 19474 tiDetailOtherError, 19475 agNULL, 19476 satIOContext->interruptContext 19477 ); 19478 #endif 19479 19480 return tiError; 19481 } 19482 19483 19484 TI_DBG6(("satStartIDDev: end\n")); 19485 19486 return status; 19487 19488 19489 } 19490 19491 /*****************************************************************************/ 19492 /*! \brief satComputeCDB10LBA. 19493 * 19494 * This fuctions computes LBA of CDB10. 19495 * 19496 * \param satIOContext_t: Pointer to the SAT IO Context 19497 * 19498 * \return 19499 * - \e LBA 19500 */ 19501 /*****************************************************************************/ 19502 bit32 satComputeCDB10LBA(satIOContext_t *satIOContext) 19503 { 19504 tiIniScsiCmnd_t *scsiCmnd; 19505 tiScsiInitiatorRequest_t *tiScsiRequest; 19506 bit32 lba = 0; 19507 19508 TI_DBG5(("satComputeCDB10LBA: start\n")); 19509 tiScsiRequest = satIOContext->tiScsiXchg; 19510 scsiCmnd = &(tiScsiRequest->scsiCmnd); 19511 19512 lba = (scsiCmnd->cdb[2] << (8*3)) + (scsiCmnd->cdb[3] << (8*2)) 19513 + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 19514 19515 return lba; 19516 } 19517 19518 /*****************************************************************************/ 19519 /*! \brief satComputeCDB10TL. 19520 * 19521 * This fuctions computes transfer length of CDB10. 19522 * 19523 * \param satIOContext_t: Pointer to the SAT IO Context 19524 * 19525 * \return 19526 * - \e TL 19527 */ 19528 /*****************************************************************************/ 19529 bit32 satComputeCDB10TL(satIOContext_t *satIOContext) 19530 { 19531 19532 tiIniScsiCmnd_t *scsiCmnd; 19533 tiScsiInitiatorRequest_t *tiScsiRequest; 19534 bit32 tl = 0; 19535 19536 TI_DBG5(("satComputeCDB10TL: start\n")); 19537 tiScsiRequest = satIOContext->tiScsiXchg; 19538 scsiCmnd = &(tiScsiRequest->scsiCmnd); 19539 19540 tl = (scsiCmnd->cdb[7] << 8) + scsiCmnd->cdb[8]; 19541 return tl; 19542 } 19543 19544 /*****************************************************************************/ 19545 /*! \brief satComputeCDB12LBA. 19546 * 19547 * This fuctions computes LBA of CDB12. 19548 * 19549 * \param satIOContext_t: Pointer to the SAT IO Context 19550 * 19551 * \return 19552 * - \e LBA 19553 */ 19554 /*****************************************************************************/ 19555 bit32 satComputeCDB12LBA(satIOContext_t *satIOContext) 19556 { 19557 tiIniScsiCmnd_t *scsiCmnd; 19558 tiScsiInitiatorRequest_t *tiScsiRequest; 19559 bit32 lba = 0; 19560 19561 TI_DBG5(("satComputeCDB10LBA: start\n")); 19562 tiScsiRequest = satIOContext->tiScsiXchg; 19563 scsiCmnd = &(tiScsiRequest->scsiCmnd); 19564 19565 lba = (scsiCmnd->cdb[2] << (8*3)) + (scsiCmnd->cdb[3] << (8*2)) 19566 + (scsiCmnd->cdb[4] << 8) + scsiCmnd->cdb[5]; 19567 19568 return lba; 19569 } 19570 19571 /*****************************************************************************/ 19572 /*! \brief satComputeCDB12TL. 19573 * 19574 * This fuctions computes transfer length of CDB12. 19575 * 19576 * \param satIOContext_t: Pointer to the SAT IO Context 19577 * 19578 * \return 19579 * - \e TL 19580 */ 19581 /*****************************************************************************/ 19582 bit32 satComputeCDB12TL(satIOContext_t *satIOContext) 19583 { 19584 19585 tiIniScsiCmnd_t *scsiCmnd; 19586 tiScsiInitiatorRequest_t *tiScsiRequest; 19587 bit32 tl = 0; 19588 19589 TI_DBG5(("satComputeCDB10TL: start\n")); 19590 tiScsiRequest = satIOContext->tiScsiXchg; 19591 scsiCmnd = &(tiScsiRequest->scsiCmnd); 19592 19593 tl = (scsiCmnd->cdb[6] << (8*3)) + (scsiCmnd->cdb[7] << (8*2)) 19594 + (scsiCmnd->cdb[8] << 8) + scsiCmnd->cdb[9]; 19595 return tl; 19596 } 19597 19598 19599 /*****************************************************************************/ 19600 /*! \brief satComputeCDB16LBA. 19601 * 19602 * This fuctions computes LBA of CDB16. 19603 * 19604 * \param satIOContext_t: Pointer to the SAT IO Context 19605 * 19606 * \return 19607 * - \e LBA 19608 */ 19609 /*****************************************************************************/ 19610 /* 19611 CBD16 has bit64 LBA 19612 But it has to be less than (2^28 - 1) 19613 Therefore, use last four bytes to compute LBA is OK 19614 */ 19615 bit32 satComputeCDB16LBA(satIOContext_t *satIOContext) 19616 { 19617 tiIniScsiCmnd_t *scsiCmnd; 19618 tiScsiInitiatorRequest_t *tiScsiRequest; 19619 bit32 lba = 0; 19620 19621 TI_DBG5(("satComputeCDB10LBA: start\n")); 19622 tiScsiRequest = satIOContext->tiScsiXchg; 19623 scsiCmnd = &(tiScsiRequest->scsiCmnd); 19624 19625 lba = (scsiCmnd->cdb[6] << (8*3)) + (scsiCmnd->cdb[7] << (8*2)) 19626 + (scsiCmnd->cdb[8] << 8) + scsiCmnd->cdb[9]; 19627 19628 return lba; 19629 } 19630 19631 /*****************************************************************************/ 19632 /*! \brief satComputeCDB16TL. 19633 * 19634 * This fuctions computes transfer length of CDB16. 19635 * 19636 * \param satIOContext_t: Pointer to the SAT IO Context 19637 * 19638 * \return 19639 * - \e TL 19640 */ 19641 /*****************************************************************************/ 19642 bit32 satComputeCDB16TL(satIOContext_t *satIOContext) 19643 { 19644 19645 tiIniScsiCmnd_t *scsiCmnd; 19646 tiScsiInitiatorRequest_t *tiScsiRequest; 19647 bit32 tl = 0; 19648 19649 TI_DBG5(("satComputeCDB10TL: start\n")); 19650 tiScsiRequest = satIOContext->tiScsiXchg; 19651 scsiCmnd = &(tiScsiRequest->scsiCmnd); 19652 19653 tl = (scsiCmnd->cdb[10] << (8*3)) + (scsiCmnd->cdb[11] << (8*2)) 19654 + (scsiCmnd->cdb[12] << 8) + scsiCmnd->cdb[13]; 19655 return tl; 19656 } 19657 19658 /*****************************************************************************/ 19659 /*! \brief satComputeLoopNum. 19660 * 19661 * This fuctions computes the number of interation needed for a transfer 19662 * length with a specific number. 19663 * 19664 * \param a: a numerator 19665 * \param b: a denominator 19666 * 19667 * \return 19668 * - \e number of interation 19669 */ 19670 /*****************************************************************************/ 19671 /* 19672 (tl, denom) 19673 tl can be upto bit32 because CDB16 has bit32 tl 19674 Therefore, fine 19675 either (tl, 0xFF) or (tl, 0xFFFF) 19676 */ 19677 bit32 satComputeLoopNum(bit32 a, bit32 b) 19678 { 19679 19680 bit32 quo = 0, rem = 0; 19681 bit32 LoopNum = 0; 19682 19683 TI_DBG5(("satComputeLoopNum: start\n")); 19684 19685 quo = a/b; 19686 19687 if (quo == 0) 19688 { 19689 LoopNum = 1; 19690 } 19691 else 19692 { 19693 rem = a % b; 19694 if (rem == 0) 19695 { 19696 LoopNum = quo; 19697 } 19698 else 19699 { 19700 LoopNum = quo + 1; 19701 } 19702 } 19703 19704 return LoopNum; 19705 } 19706 19707 /*****************************************************************************/ 19708 /*! \brief satAddNComparebit64. 19709 * 19710 * 19711 * 19712 * 19713 * \param a: lba 19714 * \param b: tl 19715 * 19716 * \return 19717 * - \e TRUE if (lba + tl > SAT_TR_LBA_LIMIT) 19718 * - \e FALSE otherwise 19719 * \note: a and b must be in the same length 19720 */ 19721 /*****************************************************************************/ 19722 /* 19723 input: bit8 a[8], bit8 b[8] (lba, tl) must be in same length 19724 if (lba + tl > SAT_TR_LBA_LIMIT) 19725 then returns true 19726 else returns false 19727 (LBA,TL) 19728 */ 19729 bit32 satAddNComparebit64(bit8 *a, bit8 *b) 19730 { 19731 bit16 ans[8]; // 0 MSB, 8 LSB 19732 bit8 final_ans[9]; // 0 MSB, 9 LSB 19733 bit8 max[9]; 19734 int i; 19735 19736 TI_DBG5(("satAddNComparebit64: start\n")); 19737 19738 osti_memset(ans, 0, sizeof(ans)); 19739 osti_memset(final_ans, 0, sizeof(final_ans)); 19740 osti_memset(max, 0, sizeof(max)); 19741 19742 max[0] = 0x1; //max = 0x1 0000 0000 0000 0000 19743 19744 // adding from LSB to MSB 19745 for(i=7;i>=0;i--) 19746 { 19747 ans[i] = (bit16)(a[i] + b[i]); 19748 if (i != 7) 19749 { 19750 ans[i] = (bit16)(ans[i] + ((ans[i+1] & 0xFF00) >> 8)); 19751 } 19752 } 19753 19754 /* 19755 filling in the final answer 19756 */ 19757 final_ans[0] = (bit8)(((ans[0] & 0xFF00) >> 8)); 19758 final_ans[1] = (bit8)(ans[0] & 0xFF); 19759 19760 for(i=2;i<=8;i++) 19761 { 19762 final_ans[i] = (bit8)(ans[i-1] & 0xFF); 19763 } 19764 19765 //compare final_ans to max 19766 for(i=0;i<=8;i++) 19767 { 19768 if (final_ans[i] > max[i]) 19769 { 19770 TI_DBG5(("satAddNComparebit64: yes at %d\n", i)); 19771 return agTRUE; 19772 } 19773 else if (final_ans[i] < max[i]) 19774 { 19775 TI_DBG5(("satAddNComparebit64: no at %d\n", i)); 19776 return agFALSE; 19777 } 19778 else 19779 { 19780 continue; 19781 } 19782 } 19783 19784 19785 return agFALSE; 19786 } 19787 19788 /*****************************************************************************/ 19789 /*! \brief satAddNComparebit32. 19790 * 19791 * 19792 * 19793 * 19794 * \param a: lba 19795 * \param b: tl 19796 * 19797 * \return 19798 * - \e TRUE if (lba + tl > SAT_TR_LBA_LIMIT) 19799 * - \e FALSE otherwise 19800 * \note: a and b must be in the same length 19801 */ 19802 /*****************************************************************************/ 19803 /* 19804 input: bit8 a[4], bit8 b[4] (lba, tl) must be in same length 19805 if (lba + tl > SAT_TR_LBA_LIMIT) 19806 then returns true 19807 else returns false 19808 (LBA,TL) 19809 */ 19810 bit32 satAddNComparebit32(bit8 *a, bit8 *b) 19811 { 19812 bit16 ans[4]; // 0 MSB, 4 LSB 19813 bit8 final_ans[5]; // 0 MSB, 5 LSB 19814 bit8 max[4]; 19815 int i; 19816 19817 TI_DBG5(("satAddNComparebit32: start\n")); 19818 19819 osti_memset(ans, 0, sizeof(ans)); 19820 osti_memset(final_ans, 0, sizeof(final_ans)); 19821 osti_memset(max, 0, sizeof(max)); 19822 19823 max[0] = 0x10; // max =0x1000 0000 19824 19825 // adding from LSB to MSB 19826 for(i=3;i>=0;i--) 19827 { 19828 ans[i] = (bit16)(a[i] + b[i]); 19829 if (i != 3) 19830 { 19831 ans[i] = (bit16)(ans[i] + ((ans[i+1] & 0xFF00) >> 8)); 19832 } 19833 } 19834 19835 19836 /* 19837 filling in the final answer 19838 */ 19839 final_ans[0] = (bit8)(((ans[0] & 0xFF00) >> 8)); 19840 final_ans[1] = (bit8)(ans[0] & 0xFF); 19841 19842 for(i=2;i<=4;i++) 19843 { 19844 final_ans[i] = (bit8)(ans[i-1] & 0xFF); 19845 } 19846 19847 //compare final_ans to max 19848 if (final_ans[0] != 0) 19849 { 19850 TI_DBG5(("satAddNComparebit32: yes bigger and out of range\n")); 19851 return agTRUE; 19852 } 19853 for(i=1;i<=4;i++) 19854 { 19855 if (final_ans[i] > max[i-1]) 19856 { 19857 TI_DBG5(("satAddNComparebit32: yes at %d\n", i)); 19858 return agTRUE; 19859 } 19860 else if (final_ans[i] < max[i-1]) 19861 { 19862 TI_DBG5(("satAddNComparebit32: no at %d\n", i)); 19863 return agFALSE; 19864 } 19865 else 19866 { 19867 continue; 19868 } 19869 } 19870 19871 19872 return agFALSE; 19873 } 19874 19875 /*****************************************************************************/ 19876 /*! \brief satCompareLBALimitbit. 19877 * 19878 * 19879 * 19880 * 19881 * \param lba: lba 19882 * 19883 * \return 19884 * - \e TRUE if (lba > SAT_TR_LBA_LIMIT - 1) 19885 * - \e FALSE otherwise 19886 * \note: a and b must be in the same length 19887 */ 19888 /*****************************************************************************/ 19889 19890 /* 19891 lba 19892 */ 19893 /* 19894 input: bit8 lba[8] 19895 if (lba > SAT_TR_LBA_LIMIT - 1) 19896 then returns true 19897 else returns false 19898 (LBA,TL) 19899 */ 19900 bit32 satCompareLBALimitbit(bit8 *lba) 19901 { 19902 bit32 i; 19903 bit8 limit[8]; 19904 19905 /* limit is 0xF FF FF = 2^28 - 1 */ 19906 limit[0] = 0x0; /* MSB */ 19907 limit[1] = 0x0; 19908 limit[2] = 0x0; 19909 limit[3] = 0x0; 19910 limit[4] = 0xF; 19911 limit[5] = 0xFF; 19912 limit[6] = 0xFF; 19913 limit[7] = 0xFF; /* LSB */ 19914 19915 //compare lba to limit 19916 for(i=0;i<8;i++) 19917 { 19918 if (lba[i] > limit[i]) 19919 { 19920 TI_DBG5(("satCompareLBALimitbit64: yes at %d\n", i)); 19921 return agTRUE; 19922 } 19923 else if (lba[i] < limit[i]) 19924 { 19925 TI_DBG5(("satCompareLBALimitbit64: no at %d\n", i)); 19926 return agFALSE; 19927 } 19928 else 19929 { 19930 continue; 19931 } 19932 } 19933 19934 19935 return agFALSE; 19936 19937 } 19938 /***************************************************************************** 19939 *! \brief 19940 * Purpose: bitwise set 19941 * 19942 * Parameters: 19943 * data - input output buffer 19944 * index - bit to set 19945 * 19946 * Return: 19947 * none 19948 * 19949 *****************************************************************************/ 19950 GLOBAL void 19951 satBitSet(bit8 *data, bit32 index) 19952 { 19953 data[index/8] |= (1 << (index%8)); 19954 } 19955 19956 /***************************************************************************** 19957 *! \brief 19958 * Purpose: bitwise clear 19959 * 19960 * Parameters: 19961 * data - input output buffer 19962 * index - bit to clear 19963 * 19964 * Return: 19965 * none 19966 * 19967 *****************************************************************************/ 19968 GLOBAL void 19969 satBitClear(bit8 *data, bit32 index) 19970 { 19971 data[index/8] &= ~(1 << (index%8)); 19972 } 19973 19974 /***************************************************************************** 19975 *! \brief 19976 * Purpose: bitwise test 19977 * 19978 * Parameters: 19979 * data - input output buffer 19980 * index - bit to test 19981 * 19982 * Return: 19983 * 0 - not set 19984 * 1 - set 19985 * 19986 *****************************************************************************/ 19987 GLOBAL agBOOLEAN 19988 satBitTest(bit8 *data, bit32 index) 19989 { 19990 return ( (BOOLEAN)((data[index/8] & (1 << (index%8)) ) ? 1: 0)); 19991 } 19992 19993 19994 /******************************************************************************/ 19995 /*! \brief allocate an available SATA tag 19996 * 19997 * allocate an available SATA tag 19998 * 19999 * \param tiRoot Pointer to TISA initiator driver/port instance. 20000 * \param pSatDevData 20001 * \param pTag 20002 * 20003 * \return -Success or fail- 20004 */ 20005 /*******************************************************************************/ 20006 GLOBAL bit32 satTagAlloc( 20007 tiRoot_t *tiRoot, 20008 satDeviceData_t *pSatDevData, 20009 bit8 *pTag 20010 ) 20011 { 20012 bit32 retCode = agFALSE; 20013 bit32 i; 20014 20015 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 20016 for ( i = 0; i < pSatDevData->satNCQMaxIO; i ++ ) 20017 { 20018 if ( 0 == satBitTest((bit8 *)&pSatDevData->freeSATAFDMATagBitmap, i) ) 20019 { 20020 satBitSet((bit8*)&pSatDevData->freeSATAFDMATagBitmap, i); 20021 *pTag = (bit8) i; 20022 retCode = agTRUE; 20023 break; 20024 } 20025 } 20026 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 20027 return retCode; 20028 } 20029 20030 /******************************************************************************/ 20031 /*! \brief release an SATA tag 20032 * 20033 * release an available SATA tag 20034 * 20035 * \param tiRoot Pointer to TISA initiator driver/port instance. 20036 * \param pSatDevData 20037 * \param Tag 20038 * 20039 * \return -the tag- 20040 */ 20041 /*******************************************************************************/ 20042 GLOBAL bit32 satTagRelease( 20043 tiRoot_t *tiRoot, 20044 satDeviceData_t *pSatDevData, 20045 bit8 tag 20046 ) 20047 { 20048 bit32 retCode = agFALSE; 20049 20050 tdsaSingleThreadedEnter(tiRoot, TD_SATA_LOCK); 20051 if ( tag < pSatDevData->satNCQMaxIO ) 20052 { 20053 satBitClear( (bit8 *)&pSatDevData->freeSATAFDMATagBitmap, (bit32)tag); 20054 retCode = agTRUE; 20055 } 20056 tdsaSingleThreadedLeave(tiRoot, TD_SATA_LOCK); 20057 return retCode; 20058 } 20059 20060 /***************************************************************************** 20061 *! \brief satSubTM 20062 * 20063 * This routine is called to initiate a TM request to SATL. 20064 * This routine is independent of HW/LL API. 20065 * 20066 * \param tiRoot: Pointer to TISA initiator driver/port instance. 20067 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 20068 * \param task: SAM-3 task management request. 20069 * \param lun: Pointer to LUN. 20070 * \param taskTag: Pointer to the associated task where the TM 20071 * command is to be applied. 20072 * \param currentTaskTag: Pointer to tag/context for this TM request. 20073 * \param NotifyOS flag determines whether notify OS layer or not 20074 * 20075 * \return: 20076 * 20077 * \e tiSuccess: I/O request successfully initiated. 20078 * \e tiBusy: No resources available, try again later. 20079 * \e tiIONoDevice: Invalid device handle. 20080 * \e tiError: Other errors that prevent the I/O request to be started. 20081 * 20082 * \note: 20083 * This funcion is triggered bottom up. Not yet in use. 20084 *****************************************************************************/ 20085 /* called for bottom up */ 20086 osGLOBAL bit32 satSubTM( 20087 tiRoot_t *tiRoot, 20088 tiDeviceHandle_t *tiDeviceHandle, 20089 bit32 task, 20090 tiLUN_t *lun, 20091 tiIORequest_t *taskTag, 20092 tiIORequest_t *currentTaskTag, 20093 bit32 NotifyOS 20094 ) 20095 { 20096 void *osMemHandle; 20097 tdIORequestBody_t *TMtdIORequestBody; 20098 bit32 PhysUpper32; 20099 bit32 PhysLower32; 20100 bit32 memAllocStatus; 20101 agsaIORequest_t *agIORequest = agNULL; 20102 20103 TI_DBG6(("satSubTM: start\n")); 20104 20105 /* allocation tdIORequestBody and pass it to satTM() */ 20106 memAllocStatus = ostiAllocMemory( 20107 tiRoot, 20108 &osMemHandle, 20109 (void **)&TMtdIORequestBody, 20110 &PhysUpper32, 20111 &PhysLower32, 20112 8, 20113 sizeof(tdIORequestBody_t), 20114 agTRUE 20115 ); 20116 20117 if (memAllocStatus != tiSuccess) 20118 { 20119 TI_DBG1(("satSubTM: ostiAllocMemory failed... \n")); 20120 return tiError; 20121 } 20122 20123 if (TMtdIORequestBody == agNULL) 20124 { 20125 TI_DBG1(("satSubTM: ostiAllocMemory returned NULL TMIORequestBody\n")); 20126 return tiError; 20127 } 20128 20129 /* setup task management structure */ 20130 TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 20131 TMtdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag = agNULL; 20132 TMtdIORequestBody->IOType.InitiatorTMIO.TaskTag = agNULL; 20133 20134 /* initialize tiDevhandle */ 20135 TMtdIORequestBody->tiDevHandle = tiDeviceHandle; 20136 20137 /* initialize tiIORequest */ 20138 TMtdIORequestBody->tiIORequest = agNULL; 20139 20140 /* initialize agIORequest */ 20141 agIORequest = &(TMtdIORequestBody->agIORequest); 20142 agIORequest->osData = (void *) TMtdIORequestBody; 20143 agIORequest->sdkData = agNULL; /* SA takes care of this */ 20144 satTM(tiRoot, 20145 tiDeviceHandle, 20146 task, /* TD_INTERNAL_TM_RESET */ 20147 agNULL, 20148 agNULL, 20149 agNULL, 20150 TMtdIORequestBody, 20151 agFALSE); 20152 20153 return tiSuccess; 20154 } 20155 20156 20157 /*****************************************************************************/ 20158 /*! \brief SAT implementation for satStartResetDevice. 20159 * 20160 * SAT implementation for sending SRT and send FIS request to LL layer. 20161 * 20162 * \param tiRoot: Pointer to TISA initiator driver/port instance. 20163 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 20164 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 20165 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 20166 * \param satIOContext_t: Pointer to the SAT IO Context 20167 * 20168 * \return If command is started successfully 20169 * - \e tiSuccess: I/O request successfully initiated. 20170 * - \e tiBusy: No resources available, try again later. 20171 * - \e tiIONoDevice: Invalid device handle. 20172 * - \e tiError: Other errors. 20173 * \note : triggerred by OS layer or bottom up 20174 */ 20175 /*****************************************************************************/ 20176 /* OS triggerred or bottom up */ 20177 GLOBAL bit32 20178 satStartResetDevice( 20179 tiRoot_t *tiRoot, 20180 tiIORequest_t *tiIORequest, /* currentTaskTag */ 20181 tiDeviceHandle_t *tiDeviceHandle, 20182 tiScsiInitiatorRequest_t *tiScsiRequest, /* should be NULL */ 20183 satIOContext_t *satIOContext 20184 ) 20185 { 20186 satInternalIo_t *satIntIo = agNULL; 20187 satDeviceData_t *satDevData = agNULL; 20188 satIOContext_t *satNewIOContext; 20189 bit32 status; 20190 tiIORequest_t *currentTaskTag = agNULL; 20191 20192 TI_DBG1(("satStartResetDevice: start\n")); 20193 20194 currentTaskTag = tiIORequest; 20195 20196 satDevData = satIOContext->pSatDevData; 20197 20198 TI_DBG6(("satStartResetDevice: before alloc\n")); 20199 20200 /* allocate any fis for seting SRT bit in device control */ 20201 satIntIo = satAllocIntIoResource( tiRoot, 20202 tiIORequest, 20203 satDevData, 20204 0, 20205 satIntIo); 20206 20207 TI_DBG6(("satStartResetDevice: before after\n")); 20208 20209 if (satIntIo == agNULL) 20210 { 20211 TI_DBG1(("satStartResetDevice: can't alloacate\n")); 20212 if (satIOContext->NotifyOS) 20213 { 20214 ostiInitiatorEvent( tiRoot, 20215 NULL, 20216 NULL, 20217 tiIntrEventTypeTaskManagement, 20218 tiTMFailed, 20219 currentTaskTag ); 20220 } 20221 return tiError; 20222 } 20223 20224 satNewIOContext = satPrepareNewIO(satIntIo, 20225 tiIORequest, 20226 satDevData, 20227 agNULL, 20228 satIOContext); 20229 20230 TI_DBG6(("satStartResetDevice: OS satIOContext %p \n", satIOContext)); 20231 TI_DBG6(("satStartResetDevice: TD satNewIOContext %p \n", satNewIOContext)); 20232 TI_DBG6(("satStartResetDevice: OS tiScsiXchg %p \n", satIOContext->tiScsiXchg)); 20233 TI_DBG6(("satStartResetDevice: TD tiScsiXchg %p \n", satNewIOContext->tiScsiXchg)); 20234 20235 20236 20237 TI_DBG6(("satStartResetDevice: satNewIOContext %p \n", satNewIOContext)); 20238 20239 if (satDevData->satDeviceType == SATA_ATAPI_DEVICE) 20240 { 20241 status = satDeviceReset(tiRoot, 20242 &satIntIo->satIntTiIORequest, /* New tiIORequest */ 20243 tiDeviceHandle, 20244 satNewIOContext->tiScsiXchg, /* New tiScsiInitiatorRequest_t *tiScsiRequest, */ 20245 satNewIOContext); 20246 } 20247 else 20248 { 20249 status = satResetDevice(tiRoot, 20250 &satIntIo->satIntTiIORequest, /* New tiIORequest */ 20251 tiDeviceHandle, 20252 satNewIOContext->tiScsiXchg, /* New tiScsiInitiatorRequest_t *tiScsiRequest, */ 20253 satNewIOContext); 20254 } 20255 20256 if (status != tiSuccess) 20257 { 20258 TI_DBG1(("satStartResetDevice: failed in sending\n")); 20259 20260 satFreeIntIoResource( tiRoot, 20261 satDevData, 20262 satIntIo); 20263 if (satIOContext->NotifyOS) 20264 { 20265 ostiInitiatorEvent( tiRoot, 20266 NULL, 20267 NULL, 20268 tiIntrEventTypeTaskManagement, 20269 tiTMFailed, 20270 currentTaskTag ); 20271 } 20272 20273 return tiError; 20274 } 20275 20276 20277 TI_DBG6(("satStartResetDevice: end\n")); 20278 20279 return status; 20280 } 20281 20282 /*****************************************************************************/ 20283 /*! \brief SAT implementation for satResetDevice. 20284 * 20285 * SAT implementation for building SRT FIS and sends the request to LL layer. 20286 * 20287 * \param tiRoot: Pointer to TISA initiator driver/port instance. 20288 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 20289 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 20290 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 20291 * \param satIOContext_t: Pointer to the SAT IO Context 20292 * 20293 * \return If command is started successfully 20294 * - \e tiSuccess: I/O request successfully initiated. 20295 * - \e tiBusy: No resources available, try again later. 20296 * - \e tiIONoDevice: Invalid device handle. 20297 * - \e tiError: Other errors. 20298 */ 20299 /*****************************************************************************/ 20300 20301 /* 20302 create any fis and set SRST bit in device control 20303 */ 20304 GLOBAL bit32 20305 satResetDevice( 20306 tiRoot_t *tiRoot, 20307 tiIORequest_t *tiIORequest, 20308 tiDeviceHandle_t *tiDeviceHandle, 20309 tiScsiInitiatorRequest_t *tiScsiRequest, 20310 satIOContext_t *satIOContext 20311 ) 20312 { 20313 bit32 status; 20314 bit32 agRequestType; 20315 agsaFisRegHostToDevice_t *fis; 20316 #ifdef TD_DEBUG_ENABLE 20317 tdIORequestBody_t *tdIORequestBody; 20318 satInternalIo_t *satIntIoContext; 20319 #endif 20320 20321 fis = satIOContext->pFis; 20322 20323 TI_DBG2(("satResetDevice: start\n")); 20324 20325 #ifdef TD_DEBUG_ENABLE 20326 satIntIoContext = satIOContext->satIntIoContext; 20327 tdIORequestBody = satIntIoContext->satIntRequestBody; 20328 #endif 20329 TI_DBG5(("satResetDevice: satIOContext %p tdIORequestBody %p\n", satIOContext, tdIORequestBody)); 20330 /* any fis should work */ 20331 fis->h.fisType = 0x27; /* Reg host to device */ 20332 fis->h.c_pmPort = 0; /* C Bit is not set */ 20333 fis->h.command = 0; /* any command */ 20334 fis->h.features = 0; /* FIS reserve */ 20335 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 20336 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 20337 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 20338 fis->d.device = 0; /* FIS LBA mode */ 20339 fis->d.lbaLowExp = 0; 20340 fis->d.lbaMidExp = 0; 20341 fis->d.lbaHighExp = 0; 20342 fis->d.featuresExp = 0; 20343 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 20344 fis->d.sectorCountExp = 0; 20345 fis->d.reserved4 = 0; 20346 fis->d.control = 0x4; /* SRST bit is set */ 20347 fis->d.reserved5 = 0; 20348 20349 agRequestType = AGSA_SATA_PROTOCOL_SRST_ASSERT; 20350 20351 satIOContext->satCompleteCB = &satResetDeviceCB; 20352 20353 /* 20354 * Prepare SGL and send FIS to LL layer. 20355 */ 20356 satIOContext->reqType = agRequestType; /* Save it */ 20357 20358 #ifdef TD_INTERNAL_DEBUG 20359 tdhexdump("satResetDevice", (bit8 *)satIOContext->pFis, sizeof(agsaFisRegHostToDevice_t)); 20360 #ifdef TD_DEBUG_ENABLE 20361 tdhexdump("satResetDevice LL", (bit8 *)&(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev), sizeof(agsaFisRegHostToDevice_t)); 20362 #endif 20363 #endif 20364 20365 status = sataLLIOStart( tiRoot, 20366 tiIORequest, 20367 tiDeviceHandle, 20368 tiScsiRequest, 20369 satIOContext); 20370 20371 TI_DBG6(("satResetDevice: end status %d\n", status)); 20372 return status; 20373 } 20374 20375 /***************************************************************************** 20376 *! \brief satResetDeviceCB 20377 * 20378 * This routine is a callback function called from ossaSATACompleted(). 20379 * This CB routine deals with SRT completion. This function send DSRT 20380 * 20381 * \param agRoot: Handles for this instance of SAS/SATA hardware 20382 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 20383 * \param agIOStatus: Status of completed I/O. 20384 * \param agFirstDword:Pointer to the four bytes of FIS. 20385 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 20386 * length. 20387 * \param agParam: Additional info based on status. 20388 * \param ioContext: Pointer to satIOContext_t. 20389 * 20390 * \return: none 20391 * 20392 *****************************************************************************/ 20393 GLOBAL void satResetDeviceCB( 20394 agsaRoot_t *agRoot, 20395 agsaIORequest_t *agIORequest, 20396 bit32 agIOStatus, 20397 agsaFisHeader_t *agFirstDword, 20398 bit32 agIOInfoLen, 20399 agsaFrameHandle_t agFrameHandle, 20400 void *ioContext 20401 ) 20402 { 20403 /* callback for satResetDevice */ 20404 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 20405 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 20406 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 20407 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 20408 tdIORequestBody_t *tdIORequestBody; 20409 tdIORequestBody_t *tdOrgIORequestBody; 20410 satIOContext_t *satIOContext; 20411 satIOContext_t *satOrgIOContext; 20412 satIOContext_t *satNewIOContext; 20413 satInternalIo_t *satIntIo; 20414 satInternalIo_t *satNewIntIo = agNULL; 20415 satDeviceData_t *satDevData; 20416 tiIORequest_t *tiOrgIORequest; 20417 #ifdef TD_DEBUG_ENABLE 20418 bit32 ataStatus = 0; 20419 bit32 ataError; 20420 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 20421 #endif 20422 bit32 status; 20423 20424 TI_DBG1(("satResetDeviceCB: start\n")); 20425 TI_DBG6(("satResetDeviceCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 20426 20427 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 20428 satIOContext = (satIOContext_t *) ioContext; 20429 satIntIo = satIOContext->satIntIoContext; 20430 satDevData = satIOContext->pSatDevData; 20431 if (satIntIo == agNULL) 20432 { 20433 TI_DBG6(("satResetDeviceCB: External, OS generated\n")); 20434 satOrgIOContext = satIOContext; 20435 tiOrgIORequest = tdIORequestBody->tiIORequest; 20436 } 20437 else 20438 { 20439 TI_DBG6(("satResetDeviceCB: Internal, TD generated\n")); 20440 satOrgIOContext = satIOContext->satOrgIOContext; 20441 if (satOrgIOContext == agNULL) 20442 { 20443 TI_DBG6(("satResetDeviceCB: satOrgIOContext is NULL, wrong\n")); 20444 return; 20445 } 20446 else 20447 { 20448 TI_DBG6(("satResetDeviceCB: satOrgIOContext is NOT NULL\n")); 20449 } 20450 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 20451 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 20452 } 20453 20454 tdIORequestBody->ioCompleted = agTRUE; 20455 tdIORequestBody->ioStarted = agFALSE; 20456 20457 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 20458 { 20459 TI_DBG1(("satResetDeviceCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 20460 if (satOrgIOContext->NotifyOS == agTRUE) 20461 { 20462 ostiInitiatorEvent( tiRoot, 20463 NULL, 20464 NULL, 20465 tiIntrEventTypeTaskManagement, 20466 tiTMFailed, 20467 tiOrgIORequest ); 20468 } 20469 20470 satDevData->satTmTaskTag = agNULL; 20471 20472 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 20473 20474 satFreeIntIoResource( tiRoot, 20475 satDevData, 20476 satIntIo); 20477 return; 20478 } 20479 20480 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED || 20481 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION || 20482 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK || 20483 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS || 20484 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION || 20485 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED || 20486 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION || 20487 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR || 20488 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY 20489 ) 20490 { 20491 TI_DBG1(("satResetDeviceCB: OSSA_IO_OPEN_CNX_ERROR\n")); 20492 20493 if (satOrgIOContext->NotifyOS == agTRUE) 20494 { 20495 ostiInitiatorEvent( tiRoot, 20496 NULL, 20497 NULL, 20498 tiIntrEventTypeTaskManagement, 20499 tiTMFailed, 20500 tiOrgIORequest ); 20501 } 20502 20503 satDevData->satTmTaskTag = agNULL; 20504 20505 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 20506 20507 satFreeIntIoResource( tiRoot, 20508 satDevData, 20509 satIntIo); 20510 return; 20511 } 20512 20513 if (agIOStatus != OSSA_IO_SUCCESS) 20514 { 20515 #ifdef TD_DEBUG_ENABLE 20516 /* only agsaFisPioSetup_t is expected */ 20517 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup); 20518 ataStatus = satPIOSetupHeader->status; /* ATA Status register */ 20519 ataError = satPIOSetupHeader->error; /* ATA Eror register */ 20520 #endif 20521 TI_DBG1(("satResetDeviceCB: ataStatus 0x%x ataError 0x%x\n", ataStatus, ataError)); 20522 20523 if (satOrgIOContext->NotifyOS == agTRUE) 20524 { 20525 ostiInitiatorEvent( tiRoot, 20526 NULL, 20527 NULL, 20528 tiIntrEventTypeTaskManagement, 20529 tiTMFailed, 20530 tiOrgIORequest ); 20531 } 20532 20533 satDevData->satTmTaskTag = agNULL; 20534 20535 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 20536 20537 satFreeIntIoResource( tiRoot, 20538 satDevData, 20539 satIntIo); 20540 return; 20541 } 20542 20543 /* success */ 20544 20545 satNewIntIo = satAllocIntIoResource( tiRoot, 20546 tiOrgIORequest, 20547 satDevData, 20548 0, 20549 satNewIntIo); 20550 if (satNewIntIo == agNULL) 20551 { 20552 satDevData->satTmTaskTag = agNULL; 20553 20554 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 20555 20556 /* memory allocation failure */ 20557 satFreeIntIoResource( tiRoot, 20558 satDevData, 20559 satNewIntIo); 20560 20561 if (satOrgIOContext->NotifyOS == agTRUE) 20562 { 20563 ostiInitiatorEvent( tiRoot, 20564 NULL, 20565 NULL, 20566 tiIntrEventTypeTaskManagement, 20567 tiTMFailed, 20568 tiOrgIORequest ); 20569 } 20570 20571 20572 TI_DBG1(("satResetDeviceCB: momory allocation fails\n")); 20573 return; 20574 } /* end of memory allocation failure */ 20575 20576 /* 20577 * Need to initialize all the fields within satIOContext 20578 */ 20579 20580 satNewIOContext = satPrepareNewIO( 20581 satNewIntIo, 20582 tiOrgIORequest, 20583 satDevData, 20584 agNULL, 20585 satOrgIOContext 20586 ); 20587 20588 20589 20590 20591 /* send AGSA_SATA_PROTOCOL_SRST_DEASSERT */ 20592 status = satDeResetDevice(tiRoot, 20593 tiOrgIORequest, 20594 satOrgIOContext->ptiDeviceHandle, 20595 agNULL, 20596 satNewIOContext 20597 ); 20598 20599 if (status != tiSuccess) 20600 { 20601 if (satOrgIOContext->NotifyOS == agTRUE) 20602 { 20603 ostiInitiatorEvent( tiRoot, 20604 NULL, 20605 NULL, 20606 tiIntrEventTypeTaskManagement, 20607 tiTMFailed, 20608 tiOrgIORequest ); 20609 } 20610 20611 /* sending AGSA_SATA_PROTOCOL_SRST_DEASSERT fails */ 20612 20613 satDevData->satTmTaskTag = agNULL; 20614 20615 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 20616 20617 satFreeIntIoResource( tiRoot, 20618 satDevData, 20619 satNewIntIo); 20620 return; 20621 20622 } 20623 20624 satDevData->satTmTaskTag = agNULL; 20625 20626 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 20627 20628 satFreeIntIoResource( tiRoot, 20629 satDevData, 20630 satIntIo); 20631 TI_DBG5(("satResetDeviceCB: device %p pending IO %d\n", satDevData, satDevData->satPendingIO)); 20632 TI_DBG6(("satResetDeviceCB: end\n")); 20633 return; 20634 20635 } 20636 20637 20638 /*****************************************************************************/ 20639 /*! \brief SAT implementation for satDeResetDevice. 20640 * 20641 * SAT implementation for building DSRT FIS and sends the request to LL layer. 20642 * 20643 * \param tiRoot: Pointer to TISA initiator driver/port instance. 20644 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 20645 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 20646 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 20647 * \param satIOContext_t: Pointer to the SAT IO Context 20648 * 20649 * \return If command is started successfully 20650 * - \e tiSuccess: I/O request successfully initiated. 20651 * - \e tiBusy: No resources available, try again later. 20652 * - \e tiIONoDevice: Invalid device handle. 20653 * - \e tiError: Other errors. 20654 */ 20655 /*****************************************************************************/ 20656 GLOBAL bit32 satDeResetDevice( 20657 tiRoot_t *tiRoot, 20658 tiIORequest_t *tiIORequest, 20659 tiDeviceHandle_t *tiDeviceHandle, 20660 tiScsiInitiatorRequest_t *tiScsiRequest, 20661 satIOContext_t *satIOContext 20662 ) 20663 { 20664 bit32 status; 20665 bit32 agRequestType; 20666 agsaFisRegHostToDevice_t *fis; 20667 #ifdef TD_DEBUG_ENABLE 20668 tdIORequestBody_t *tdIORequestBody; 20669 satInternalIo_t *satIntIoContext; 20670 #endif 20671 fis = satIOContext->pFis; 20672 20673 TI_DBG6(("satDeResetDevice: start\n")); 20674 20675 #ifdef TD_DEBUG_ENABLE 20676 satIntIoContext = satIOContext->satIntIoContext; 20677 tdIORequestBody = satIntIoContext->satIntRequestBody; 20678 TI_DBG5(("satDeResetDevice: satIOContext %p tdIORequestBody %p\n", satIOContext, tdIORequestBody)); 20679 #endif 20680 /* any fis should work */ 20681 fis->h.fisType = 0x27; /* Reg host to device */ 20682 fis->h.c_pmPort = 0; /* C Bit is not set */ 20683 fis->h.command = 0; /* any command */ 20684 fis->h.features = 0; /* FIS reserve */ 20685 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 20686 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 20687 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 20688 fis->d.device = 0; /* FIS LBA mode */ 20689 fis->d.lbaLowExp = 0; 20690 fis->d.lbaMidExp = 0; 20691 fis->d.lbaHighExp = 0; 20692 fis->d.featuresExp = 0; 20693 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 20694 fis->d.sectorCountExp = 0; 20695 fis->d.reserved4 = 0; 20696 fis->d.control = 0; /* SRST bit is not set */ 20697 fis->d.reserved5 = 0; 20698 20699 agRequestType = AGSA_SATA_PROTOCOL_SRST_DEASSERT; 20700 20701 satIOContext->satCompleteCB = &satDeResetDeviceCB; 20702 20703 /* 20704 * Prepare SGL and send FIS to LL layer. 20705 */ 20706 satIOContext->reqType = agRequestType; /* Save it */ 20707 20708 #ifdef TD_INTERNAL_DEBUG 20709 tdhexdump("satDeResetDevice", (bit8 *)satIOContext->pFis, sizeof(agsaFisRegHostToDevice_t)); 20710 #ifdef TD_DEBUG_ENABLE 20711 tdhexdump("satDeResetDevice LL", (bit8 *)&(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev), sizeof(agsaFisRegHostToDevice_t)); 20712 #endif 20713 #endif 20714 20715 status = sataLLIOStart( tiRoot, 20716 tiIORequest, 20717 tiDeviceHandle, 20718 tiScsiRequest, 20719 satIOContext); 20720 20721 TI_DBG6(("satDeResetDevice: end status %d\n", status)); 20722 return status; 20723 20724 } 20725 20726 /***************************************************************************** 20727 *! \brief satDeResetDeviceCB 20728 * 20729 * This routine is a callback function called from ossaSATACompleted(). 20730 * This CB routine deals with DSRT completion. 20731 * 20732 * \param agRoot: Handles for this instance of SAS/SATA hardware 20733 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 20734 * \param agIOStatus: Status of completed I/O. 20735 * \param agFirstDword:Pointer to the four bytes of FIS. 20736 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 20737 * length. 20738 * \param agParam: Additional info based on status. 20739 * \param ioContext: Pointer to satIOContext_t. 20740 * 20741 * \return: none 20742 * 20743 *****************************************************************************/ 20744 GLOBAL void satDeResetDeviceCB( 20745 agsaRoot_t *agRoot, 20746 agsaIORequest_t *agIORequest, 20747 bit32 agIOStatus, 20748 agsaFisHeader_t *agFirstDword, 20749 bit32 agIOInfoLen, 20750 agsaFrameHandle_t agFrameHandle, 20751 void *ioContext 20752 ) 20753 { 20754 /* callback for satDeResetDevice */ 20755 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 20756 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 20757 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 20758 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 20759 tdIORequestBody_t *tdIORequestBody; 20760 tdIORequestBody_t *tdOrgIORequestBody = agNULL; 20761 satIOContext_t *satIOContext; 20762 satIOContext_t *satOrgIOContext; 20763 satInternalIo_t *satIntIo; 20764 satDeviceData_t *satDevData; 20765 tiIORequest_t *tiOrgIORequest; 20766 #ifdef TD_DEBUG_ENABLE 20767 bit32 ataStatus = 0; 20768 bit32 ataError; 20769 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 20770 #endif 20771 bit32 report = agFALSE; 20772 bit32 AbortTM = agFALSE; 20773 20774 TI_DBG1(("satDeResetDeviceCB: start\n")); 20775 TI_DBG6(("satDeResetDeviceCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 20776 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 20777 satIOContext = (satIOContext_t *) ioContext; 20778 satIntIo = satIOContext->satIntIoContext; 20779 satDevData = satIOContext->pSatDevData; 20780 if (satIntIo == agNULL) 20781 { 20782 TI_DBG6(("satDeResetDeviceCB: External, OS generated\n")); 20783 satOrgIOContext = satIOContext; 20784 tiOrgIORequest = tdIORequestBody->tiIORequest; 20785 } 20786 else 20787 { 20788 TI_DBG6(("satDeResetDeviceCB: Internal, TD generated\n")); 20789 satOrgIOContext = satIOContext->satOrgIOContext; 20790 if (satOrgIOContext == agNULL) 20791 { 20792 TI_DBG6(("satDeResetDeviceCB: satOrgIOContext is NULL, wrong\n")); 20793 return; 20794 } 20795 else 20796 { 20797 TI_DBG6(("satDeResetDeviceCB: satOrgIOContext is NOT NULL\n")); 20798 } 20799 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 20800 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 20801 } 20802 20803 tdIORequestBody->ioCompleted = agTRUE; 20804 tdIORequestBody->ioStarted = agFALSE; 20805 20806 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 20807 { 20808 TI_DBG1(("satDeResetDeviceCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 20809 if (satOrgIOContext->NotifyOS == agTRUE) 20810 { 20811 ostiInitiatorEvent( tiRoot, 20812 NULL, 20813 NULL, 20814 tiIntrEventTypeTaskManagement, 20815 tiTMFailed, 20816 tiOrgIORequest ); 20817 } 20818 20819 satDevData->satTmTaskTag = agNULL; 20820 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 20821 20822 satFreeIntIoResource( tiRoot, 20823 satDevData, 20824 satIntIo); 20825 return; 20826 } 20827 20828 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED || 20829 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION || 20830 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK || 20831 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS || 20832 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION || 20833 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED || 20834 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION || 20835 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR || 20836 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY 20837 ) 20838 { 20839 TI_DBG1(("satDeResetDeviceCB: OSSA_IO_OPEN_CNX_ERROR\n")); 20840 20841 if (satOrgIOContext->NotifyOS == agTRUE) 20842 { 20843 ostiInitiatorEvent( tiRoot, 20844 NULL, 20845 NULL, 20846 tiIntrEventTypeTaskManagement, 20847 tiTMFailed, 20848 tiOrgIORequest ); 20849 } 20850 20851 satDevData->satTmTaskTag = agNULL; 20852 20853 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 20854 20855 satFreeIntIoResource( tiRoot, 20856 satDevData, 20857 satIntIo); 20858 return; 20859 } 20860 20861 if (agIOStatus != OSSA_IO_SUCCESS) 20862 { 20863 #ifdef TD_DEBUG_ENABLE 20864 /* only agsaFisPioSetup_t is expected */ 20865 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup); 20866 ataStatus = satPIOSetupHeader->status; /* ATA Status register */ 20867 ataError = satPIOSetupHeader->error; /* ATA Eror register */ 20868 #endif 20869 TI_DBG1(("satDeResetDeviceCB: ataStatus 0x%x ataError 0x%x\n", ataStatus, ataError)); 20870 20871 if (satOrgIOContext->NotifyOS == agTRUE) 20872 { 20873 ostiInitiatorEvent( tiRoot, 20874 NULL, 20875 NULL, 20876 tiIntrEventTypeTaskManagement, 20877 tiTMFailed, 20878 tiOrgIORequest ); 20879 } 20880 20881 satDevData->satTmTaskTag = agNULL; 20882 20883 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 20884 20885 satFreeIntIoResource( tiRoot, 20886 satDevData, 20887 satIntIo); 20888 return; 20889 } 20890 20891 /* success */ 20892 TI_DBG1(("satDeResetDeviceCB: success \n")); 20893 TI_DBG1(("satDeResetDeviceCB: TMF %d\n", satOrgIOContext->TMF)); 20894 20895 if (satOrgIOContext->TMF == AG_ABORT_TASK) 20896 { 20897 AbortTM = agTRUE; 20898 } 20899 20900 if (satOrgIOContext->NotifyOS == agTRUE) 20901 { 20902 report = agTRUE; 20903 } 20904 20905 if (AbortTM == agTRUE) 20906 { 20907 TI_DBG1(("satDeResetDeviceCB: calling satAbort\n")); 20908 satAbort(agRoot, satOrgIOContext->satToBeAbortedIOContext); 20909 } 20910 satDevData->satTmTaskTag = agNULL; 20911 20912 satDevData->satDriveState = SAT_DEV_STATE_NORMAL; 20913 20914 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 20915 20916 TI_DBG1(("satDeResetDeviceCB: satPendingIO %d satNCQMaxIO %d\n", satDevData->satPendingIO, satDevData->satNCQMaxIO )); 20917 TI_DBG1(("satDeResetDeviceCB: satPendingNCQIO %d satPendingNONNCQIO %d\n", satDevData->satPendingNCQIO, satDevData->satPendingNONNCQIO)); 20918 20919 satFreeIntIoResource( tiRoot, 20920 satDevData, 20921 satIntIo); 20922 20923 /* clean up TD layer's IORequestBody */ 20924 if (tdOrgIORequestBody != agNULL) 20925 { 20926 ostiFreeMemory( 20927 tiRoot, 20928 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 20929 sizeof(tdIORequestBody_t) 20930 ); 20931 } 20932 else 20933 { 20934 TI_DBG1(("satDeResetDeviceCB: tdOrgIORequestBody is NULL, wrong\n")); 20935 } 20936 20937 20938 if (report) 20939 { 20940 ostiInitiatorEvent( tiRoot, 20941 NULL, 20942 NULL, 20943 tiIntrEventTypeTaskManagement, 20944 tiTMOK, 20945 tiOrgIORequest ); 20946 } 20947 20948 20949 TI_DBG5(("satDeResetDeviceCB: device %p pending IO %d\n", satDevData, satDevData->satPendingIO)); 20950 TI_DBG6(("satDeResetDeviceCB: end\n")); 20951 return; 20952 20953 } 20954 20955 /*****************************************************************************/ 20956 /*! \brief SAT implementation for satStartCheckPowerMode. 20957 * 20958 * SAT implementation for abort task management for non-ncq sata disk. 20959 * This function sends CHECK POWER MODE 20960 * 20961 * \param tiRoot: Pointer to TISA initiator driver/port instance. 20962 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 20963 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 20964 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 20965 * \param satIOContext_t: Pointer to the SAT IO Context 20966 * 20967 * \return If command is started successfully 20968 * - \e tiSuccess: I/O request successfully initiated. 20969 * - \e tiBusy: No resources available, try again later. 20970 * - \e tiIONoDevice: Invalid device handle. 20971 * - \e tiError: Other errors. 20972 */ 20973 /*****************************************************************************/ 20974 GLOBAL bit32 satStartCheckPowerMode( 20975 tiRoot_t *tiRoot, 20976 tiIORequest_t *tiIORequest, 20977 tiDeviceHandle_t *tiDeviceHandle, 20978 tiScsiInitiatorRequest_t *tiScsiRequest, /* NULL */ 20979 satIOContext_t *satIOContext 20980 ) 20981 { 20982 satInternalIo_t *satIntIo = agNULL; 20983 satDeviceData_t *satDevData = agNULL; 20984 satIOContext_t *satNewIOContext; 20985 bit32 status; 20986 tiIORequest_t *currentTaskTag = agNULL; 20987 20988 TI_DBG6(("satStartCheckPowerMode: start\n")); 20989 20990 currentTaskTag = tiIORequest; 20991 20992 satDevData = satIOContext->pSatDevData; 20993 20994 TI_DBG6(("satStartCheckPowerMode: before alloc\n")); 20995 20996 /* allocate any fis for seting SRT bit in device control */ 20997 satIntIo = satAllocIntIoResource( tiRoot, 20998 tiIORequest, 20999 satDevData, 21000 0, 21001 satIntIo); 21002 21003 TI_DBG6(("satStartCheckPowerMode: before after\n")); 21004 21005 if (satIntIo == agNULL) 21006 { 21007 TI_DBG1(("satStartCheckPowerMode: can't alloacate\n")); 21008 if (satIOContext->NotifyOS) 21009 { 21010 ostiInitiatorEvent( tiRoot, 21011 NULL, 21012 NULL, 21013 tiIntrEventTypeTaskManagement, 21014 tiTMFailed, 21015 currentTaskTag ); 21016 } 21017 return tiError; 21018 } 21019 21020 satNewIOContext = satPrepareNewIO(satIntIo, 21021 tiIORequest, 21022 satDevData, 21023 agNULL, 21024 satIOContext); 21025 21026 TI_DBG6(("satStartCheckPowerMode: OS satIOContext %p \n", satIOContext)); 21027 TI_DBG6(("satStartCheckPowerMode: TD satNewIOContext %p \n", satNewIOContext)); 21028 TI_DBG6(("satStartCheckPowerMode: OS tiScsiXchg %p \n", satIOContext->tiScsiXchg)); 21029 TI_DBG6(("satStartCheckPowerMode: TD tiScsiXchg %p \n", satNewIOContext->tiScsiXchg)); 21030 21031 21032 21033 TI_DBG1(("satStartCheckPowerMode: satNewIOContext %p \n", satNewIOContext)); 21034 21035 status = satCheckPowerMode(tiRoot, 21036 &satIntIo->satIntTiIORequest, /* New tiIORequest */ 21037 tiDeviceHandle, 21038 satNewIOContext->tiScsiXchg, /* New tiScsiInitiatorRequest_t *tiScsiRequest, */ 21039 satNewIOContext); 21040 21041 if (status != tiSuccess) 21042 { 21043 TI_DBG1(("satStartCheckPowerMode: failed in sending\n")); 21044 21045 satFreeIntIoResource( tiRoot, 21046 satDevData, 21047 satIntIo); 21048 if (satIOContext->NotifyOS) 21049 { 21050 ostiInitiatorEvent( tiRoot, 21051 NULL, 21052 NULL, 21053 tiIntrEventTypeTaskManagement, 21054 tiTMFailed, 21055 currentTaskTag ); 21056 } 21057 21058 return tiError; 21059 } 21060 21061 21062 TI_DBG6(("satStartCheckPowerMode: end\n")); 21063 21064 return status; 21065 } 21066 21067 /*****************************************************************************/ 21068 /*! \brief SAT implementation for satCheckPowerMode. 21069 * 21070 * This function creates CHECK POWER MODE fis and sends the request to LL layer 21071 * 21072 * \param tiRoot: Pointer to TISA initiator driver/port instance. 21073 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 21074 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 21075 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 21076 * \param satIOContext_t: Pointer to the SAT IO Context 21077 * 21078 * \return If command is started successfully 21079 * - \e tiSuccess: I/O request successfully initiated. 21080 * - \e tiBusy: No resources available, try again later. 21081 * - \e tiIONoDevice: Invalid device handle. 21082 * - \e tiError: Other errors. 21083 */ 21084 /*****************************************************************************/ 21085 GLOBAL bit32 satCheckPowerMode( 21086 tiRoot_t *tiRoot, 21087 tiIORequest_t *tiIORequest, 21088 tiDeviceHandle_t *tiDeviceHandle, 21089 tiScsiInitiatorRequest_t *tiScsiRequest, 21090 satIOContext_t *satIOContext 21091 ) 21092 { 21093 /* 21094 sends SAT_CHECK_POWER_MODE as a part of ABORT TASKMANGEMENT for NCQ commands 21095 internally generated - no directly corresponding scsi 21096 */ 21097 bit32 status; 21098 bit32 agRequestType; 21099 agsaFisRegHostToDevice_t *fis; 21100 21101 fis = satIOContext->pFis; 21102 TI_DBG5(("satCheckPowerMode: start\n")); 21103 /* 21104 * Send the ATA CHECK POWER MODE command. 21105 */ 21106 fis->h.fisType = 0x27; /* Reg host to device */ 21107 fis->h.c_pmPort = 0x80; /* C Bit is set */ 21108 fis->h.command = SAT_CHECK_POWER_MODE; /* 0xE5 */ 21109 fis->h.features = 0; 21110 fis->d.lbaLow = 0; 21111 fis->d.lbaMid = 0; 21112 fis->d.lbaHigh = 0; 21113 fis->d.device = 0; 21114 fis->d.lbaLowExp = 0; 21115 fis->d.lbaMidExp = 0; 21116 fis->d.lbaHighExp = 0; 21117 fis->d.featuresExp = 0; 21118 fis->d.sectorCount = 0; 21119 fis->d.sectorCountExp = 0; 21120 fis->d.reserved4 = 0; 21121 fis->d.control = 0; /* FIS HOB bit clear */ 21122 fis->d.reserved5 = 0; 21123 21124 agRequestType = AGSA_SATA_PROTOCOL_NON_DATA; 21125 21126 /* Initialize CB for SATA completion. 21127 */ 21128 satIOContext->satCompleteCB = &satCheckPowerModeCB; 21129 21130 /* 21131 * Prepare SGL and send FIS to LL layer. 21132 */ 21133 satIOContext->reqType = agRequestType; /* Save it */ 21134 21135 status = sataLLIOStart( tiRoot, 21136 tiIORequest, 21137 tiDeviceHandle, 21138 tiScsiRequest, 21139 satIOContext); 21140 21141 TI_DBG5(("satCheckPowerMode: return\n")); 21142 21143 return status; 21144 } 21145 21146 /***************************************************************************** 21147 *! \brief satCheckPowerModeCB 21148 * 21149 * This routine is a callback function called from ossaSATACompleted(). 21150 * This CB routine deals with CHECK POWER MODE completion as abort task 21151 * management. 21152 * 21153 * \param agRoot: Handles for this instance of SAS/SATA hardware 21154 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 21155 * \param agIOStatus: Status of completed I/O. 21156 * \param agFirstDword:Pointer to the four bytes of FIS. 21157 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 21158 * length. 21159 * \param agParam: Additional info based on status. 21160 * \param ioContext: Pointer to satIOContext_t. 21161 * 21162 * \return: none 21163 * 21164 *****************************************************************************/ 21165 GLOBAL void satCheckPowerModeCB( 21166 agsaRoot_t *agRoot, 21167 agsaIORequest_t *agIORequest, 21168 bit32 agIOStatus, 21169 agsaFisHeader_t *agFirstDword, 21170 bit32 agIOInfoLen, 21171 agsaFrameHandle_t agFrameHandle, 21172 void *ioContext 21173 ) 21174 { 21175 /* callback for satDeResetDevice */ 21176 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 21177 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 21178 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 21179 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 21180 tdIORequestBody_t *tdIORequestBody; 21181 tdIORequestBody_t *tdOrgIORequestBody = agNULL; 21182 satIOContext_t *satIOContext; 21183 satIOContext_t *satOrgIOContext; 21184 satInternalIo_t *satIntIo; 21185 satDeviceData_t *satDevData; 21186 21187 tiIORequest_t *tiOrgIORequest; 21188 #ifdef TD_DEBUG_ENABLE 21189 bit32 ataStatus = 0; 21190 bit32 ataError; 21191 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 21192 #endif 21193 bit32 report = agFALSE; 21194 bit32 AbortTM = agFALSE; 21195 21196 21197 TI_DBG1(("satCheckPowerModeCB: start\n")); 21198 21199 TI_DBG1(("satCheckPowerModeCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 21200 21201 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 21202 satIOContext = (satIOContext_t *) ioContext; 21203 satIntIo = satIOContext->satIntIoContext; 21204 satDevData = satIOContext->pSatDevData; 21205 if (satIntIo == agNULL) 21206 { 21207 TI_DBG6(("satCheckPowerModeCB: External, OS generated\n")); 21208 satOrgIOContext = satIOContext; 21209 tiOrgIORequest = tdIORequestBody->tiIORequest; 21210 } 21211 else 21212 { 21213 TI_DBG6(("satCheckPowerModeCB: Internal, TD generated\n")); 21214 satOrgIOContext = satIOContext->satOrgIOContext; 21215 if (satOrgIOContext == agNULL) 21216 { 21217 TI_DBG6(("satCheckPowerModeCB: satOrgIOContext is NULL, wrong\n")); 21218 return; 21219 } 21220 else 21221 { 21222 TI_DBG6(("satCheckPowerModeCB: satOrgIOContext is NOT NULL\n")); 21223 } 21224 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 21225 tiOrgIORequest = (tiIORequest_t *)tdOrgIORequestBody->tiIORequest; 21226 } 21227 21228 21229 tdIORequestBody->ioCompleted = agTRUE; 21230 tdIORequestBody->ioStarted = agFALSE; 21231 21232 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 21233 { 21234 TI_DBG1(("satCheckPowerModeCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 21235 21236 if (satOrgIOContext->NotifyOS == agTRUE) 21237 { 21238 ostiInitiatorEvent( tiRoot, 21239 NULL, 21240 NULL, 21241 tiIntrEventTypeTaskManagement, 21242 tiTMFailed, 21243 tiOrgIORequest ); 21244 } 21245 21246 satDevData->satTmTaskTag = agNULL; 21247 21248 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 21249 21250 satFreeIntIoResource( tiRoot, 21251 satDevData, 21252 satIntIo); 21253 return; 21254 } 21255 21256 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED || 21257 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION || 21258 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK || 21259 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS || 21260 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION || 21261 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED || 21262 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION || 21263 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR || 21264 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY 21265 ) 21266 { 21267 TI_DBG1(("satCheckPowerModeCB: OSSA_IO_OPEN_CNX_ERROR\n")); 21268 21269 if (satOrgIOContext->NotifyOS == agTRUE) 21270 { 21271 ostiInitiatorEvent( tiRoot, 21272 NULL, 21273 NULL, 21274 tiIntrEventTypeTaskManagement, 21275 tiTMFailed, 21276 tiOrgIORequest ); 21277 } 21278 21279 satDevData->satTmTaskTag = agNULL; 21280 21281 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 21282 21283 satFreeIntIoResource( tiRoot, 21284 satDevData, 21285 satIntIo); 21286 return; 21287 } 21288 21289 if (agIOStatus != OSSA_IO_SUCCESS) 21290 { 21291 #ifdef TD_DEBUG_ENABLE 21292 /* only agsaFisPioSetup_t is expected */ 21293 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup); 21294 ataStatus = satPIOSetupHeader->status; /* ATA Status register */ 21295 ataError = satPIOSetupHeader->error; /* ATA Eror register */ 21296 #endif 21297 TI_DBG1(("satCheckPowerModeCB: ataStatus 0x%x ataError 0x%x\n", ataStatus, ataError)); 21298 21299 if (satOrgIOContext->NotifyOS == agTRUE) 21300 { 21301 ostiInitiatorEvent( tiRoot, 21302 NULL, 21303 NULL, 21304 tiIntrEventTypeTaskManagement, 21305 tiTMFailed, 21306 tiOrgIORequest ); 21307 } 21308 21309 satDevData->satTmTaskTag = agNULL; 21310 21311 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 21312 21313 satFreeIntIoResource( tiRoot, 21314 satDevData, 21315 satIntIo); 21316 return; 21317 } 21318 21319 /* success */ 21320 TI_DBG1(("satCheckPowerModeCB: success\n")); 21321 TI_DBG1(("satCheckPowerModeCB: TMF %d\n", satOrgIOContext->TMF)); 21322 21323 if (satOrgIOContext->TMF == AG_ABORT_TASK) 21324 { 21325 AbortTM = agTRUE; 21326 } 21327 21328 if (satOrgIOContext->NotifyOS == agTRUE) 21329 { 21330 report = agTRUE; 21331 } 21332 if (AbortTM == agTRUE) 21333 { 21334 TI_DBG1(("satCheckPowerModeCB: calling satAbort\n")); 21335 satAbort(agRoot, satOrgIOContext->satToBeAbortedIOContext); 21336 } 21337 satDevData->satTmTaskTag = agNULL; 21338 21339 satDevData->satDriveState = SAT_DEV_STATE_NORMAL; 21340 21341 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 21342 21343 TI_DBG1(("satCheckPowerModeCB: satPendingIO %d satNCQMaxIO %d\n", satDevData->satPendingIO, satDevData->satNCQMaxIO )); 21344 TI_DBG1(("satCheckPowerModeCB: satPendingNCQIO %d satPendingNONNCQIO %d\n", satDevData->satPendingNCQIO, satDevData->satPendingNONNCQIO)); 21345 21346 satFreeIntIoResource( tiRoot, 21347 satDevData, 21348 satIntIo); 21349 21350 /* clean up TD layer's IORequestBody */ 21351 if (tdOrgIORequestBody != agNULL) 21352 { 21353 ostiFreeMemory( 21354 tiRoot, 21355 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 21356 sizeof(tdIORequestBody_t) 21357 ); 21358 } 21359 else 21360 { 21361 TI_DBG1(("satCheckPowerModeCB: tdOrgIORequestBody is NULL, wrong\n")); 21362 } 21363 if (report) 21364 { 21365 ostiInitiatorEvent( tiRoot, 21366 NULL, 21367 NULL, 21368 tiIntrEventTypeTaskManagement, 21369 tiTMOK, 21370 tiOrgIORequest ); 21371 } 21372 21373 TI_DBG5(("satCheckPowerModeCB: device %p pending IO %d\n", satDevData, satDevData->satPendingIO)); 21374 TI_DBG2(("satCheckPowerModeCB: end\n")); 21375 return; 21376 21377 } 21378 21379 /*****************************************************************************/ 21380 /*! \brief SAT implementation for satAddSATAStartIDDev. 21381 * 21382 * This function sends identify device data to find out the uniqueness 21383 * of device. 21384 * 21385 * \param tiRoot: Pointer to TISA initiator driver/port instance. 21386 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 21387 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 21388 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 21389 * \param satIOContext_t: Pointer to the SAT IO Context 21390 * 21391 * \return If command is started successfully 21392 * - \e tiSuccess: I/O request successfully initiated. 21393 * - \e tiBusy: No resources available, try again later. 21394 * - \e tiIONoDevice: Invalid device handle. 21395 * - \e tiError: Other errors. 21396 */ 21397 /*****************************************************************************/ 21398 GLOBAL bit32 satAddSATAStartIDDev( 21399 tiRoot_t *tiRoot, 21400 tiIORequest_t *tiIORequest, 21401 tiDeviceHandle_t *tiDeviceHandle, 21402 tiScsiInitiatorRequest_t *tiScsiRequest, // NULL 21403 satIOContext_t *satIOContext 21404 ) 21405 { 21406 satInternalIo_t *satIntIo = agNULL; 21407 satDeviceData_t *satDevData = agNULL; 21408 tdIORequestBody_t *tdIORequestBody; 21409 satIOContext_t *satNewIOContext; 21410 bit32 status; 21411 21412 TI_DBG2(("satAddSATAStartIDDev: start\n")); 21413 21414 satDevData = satIOContext->pSatDevData; 21415 21416 TI_DBG2(("satAddSATAStartIDDev: before alloc\n")); 21417 21418 /* allocate identify device command */ 21419 satIntIo = satAllocIntIoResource( tiRoot, 21420 tiIORequest, 21421 satDevData, 21422 sizeof(agsaSATAIdentifyData_t), /* 512; size of identify device data */ 21423 satIntIo); 21424 21425 TI_DBG2(("satAddSATAStartIDDev: after alloc\n")); 21426 21427 if (satIntIo == agNULL) 21428 { 21429 TI_DBG1(("satAddSATAStartIDDev: can't alloacate\n")); 21430 21431 return tiError; 21432 } 21433 21434 /* fill in fields */ 21435 /* real ttttttthe one worked and the same; 5/21/07/ */ 21436 satIntIo->satOrgTiIORequest = tiIORequest; /* changed */ 21437 tdIORequestBody = satIntIo->satIntRequestBody; 21438 satNewIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 21439 21440 satNewIOContext->pSatDevData = satDevData; 21441 satNewIOContext->pFis = &(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 21442 satNewIOContext->pScsiCmnd = &(satIntIo->satIntTiScsiXchg.scsiCmnd); 21443 satNewIOContext->pSense = &(tdIORequestBody->transport.SATA.sensePayload); 21444 satNewIOContext->pTiSenseData = &(tdIORequestBody->transport.SATA.tiSenseData); 21445 satNewIOContext->tiRequestBody = satIntIo->satIntRequestBody; /* key fix */ 21446 satNewIOContext->interruptContext = tiInterruptContext; 21447 satNewIOContext->satIntIoContext = satIntIo; 21448 21449 satNewIOContext->ptiDeviceHandle = agNULL; 21450 satNewIOContext->satOrgIOContext = satIOContext; /* changed */ 21451 21452 /* this is valid only for TD layer generated (not triggered by OS at all) IO */ 21453 satNewIOContext->tiScsiXchg = &(satIntIo->satIntTiScsiXchg); 21454 21455 21456 TI_DBG6(("satAddSATAStartIDDev: OS satIOContext %p \n", satIOContext)); 21457 TI_DBG6(("satAddSATAStartIDDev: TD satNewIOContext %p \n", satNewIOContext)); 21458 TI_DBG6(("satAddSATAStartIDDev: OS tiScsiXchg %p \n", satIOContext->tiScsiXchg)); 21459 TI_DBG6(("satAddSATAStartIDDev: TD tiScsiXchg %p \n", satNewIOContext->tiScsiXchg)); 21460 21461 21462 21463 TI_DBG2(("satAddSATAStartIDDev: satNewIOContext %p tdIORequestBody %p\n", satNewIOContext, tdIORequestBody)); 21464 21465 status = satAddSATASendIDDev( tiRoot, 21466 &satIntIo->satIntTiIORequest, /* New tiIORequest */ 21467 tiDeviceHandle, 21468 satNewIOContext->tiScsiXchg, /* New tiScsiInitiatorRequest_t *tiScsiRequest, */ 21469 satNewIOContext); 21470 21471 if (status != tiSuccess) 21472 { 21473 TI_DBG1(("satAddSATAStartIDDev: failed in sending\n")); 21474 21475 satFreeIntIoResource( tiRoot, 21476 satDevData, 21477 satIntIo); 21478 21479 return tiError; 21480 } 21481 21482 21483 TI_DBG6(("satAddSATAStartIDDev: end\n")); 21484 21485 return status; 21486 21487 21488 } 21489 21490 /*****************************************************************************/ 21491 /*! \brief SAT implementation for satAddSATASendIDDev. 21492 * 21493 * This function creates identify device data fis and send it to LL 21494 * 21495 * \param tiRoot: Pointer to TISA initiator driver/port instance. 21496 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 21497 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 21498 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 21499 * \param satIOContext_t: Pointer to the SAT IO Context 21500 * 21501 * \return If command is started successfully 21502 * - \e tiSuccess: I/O request successfully initiated. 21503 * - \e tiBusy: No resources available, try again later. 21504 * - \e tiIONoDevice: Invalid device handle. 21505 * - \e tiError: Other errors. 21506 */ 21507 /*****************************************************************************/ 21508 GLOBAL bit32 satAddSATASendIDDev( 21509 tiRoot_t *tiRoot, 21510 tiIORequest_t *tiIORequest, 21511 tiDeviceHandle_t *tiDeviceHandle, 21512 tiScsiInitiatorRequest_t *tiScsiRequest, 21513 satIOContext_t *satIOContext) 21514 { 21515 bit32 status; 21516 bit32 agRequestType; 21517 satDeviceData_t *pSatDevData; 21518 agsaFisRegHostToDevice_t *fis; 21519 #ifdef TD_DEBUG_ENABLE 21520 tdIORequestBody_t *tdIORequestBody; 21521 satInternalIo_t *satIntIoContext; 21522 #endif 21523 21524 pSatDevData = satIOContext->pSatDevData; 21525 fis = satIOContext->pFis; 21526 TI_DBG2(("satAddSATASendIDDev: start\n")); 21527 #ifdef TD_DEBUG_ENABLE 21528 satIntIoContext = satIOContext->satIntIoContext; 21529 tdIORequestBody = satIntIoContext->satIntRequestBody; 21530 #endif 21531 TI_DBG5(("satAddSATASendIDDev: satIOContext %p tdIORequestBody %p\n", satIOContext, tdIORequestBody)); 21532 21533 fis->h.fisType = 0x27; /* Reg host to device */ 21534 fis->h.c_pmPort = 0x80; /* C Bit is set */ 21535 if (pSatDevData->satDeviceType == SATA_ATAPI_DEVICE) 21536 fis->h.command = SAT_IDENTIFY_PACKET_DEVICE; /* 0x40 */ 21537 else 21538 fis->h.command = SAT_IDENTIFY_DEVICE; /* 0xEC */ 21539 fis->h.features = 0; /* FIS reserve */ 21540 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 21541 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 21542 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 21543 fis->d.device = 0; /* FIS LBA mode */ 21544 fis->d.lbaLowExp = 0; 21545 fis->d.lbaMidExp = 0; 21546 fis->d.lbaHighExp = 0; 21547 fis->d.featuresExp = 0; 21548 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 21549 fis->d.sectorCountExp = 0; 21550 fis->d.reserved4 = 0; 21551 fis->d.control = 0; /* FIS HOB bit clear */ 21552 fis->d.reserved5 = 0; 21553 21554 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 21555 21556 /* Initialize CB for SATA completion. 21557 */ 21558 satIOContext->satCompleteCB = &satAddSATAIDDevCB; 21559 21560 /* 21561 * Prepare SGL and send FIS to LL layer. 21562 */ 21563 satIOContext->reqType = agRequestType; /* Save it */ 21564 21565 #ifdef TD_INTERNAL_DEBUG 21566 tdhexdump("satAddSATASendIDDev", (bit8 *)satIOContext->pFis, sizeof(agsaFisRegHostToDevice_t)); 21567 #ifdef TD_DEBUG_ENABLE 21568 tdhexdump("satAddSATASendIDDev LL", (bit8 *)&(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev), sizeof(agsaFisRegHostToDevice_t)); 21569 #endif 21570 #endif 21571 21572 status = sataLLIOStart( tiRoot, 21573 tiIORequest, 21574 tiDeviceHandle, 21575 tiScsiRequest, 21576 satIOContext); 21577 21578 TI_DBG2(("satAddSATASendIDDev: end status %d\n", status)); 21579 return status; 21580 } 21581 21582 /***************************************************************************** 21583 *! \brief satAddSATAIDDevCB 21584 * 21585 * This routine is a callback function for satAddSATASendIDDev() 21586 * Using Identify Device Data, this function finds whether devicedata is 21587 * new or old. If new, add it to the devicelist. 21588 * 21589 * \param agRoot: Handles for this instance of SAS/SATA hardware 21590 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 21591 * \param agIOStatus: Status of completed I/O. 21592 * \param agFirstDword:Pointer to the four bytes of FIS. 21593 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 21594 * length. 21595 * \param agParam: Additional info based on status. 21596 * \param ioContext: Pointer to satIOContext_t. 21597 * 21598 * \return: none 21599 * 21600 *****************************************************************************/ 21601 void satAddSATAIDDevCB( 21602 agsaRoot_t *agRoot, 21603 agsaIORequest_t *agIORequest, 21604 bit32 agIOStatus, 21605 agsaFisHeader_t *agFirstDword, 21606 bit32 agIOInfoLen, 21607 void *agParam, 21608 void *ioContext 21609 ) 21610 { 21611 21612 /* 21613 In the process of Inquiry 21614 Process SAT_IDENTIFY_DEVICE 21615 */ 21616 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 21617 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 21618 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 21619 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 21620 tdIORequestBody_t *tdIORequestBody; 21621 tdIORequestBody_t *tdOrgIORequestBody; 21622 satIOContext_t *satIOContext; 21623 satIOContext_t *satOrgIOContext; 21624 satIOContext_t *satNewIOContext; 21625 satInternalIo_t *satIntIo; 21626 satInternalIo_t *satNewIntIo = agNULL; 21627 satDeviceData_t *satDevData; 21628 tiIORequest_t *tiOrgIORequest = agNULL; 21629 agsaSATAIdentifyData_t *pSATAIdData; 21630 bit16 *tmpptr, tmpptr_tmp; 21631 bit32 x; 21632 tdsaDeviceData_t *NewOneDeviceData = agNULL; 21633 tdsaDeviceData_t *oneDeviceData = agNULL; 21634 tdList_t *DeviceListList; 21635 int new_device = agTRUE; 21636 bit8 PhyID; 21637 void *sglVirtualAddr; 21638 bit32 retry_status; 21639 agsaContext_t *agContext; 21640 tdsaPortContext_t *onePortContext; 21641 bit32 status = 0; 21642 21643 TI_DBG2(("satAddSATAIDDevCB: start\n")); 21644 TI_DBG6(("satAddSATAIDDevCB: agIORequest=%p agIOStatus=0x%x agIOInfoLen %d\n", agIORequest, agIOStatus, agIOInfoLen)); 21645 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 21646 satIOContext = (satIOContext_t *) ioContext; 21647 satIntIo = satIOContext->satIntIoContext; 21648 satDevData = satIOContext->pSatDevData; 21649 21650 NewOneDeviceData = (tdsaDeviceData_t *)tdIORequestBody->tiDevHandle->tdData; 21651 TI_DBG2(("satAddSATAIDDevCB: NewOneDeviceData %p did %d\n", NewOneDeviceData, NewOneDeviceData->id)); 21652 PhyID = NewOneDeviceData->phyID; 21653 TI_DBG2(("satAddSATAIDDevCB: phyID %d\n", PhyID)); 21654 agContext = &(NewOneDeviceData->agDeviceResetContext); 21655 agContext->osData = agNULL; 21656 if (satIntIo == agNULL) 21657 { 21658 TI_DBG1(("satAddSATAIDDevCB: External, OS generated\n")); 21659 TI_DBG1(("satAddSATAIDDevCB: Not possible case\n")); 21660 satOrgIOContext = satIOContext; 21661 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 21662 tdsaAbortAll(tiRoot, agRoot, NewOneDeviceData); 21663 21664 /* put onedevicedata back to free list */ 21665 osti_memset(&(NewOneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t)); 21666 TDLIST_DEQUEUE_THIS(&(NewOneDeviceData->MainLink)); 21667 TDLIST_ENQUEUE_AT_TAIL(&(NewOneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList)); 21668 21669 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 21670 21671 satFreeIntIoResource( tiRoot, 21672 satDevData, 21673 satIntIo); 21674 /* clean up TD layer's IORequestBody */ 21675 ostiFreeMemory( 21676 tiRoot, 21677 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 21678 sizeof(tdIORequestBody_t) 21679 ); 21680 21681 /* notifying link up */ 21682 ostiPortEvent ( 21683 tiRoot, 21684 tiPortLinkUp, 21685 tiSuccess, 21686 (void *)tdsaAllShared->Ports[PhyID].tiPortalContext 21687 ); 21688 #ifdef INITIATOR_DRIVER 21689 /* triggers discovery */ 21690 ostiPortEvent( 21691 tiRoot, 21692 tiPortDiscoveryReady, 21693 tiSuccess, 21694 (void *) tdsaAllShared->Ports[PhyID].tiPortalContext 21695 ); 21696 #endif 21697 return; 21698 } 21699 else 21700 { 21701 TI_DBG1(("satAddSATAIDDevCB: Internal, TD generated\n")); 21702 satOrgIOContext = satIOContext->satOrgIOContext; 21703 if (satOrgIOContext == agNULL) 21704 { 21705 TI_DBG6(("satAddSATAIDDevCB: satOrgIOContext is NULL\n")); 21706 return; 21707 } 21708 else 21709 { 21710 TI_DBG6(("satAddSATAIDDevCB: satOrgIOContext is NOT NULL\n")); 21711 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 21712 sglVirtualAddr = satIntIo->satIntTiScsiXchg.sglVirtualAddr; 21713 } 21714 } 21715 tiOrgIORequest = tdIORequestBody->tiIORequest; 21716 21717 tdIORequestBody->ioCompleted = agTRUE; 21718 tdIORequestBody->ioStarted = agFALSE; 21719 TI_DBG2(("satAddSATAIDDevCB: satOrgIOContext->pid %d\n", satOrgIOContext->pid)); 21720 /* protect against double completion for old port */ 21721 if (satOrgIOContext->pid != tdsaAllShared->Ports[PhyID].portContext->id) 21722 { 21723 TI_DBG2(("satAddSATAIDDevCB: incorrect pid\n")); 21724 TI_DBG2(("satAddSATAIDDevCB: satOrgIOContext->pid %d\n", satOrgIOContext->pid)); 21725 TI_DBG2(("satAddSATAIDDevCB: tiPortalContext pid %d\n", tdsaAllShared->Ports[PhyID].portContext->id)); 21726 tdsaAbortAll(tiRoot, agRoot, NewOneDeviceData); 21727 /* put onedevicedata back to free list */ 21728 osti_memset(&(NewOneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t)); 21729 TDLIST_DEQUEUE_THIS(&(NewOneDeviceData->MainLink)); 21730 TDLIST_ENQUEUE_AT_TAIL(&(NewOneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList)); 21731 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 21732 21733 satFreeIntIoResource( tiRoot, 21734 satDevData, 21735 satIntIo); 21736 /* clean up TD layer's IORequestBody */ 21737 ostiFreeMemory( 21738 tiRoot, 21739 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 21740 sizeof(tdIORequestBody_t) 21741 ); 21742 /* no notification to OS layer */ 21743 return; 21744 } 21745 /* completion after portcontext is invalidated */ 21746 onePortContext = NewOneDeviceData->tdPortContext; 21747 if (onePortContext != agNULL) 21748 { 21749 if (onePortContext->valid == agFALSE) 21750 { 21751 TI_DBG1(("satAddSATAIDDevCB: portcontext is invalid\n")); 21752 TI_DBG1(("satAddSATAIDDevCB: onePortContext->id pid %d\n", onePortContext->id)); 21753 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 21754 21755 satFreeIntIoResource( tiRoot, 21756 satDevData, 21757 satIntIo); 21758 /* clean up TD layer's IORequestBody */ 21759 ostiFreeMemory( 21760 tiRoot, 21761 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 21762 sizeof(tdIORequestBody_t) 21763 ); 21764 /* no notification to OS layer */ 21765 return; 21766 } 21767 } 21768 else 21769 { 21770 TI_DBG1(("satAddSATAIDDevCB: onePortContext is NULL!!!\n")); 21771 return; 21772 } 21773 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 21774 { 21775 TI_DBG1(("satAddSATAIDDevCB: wrong. agFirstDword is NULL when error, status %d\n", agIOStatus)); 21776 if (tdsaAllShared->ResetInDiscovery != 0 && satDevData->ID_Retries < SATA_ID_DEVICE_DATA_RETRIES) 21777 { 21778 satDevData->satPendingNONNCQIO--; 21779 satDevData->satPendingIO--; 21780 retry_status = sataLLIOStart(tiRoot, 21781 &satIntIo->satIntTiIORequest, 21782 &(NewOneDeviceData->tiDeviceHandle), 21783 satIOContext->tiScsiXchg, 21784 satIOContext); 21785 if (retry_status != tiSuccess) 21786 { 21787 /* simply give up */ 21788 satDevData->ID_Retries = 0; 21789 satAddSATAIDDevCBCleanup(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21790 return; 21791 } 21792 satDevData->ID_Retries++; 21793 tdIORequestBody->ioCompleted = agFALSE; 21794 tdIORequestBody->ioStarted = agTRUE; 21795 return; 21796 } 21797 else 21798 { 21799 if (tdsaAllShared->ResetInDiscovery == 0) 21800 { 21801 satAddSATAIDDevCBCleanup(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21802 } 21803 else /* ResetInDiscovery in on */ 21804 { 21805 /* RESET only one after ID retries */ 21806 if (satDevData->NumOfIDRetries <= 0) 21807 { 21808 satDevData->NumOfIDRetries++; 21809 satDevData->ID_Retries = 0; 21810 satAddSATAIDDevCBReset(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21811 /* send link reset */ 21812 saLocalPhyControl(agRoot, 21813 agContext, 21814 tdsaRotateQnumber(tiRoot, NewOneDeviceData), 21815 PhyID, 21816 AGSA_PHY_HARD_RESET, 21817 agNULL); 21818 } 21819 else 21820 { 21821 satDevData->ID_Retries = 0; 21822 satAddSATAIDDevCBCleanup(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21823 } 21824 } 21825 return; 21826 } 21827 } 21828 if (agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED || 21829 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION || 21830 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK || 21831 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS || 21832 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION || 21833 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED || 21834 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION || 21835 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_UNKNOWN_ERROR || 21836 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY 21837 ) 21838 { 21839 TI_DBG1(("satAddSATAIDDevCB: OSSA_IO_OPEN_CNX_ERROR\n")); 21840 if (tdsaAllShared->ResetInDiscovery != 0 && satDevData->ID_Retries < SATA_ID_DEVICE_DATA_RETRIES) 21841 { 21842 satDevData->satPendingNONNCQIO--; 21843 satDevData->satPendingIO--; 21844 retry_status = sataLLIOStart(tiRoot, 21845 &satIntIo->satIntTiIORequest, 21846 &(NewOneDeviceData->tiDeviceHandle), 21847 satIOContext->tiScsiXchg, 21848 satIOContext); 21849 if (retry_status != tiSuccess) 21850 { 21851 /* simply give up */ 21852 satDevData->ID_Retries = 0; 21853 satAddSATAIDDevCBCleanup(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21854 return; 21855 } 21856 satDevData->ID_Retries++; 21857 tdIORequestBody->ioCompleted = agFALSE; 21858 tdIORequestBody->ioStarted = agTRUE; 21859 return; 21860 } 21861 else 21862 { 21863 if (tdsaAllShared->ResetInDiscovery == 0) 21864 { 21865 satAddSATAIDDevCBCleanup(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21866 } 21867 else /* ResetInDiscovery in on */ 21868 { 21869 /* RESET only one after ID retries */ 21870 if (satDevData->NumOfIDRetries <= 0) 21871 { 21872 satDevData->NumOfIDRetries++; 21873 satDevData->ID_Retries = 0; 21874 satAddSATAIDDevCBReset(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21875 /* send link reset */ 21876 saLocalPhyControl(agRoot, 21877 agContext, 21878 tdsaRotateQnumber(tiRoot, NewOneDeviceData), 21879 PhyID, 21880 AGSA_PHY_HARD_RESET, 21881 agNULL); 21882 } 21883 else 21884 { 21885 satDevData->ID_Retries = 0; 21886 satAddSATAIDDevCBCleanup(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21887 } 21888 } 21889 return; 21890 } 21891 } 21892 21893 if ( agIOStatus != OSSA_IO_SUCCESS || 21894 (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL && agIOInfoLen != 0) 21895 ) 21896 { 21897 if (tdsaAllShared->ResetInDiscovery != 0 && satDevData->ID_Retries < SATA_ID_DEVICE_DATA_RETRIES) 21898 { 21899 satIOContext->pSatDevData->satPendingNONNCQIO--; 21900 satIOContext->pSatDevData->satPendingIO--; 21901 retry_status = sataLLIOStart(tiRoot, 21902 &satIntIo->satIntTiIORequest, 21903 &(NewOneDeviceData->tiDeviceHandle), 21904 satIOContext->tiScsiXchg, 21905 satIOContext); 21906 if (retry_status != tiSuccess) 21907 { 21908 /* simply give up */ 21909 satDevData->ID_Retries = 0; 21910 satAddSATAIDDevCBCleanup(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21911 return; 21912 } 21913 satDevData->ID_Retries++; 21914 tdIORequestBody->ioCompleted = agFALSE; 21915 tdIORequestBody->ioStarted = agTRUE; 21916 return; 21917 } 21918 else 21919 { 21920 if (tdsaAllShared->ResetInDiscovery == 0) 21921 { 21922 satAddSATAIDDevCBCleanup(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21923 } 21924 else /* ResetInDiscovery in on */ 21925 { 21926 /* RESET only one after ID retries */ 21927 if (satDevData->NumOfIDRetries <= 0) 21928 { 21929 satDevData->NumOfIDRetries++; 21930 satDevData->ID_Retries = 0; 21931 satAddSATAIDDevCBReset(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21932 /* send link reset */ 21933 saLocalPhyControl(agRoot, 21934 agContext, 21935 tdsaRotateQnumber(tiRoot, NewOneDeviceData), 21936 PhyID, 21937 AGSA_PHY_HARD_RESET, 21938 agNULL); 21939 } 21940 else 21941 { 21942 satDevData->ID_Retries = 0; 21943 satAddSATAIDDevCBCleanup(agRoot, NewOneDeviceData, satIOContext, tdOrgIORequestBody); 21944 } 21945 } 21946 return; 21947 } 21948 } 21949 21950 /* success */ 21951 TI_DBG2(("satAddSATAIDDevCB: Success\n")); 21952 /* Convert to host endian */ 21953 tmpptr = (bit16*)sglVirtualAddr; 21954 //tdhexdump("satAddSATAIDDevCB before", (bit8 *)sglVirtualAddr, sizeof(agsaSATAIdentifyData_t)); 21955 for (x=0; x < sizeof(agsaSATAIdentifyData_t)/sizeof(bit16); x++) 21956 { 21957 OSSA_READ_LE_16(AGROOT, &tmpptr_tmp, tmpptr, 0); 21958 *tmpptr = tmpptr_tmp; 21959 tmpptr++; 21960 /*Print tmpptr_tmp here for debugging purpose*/ 21961 } 21962 21963 pSATAIdData = (agsaSATAIdentifyData_t *)sglVirtualAddr; 21964 //tdhexdump("satAddSATAIDDevCB after", (bit8 *)pSATAIdData, sizeof(agsaSATAIdentifyData_t)); 21965 21966 TI_DBG5(("satAddSATAIDDevCB: OS satOrgIOContext %p \n", satOrgIOContext)); 21967 TI_DBG5(("satAddSATAIDDevCB: TD satIOContext %p \n", satIOContext)); 21968 TI_DBG5(("satAddSATAIDDevCB: OS tiScsiXchg %p \n", satOrgIOContext->tiScsiXchg)); 21969 TI_DBG5(("satAddSATAIDDevCB: TD tiScsiXchg %p \n", satIOContext->tiScsiXchg)); 21970 21971 21972 /* compare idenitfy device data to the exiting list */ 21973 DeviceListList = tdsaAllShared->MainDeviceList.flink; 21974 while (DeviceListList != &(tdsaAllShared->MainDeviceList)) 21975 { 21976 oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList); 21977 TI_DBG1(("satAddSATAIDDevCB: LOOP oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id)); 21978 //tdhexdump("satAddSATAIDDevCB LOOP", (bit8 *)&oneDeviceData->satDevData.satIdentifyData, sizeof(agsaSATAIdentifyData_t)); 21979 21980 /* what is unique ID for sata device -> response of identify devicedata; not really 21981 Let's compare serial number, firmware version, model number 21982 */ 21983 if ( oneDeviceData->DeviceType == TD_SATA_DEVICE && 21984 (osti_memcmp (oneDeviceData->satDevData.satIdentifyData.serialNumber, 21985 pSATAIdData->serialNumber, 21986 20) == 0) && 21987 (osti_memcmp (oneDeviceData->satDevData.satIdentifyData.firmwareVersion, 21988 pSATAIdData->firmwareVersion, 21989 8) == 0) && 21990 (osti_memcmp (oneDeviceData->satDevData.satIdentifyData.modelNumber, 21991 pSATAIdData->modelNumber, 21992 40) == 0) 21993 ) 21994 { 21995 TI_DBG2(("satAddSATAIDDevCB: did %d\n", oneDeviceData->id)); 21996 new_device = agFALSE; 21997 break; 21998 } 21999 DeviceListList = DeviceListList->flink; 22000 } 22001 22002 if (new_device == agFALSE) 22003 { 22004 TI_DBG2(("satAddSATAIDDevCB: old device data\n")); 22005 oneDeviceData->valid = agTRUE; 22006 oneDeviceData->valid2 = agTRUE; 22007 /* save data field from new device data */ 22008 oneDeviceData->agRoot = agRoot; 22009 oneDeviceData->agDevHandle = NewOneDeviceData->agDevHandle; 22010 oneDeviceData->agDevHandle->osData = oneDeviceData; /* TD layer */ 22011 oneDeviceData->tdPortContext = NewOneDeviceData->tdPortContext; 22012 oneDeviceData->phyID = NewOneDeviceData->phyID; 22013 22014 /* 22015 one SATA directly attached device per phy; 22016 Therefore, deregister then register 22017 */ 22018 saDeregisterDeviceHandle(agRoot, agNULL, NewOneDeviceData->agDevHandle, 0); 22019 22020 if (oneDeviceData->registered == agFALSE) 22021 { 22022 TI_DBG2(("satAddSATAIDDevCB: re-registering old device data\n")); 22023 /* already has old information; just register it again */ 22024 saRegisterNewDevice( /* satAddSATAIDDevCB */ 22025 agRoot, 22026 &oneDeviceData->agContext, 22027 tdsaRotateQnumber(tiRoot, oneDeviceData), 22028 &oneDeviceData->agDeviceInfo, 22029 oneDeviceData->tdPortContext->agPortContext, 22030 0 22031 ); 22032 } 22033 22034 // tdsaAbortAll(tiRoot, agRoot, NewOneDeviceData); 22035 /* put onedevicedata back to free list */ 22036 osti_memset(&(NewOneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t)); 22037 TDLIST_DEQUEUE_THIS(&(NewOneDeviceData->MainLink)); 22038 TDLIST_ENQUEUE_AT_TAIL(&(NewOneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList)); 22039 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22040 22041 satFreeIntIoResource( tiRoot, 22042 satDevData, 22043 satIntIo); 22044 22045 if (satDevData->satDeviceType == SATA_ATAPI_DEVICE) 22046 { 22047 /* send the Set Feature ATA command to ATAPI device for enbling PIO and DMA transfer mode*/ 22048 satNewIntIo = satAllocIntIoResource( tiRoot, 22049 tiOrgIORequest, 22050 satDevData, 22051 0, 22052 satNewIntIo); 22053 22054 if (satNewIntIo == agNULL) 22055 { 22056 TI_DBG1(("tdsaDiscoveryStartIDDevCB: momory allocation fails\n")); 22057 /* clean up TD layer's IORequestBody */ 22058 ostiFreeMemory( 22059 tiRoot, 22060 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22061 sizeof(tdIORequestBody_t) 22062 ); 22063 return; 22064 } /* end memory allocation */ 22065 22066 satNewIOContext = satPrepareNewIO(satNewIntIo, 22067 tiOrgIORequest, 22068 satDevData, 22069 agNULL, 22070 satOrgIOContext 22071 ); 22072 /* enable PIO mode, then enable Ultra DMA mode in the satSetFeaturesCB callback function*/ 22073 status = satSetFeatures(tiRoot, 22074 &satNewIntIo->satIntTiIORequest, 22075 satNewIOContext->ptiDeviceHandle, 22076 &satNewIntIo->satIntTiScsiXchg, /* orginal from OS layer */ 22077 satNewIOContext, 22078 agFALSE); 22079 if (status != tiSuccess) 22080 { 22081 satFreeIntIoResource( tiRoot, 22082 satDevData, 22083 satIntIo); 22084 /* clean up TD layer's IORequestBody */ 22085 ostiFreeMemory( 22086 tiRoot, 22087 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22088 sizeof(tdIORequestBody_t) 22089 ); 22090 } 22091 } 22092 else 22093 { 22094 /* clean up TD layer's IORequestBody */ 22095 ostiFreeMemory( 22096 tiRoot, 22097 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22098 sizeof(tdIORequestBody_t) 22099 ); 22100 TI_DBG2(("satAddSATAIDDevCB: pid %d\n", tdsaAllShared->Ports[PhyID].portContext->id)); 22101 /* notifying link up */ 22102 ostiPortEvent( 22103 tiRoot, 22104 tiPortLinkUp, 22105 tiSuccess, 22106 (void *)tdsaAllShared->Ports[PhyID].tiPortalContext 22107 ); 22108 22109 22110 #ifdef INITIATOR_DRIVER 22111 /* triggers discovery */ 22112 ostiPortEvent( 22113 tiRoot, 22114 tiPortDiscoveryReady, 22115 tiSuccess, 22116 (void *) tdsaAllShared->Ports[PhyID].tiPortalContext 22117 ); 22118 #endif 22119 } 22120 return; 22121 } 22122 22123 TI_DBG2(("satAddSATAIDDevCB: new device data\n")); 22124 /* copy ID Dev data to satDevData */ 22125 satDevData->satIdentifyData = *pSATAIdData; 22126 22127 22128 satDevData->IDDeviceValid = agTRUE; 22129 #ifdef TD_INTERNAL_DEBUG 22130 tdhexdump("satAddSATAIDDevCB ID Dev data",(bit8 *)pSATAIdData, sizeof(agsaSATAIdentifyData_t)); 22131 tdhexdump("satAddSATAIDDevCB Device ID Dev data",(bit8 *)&satDevData->satIdentifyData, sizeof(agsaSATAIdentifyData_t)); 22132 #endif 22133 22134 /* set satDevData fields from IndentifyData */ 22135 satSetDevInfo(satDevData,pSATAIdData); 22136 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22137 22138 satFreeIntIoResource( tiRoot, 22139 satDevData, 22140 satIntIo); 22141 22142 if (satDevData->satDeviceType == SATA_ATAPI_DEVICE) 22143 { 22144 /* send the Set Feature ATA command to ATAPI device for enbling PIO and DMA transfer mode*/ 22145 satNewIntIo = satAllocIntIoResource( tiRoot, 22146 tiOrgIORequest, 22147 satDevData, 22148 0, 22149 satNewIntIo); 22150 22151 if (satNewIntIo == agNULL) 22152 { 22153 TI_DBG1(("tdsaDiscoveryStartIDDevCB: momory allocation fails\n")); 22154 /* clean up TD layer's IORequestBody */ 22155 ostiFreeMemory( 22156 tiRoot, 22157 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22158 sizeof(tdIORequestBody_t) 22159 ); 22160 return; 22161 } /* end memory allocation */ 22162 22163 satNewIOContext = satPrepareNewIO(satNewIntIo, 22164 tiOrgIORequest, 22165 satDevData, 22166 agNULL, 22167 satOrgIOContext 22168 ); 22169 /* enable PIO mode, then enable Ultra DMA mode in the satSetFeaturesCB callback function*/ 22170 status = satSetFeatures(tiRoot, 22171 &satNewIntIo->satIntTiIORequest, 22172 satNewIOContext->ptiDeviceHandle, 22173 &satNewIntIo->satIntTiScsiXchg, /* orginal from OS layer */ 22174 satNewIOContext, 22175 agFALSE); 22176 if (status != tiSuccess) 22177 { 22178 satFreeIntIoResource( tiRoot, 22179 satDevData, 22180 satIntIo); 22181 /* clean up TD layer's IORequestBody */ 22182 ostiFreeMemory( 22183 tiRoot, 22184 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22185 sizeof(tdIORequestBody_t) 22186 ); 22187 } 22188 22189 } 22190 else 22191 { 22192 /* clean up TD layer's IORequestBody */ 22193 ostiFreeMemory( 22194 tiRoot, 22195 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22196 sizeof(tdIORequestBody_t) 22197 ); 22198 22199 TI_DBG2(("satAddSATAIDDevCB: pid %d\n", tdsaAllShared->Ports[PhyID].portContext->id)); 22200 /* notifying link up */ 22201 ostiPortEvent ( 22202 tiRoot, 22203 tiPortLinkUp, 22204 tiSuccess, 22205 (void *)tdsaAllShared->Ports[PhyID].tiPortalContext 22206 ); 22207 #ifdef INITIATOR_DRIVER 22208 /* triggers discovery */ 22209 ostiPortEvent( 22210 tiRoot, 22211 tiPortDiscoveryReady, 22212 tiSuccess, 22213 (void *) tdsaAllShared->Ports[PhyID].tiPortalContext 22214 ); 22215 #endif 22216 } 22217 22218 TI_DBG2(("satAddSATAIDDevCB: end\n")); 22219 return; 22220 22221 } 22222 22223 /***************************************************************************** 22224 *! \brief satAddSATAIDDevCBReset 22225 * 22226 * This routine cleans up IOs for failed Identify device data 22227 * 22228 * \param agRoot: Handles for this instance of SAS/SATA hardware 22229 * \param oneDeviceData: Pointer to the device data. 22230 * \param ioContext: Pointer to satIOContext_t. 22231 * \param tdIORequestBody: Pointer to the request body 22232 * \param flag: Decrement pending io or not 22233 * 22234 * \return: none 22235 * 22236 *****************************************************************************/ 22237 void satAddSATAIDDevCBReset( 22238 agsaRoot_t *agRoot, 22239 tdsaDeviceData_t *oneDeviceData, 22240 satIOContext_t *satIOContext, 22241 tdIORequestBody_t *tdIORequestBody 22242 ) 22243 { 22244 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 22245 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 22246 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 22247 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 22248 satInternalIo_t *satIntIo; 22249 satDeviceData_t *satDevData; 22250 22251 TI_DBG2(("satAddSATAIDDevCBReset: start\n")); 22252 satIntIo = satIOContext->satIntIoContext; 22253 satDevData = satIOContext->pSatDevData; 22254 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22255 22256 satFreeIntIoResource( tiRoot, 22257 satDevData, 22258 satIntIo); 22259 /* clean up TD layer's IORequestBody */ 22260 ostiFreeMemory( 22261 tiRoot, 22262 tdIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22263 sizeof(tdIORequestBody_t) 22264 ); 22265 return; 22266 } 22267 22268 22269 /***************************************************************************** 22270 *! \brief satAddSATAIDDevCBCleanup 22271 * 22272 * This routine cleans up IOs for failed Identify device data 22273 * 22274 * \param agRoot: Handles for this instance of SAS/SATA hardware 22275 * \param oneDeviceData: Pointer to the device data. 22276 * \param ioContext: Pointer to satIOContext_t. 22277 * \param tdIORequestBody: Pointer to the request body 22278 * 22279 * \return: none 22280 * 22281 *****************************************************************************/ 22282 void satAddSATAIDDevCBCleanup( 22283 agsaRoot_t *agRoot, 22284 tdsaDeviceData_t *oneDeviceData, 22285 satIOContext_t *satIOContext, 22286 tdIORequestBody_t *tdIORequestBody 22287 ) 22288 { 22289 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 22290 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 22291 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 22292 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 22293 satInternalIo_t *satIntIo; 22294 satDeviceData_t *satDevData; 22295 bit8 PhyID; 22296 22297 TI_DBG2(("satAddSATAIDDevCBCleanup: start\n")); 22298 satIntIo = satIOContext->satIntIoContext; 22299 satDevData = satIOContext->pSatDevData; 22300 PhyID = oneDeviceData->phyID; 22301 tdsaAbortAll(tiRoot, agRoot, oneDeviceData); 22302 /* put onedevicedata back to free list */ 22303 osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t)); 22304 TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink)); 22305 TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList)); 22306 22307 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22308 22309 22310 satFreeIntIoResource( tiRoot, 22311 satDevData, 22312 satIntIo); 22313 22314 /* clean up TD layer's IORequestBody */ 22315 ostiFreeMemory( 22316 tiRoot, 22317 tdIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22318 sizeof(tdIORequestBody_t) 22319 ); 22320 22321 /* notifying link up */ 22322 ostiPortEvent ( 22323 tiRoot, 22324 tiPortLinkUp, 22325 tiSuccess, 22326 (void *)tdsaAllShared->Ports[PhyID].tiPortalContext 22327 ); 22328 #ifdef INITIATOR_DRIVER 22329 /* triggers discovery */ 22330 ostiPortEvent( 22331 tiRoot, 22332 tiPortDiscoveryReady, 22333 tiSuccess, 22334 (void *) tdsaAllShared->Ports[PhyID].tiPortalContext 22335 ); 22336 #endif 22337 22338 return; 22339 } 22340 22341 /*****************************************************************************/ 22342 /*! \brief SAT implementation for tdsaDiscoveryStartIDDev. 22343 * 22344 * This function sends identify device data to SATA device in discovery 22345 * 22346 * 22347 * \param tiRoot: Pointer to TISA initiator driver/port instance. 22348 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 22349 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 22350 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 22351 * \param oneDeviceData : Pointer to the device data. 22352 * 22353 * \return If command is started successfully 22354 * - \e tiSuccess: I/O request successfully initiated. 22355 * - \e tiBusy: No resources available, try again later. 22356 * - \e tiIONoDevice: Invalid device handle. 22357 * - \e tiError: Other errors. 22358 */ 22359 /*****************************************************************************/ 22360 GLOBAL bit32 22361 tdsaDiscoveryStartIDDev(tiRoot_t *tiRoot, 22362 tiIORequest_t *tiIORequest, /* agNULL */ 22363 tiDeviceHandle_t *tiDeviceHandle, 22364 tiScsiInitiatorRequest_t *tiScsiRequest, /* agNULL */ 22365 tdsaDeviceData_t *oneDeviceData 22366 ) 22367 { 22368 void *osMemHandle; 22369 tdIORequestBody_t *tdIORequestBody; 22370 bit32 PhysUpper32; 22371 bit32 PhysLower32; 22372 bit32 memAllocStatus; 22373 agsaIORequest_t *agIORequest = agNULL; /* identify device data itself */ 22374 satIOContext_t *satIOContext = agNULL; 22375 bit32 status; 22376 22377 /* allocate tdiorequestbody and call tdsaDiscoveryIntStartIDDev 22378 tdsaDiscoveryIntStartIDDev(tiRoot, agNULL, tiDeviceHandle, satIOContext); 22379 22380 */ 22381 22382 TI_DBG3(("tdsaDiscoveryStartIDDev: start\n")); 22383 TI_DBG3(("tdsaDiscoveryStartIDDev: did %d\n", oneDeviceData->id)); 22384 22385 /* allocation tdIORequestBody and pass it to satTM() */ 22386 memAllocStatus = ostiAllocMemory( 22387 tiRoot, 22388 &osMemHandle, 22389 (void **)&tdIORequestBody, 22390 &PhysUpper32, 22391 &PhysLower32, 22392 8, 22393 sizeof(tdIORequestBody_t), 22394 agTRUE 22395 ); 22396 22397 if (memAllocStatus != tiSuccess) 22398 { 22399 TI_DBG1(("tdsaDiscoveryStartIDDev: ostiAllocMemory failed... loc 1\n")); 22400 return tiError; 22401 } 22402 if (tdIORequestBody == agNULL) 22403 { 22404 TI_DBG1(("tdsaDiscoveryStartIDDev: ostiAllocMemory returned NULL tdIORequestBody loc 2\n")); 22405 return tiError; 22406 } 22407 22408 /* setup identify device data IO structure */ 22409 tdIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 22410 tdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag = agNULL; 22411 tdIORequestBody->IOType.InitiatorTMIO.TaskTag = agNULL; 22412 22413 /* initialize tiDevhandle */ 22414 tdIORequestBody->tiDevHandle = &(oneDeviceData->tiDeviceHandle); 22415 tdIORequestBody->tiDevHandle->tdData = oneDeviceData; 22416 22417 /* initialize tiIORequest */ 22418 tdIORequestBody->tiIORequest = agNULL; 22419 22420 /* initialize agIORequest */ 22421 agIORequest = &(tdIORequestBody->agIORequest); 22422 agIORequest->osData = (void *) tdIORequestBody; 22423 agIORequest->sdkData = agNULL; /* SA takes care of this */ 22424 22425 /* set up satIOContext */ 22426 satIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 22427 satIOContext->pSatDevData = &(oneDeviceData->satDevData); 22428 satIOContext->pFis = 22429 &(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 22430 22431 satIOContext->tiRequestBody = tdIORequestBody; 22432 satIOContext->ptiDeviceHandle = &(oneDeviceData->tiDeviceHandle); 22433 satIOContext->tiScsiXchg = agNULL; 22434 satIOContext->satIntIoContext = agNULL; 22435 satIOContext->satOrgIOContext = agNULL; 22436 /* followings are used only for internal IO */ 22437 satIOContext->currentLBA = 0; 22438 satIOContext->OrgTL = 0; 22439 satIOContext->satToBeAbortedIOContext = agNULL; 22440 satIOContext->NotifyOS = agFALSE; 22441 22442 /* saving port ID just in case of full discovery to full discovery transition */ 22443 satIOContext->pid = oneDeviceData->tdPortContext->id; 22444 osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0x0, sizeof(agsaSATAIdentifyData_t)); 22445 status = tdsaDiscoveryIntStartIDDev(tiRoot, 22446 tiIORequest, /* agNULL */ 22447 tiDeviceHandle, /* &(oneDeviceData->tiDeviceHandle)*/ 22448 agNULL, 22449 satIOContext 22450 ); 22451 if (status != tiSuccess) 22452 { 22453 TI_DBG1(("tdsaDiscoveryStartIDDev: failed in sending %d\n", status)); 22454 ostiFreeMemory(tiRoot, osMemHandle, sizeof(tdIORequestBody_t)); 22455 } 22456 return status; 22457 } 22458 22459 /*****************************************************************************/ 22460 /*! \brief SAT implementation for tdsaDiscoveryIntStartIDDev. 22461 * 22462 * This function sends identify device data to SATA device. 22463 * 22464 * \param tiRoot: Pointer to TISA initiator driver/port instance. 22465 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 22466 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 22467 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 22468 * \param satIOContext_t: Pointer to the SAT IO Context 22469 * 22470 * \return If command is started successfully 22471 * - \e tiSuccess: I/O request successfully initiated. 22472 * - \e tiBusy: No resources available, try again later. 22473 * - \e tiIONoDevice: Invalid device handle. 22474 * - \e tiError: Other errors. 22475 */ 22476 /*****************************************************************************/ 22477 GLOBAL bit32 22478 tdsaDiscoveryIntStartIDDev(tiRoot_t *tiRoot, 22479 tiIORequest_t *tiIORequest, /* agNULL */ 22480 tiDeviceHandle_t *tiDeviceHandle, 22481 tiScsiInitiatorRequest_t *tiScsiRequest, /* agNULL */ 22482 satIOContext_t *satIOContext 22483 ) 22484 { 22485 satInternalIo_t *satIntIo = agNULL; 22486 satDeviceData_t *satDevData = agNULL; 22487 tdIORequestBody_t *tdIORequestBody; 22488 satIOContext_t *satNewIOContext; 22489 bit32 status; 22490 22491 TI_DBG3(("tdsaDiscoveryIntStartIDDev: start\n")); 22492 22493 satDevData = satIOContext->pSatDevData; 22494 22495 /* allocate identify device command */ 22496 satIntIo = satAllocIntIoResource( tiRoot, 22497 tiIORequest, 22498 satDevData, 22499 sizeof(agsaSATAIdentifyData_t), /* 512; size of identify device data */ 22500 satIntIo); 22501 22502 if (satIntIo == agNULL) 22503 { 22504 TI_DBG2(("tdsaDiscoveryIntStartIDDev: can't alloacate\n")); 22505 22506 return tiError; 22507 } 22508 22509 /* fill in fields */ 22510 /* real ttttttthe one worked and the same; 5/21/07/ */ 22511 satIntIo->satOrgTiIORequest = tiIORequest; /* changed */ 22512 tdIORequestBody = satIntIo->satIntRequestBody; 22513 satNewIOContext = &(tdIORequestBody->transport.SATA.satIOContext); 22514 22515 satNewIOContext->pSatDevData = satDevData; 22516 satNewIOContext->pFis = &(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev); 22517 satNewIOContext->pScsiCmnd = &(satIntIo->satIntTiScsiXchg.scsiCmnd); 22518 satNewIOContext->pSense = &(tdIORequestBody->transport.SATA.sensePayload); 22519 satNewIOContext->pTiSenseData = &(tdIORequestBody->transport.SATA.tiSenseData); 22520 satNewIOContext->tiRequestBody = satIntIo->satIntRequestBody; /* key fix */ 22521 satNewIOContext->interruptContext = tiInterruptContext; 22522 satNewIOContext->satIntIoContext = satIntIo; 22523 22524 satNewIOContext->ptiDeviceHandle = agNULL; 22525 satNewIOContext->satOrgIOContext = satIOContext; /* changed */ 22526 22527 /* this is valid only for TD layer generated (not triggered by OS at all) IO */ 22528 satNewIOContext->tiScsiXchg = &(satIntIo->satIntTiScsiXchg); 22529 22530 22531 TI_DBG6(("tdsaDiscoveryIntStartIDDev: OS satIOContext %p \n", satIOContext)); 22532 TI_DBG6(("tdsaDiscoveryIntStartIDDev: TD satNewIOContext %p \n", satNewIOContext)); 22533 TI_DBG6(("tdsaDiscoveryIntStartIDDev: OS tiScsiXchg %p \n", satIOContext->tiScsiXchg)); 22534 TI_DBG6(("tdsaDiscoveryIntStartIDDev: TD tiScsiXchg %p \n", satNewIOContext->tiScsiXchg)); 22535 22536 22537 22538 TI_DBG3(("tdsaDiscoveryIntStartIDDev: satNewIOContext %p tdIORequestBody %p\n", satNewIOContext, tdIORequestBody)); 22539 22540 status = tdsaDiscoverySendIDDev(tiRoot, 22541 &satIntIo->satIntTiIORequest, /* New tiIORequest */ 22542 tiDeviceHandle, 22543 satNewIOContext->tiScsiXchg, /* New tiScsiInitiatorRequest_t *tiScsiRequest, */ 22544 satNewIOContext); 22545 22546 if (status != tiSuccess) 22547 { 22548 TI_DBG1(("tdsaDiscoveryIntStartIDDev: failed in sending %d\n", status)); 22549 22550 satFreeIntIoResource( tiRoot, 22551 satDevData, 22552 satIntIo); 22553 22554 return tiError; 22555 } 22556 22557 22558 TI_DBG6(("tdsaDiscoveryIntStartIDDev: end\n")); 22559 22560 return status; 22561 } 22562 22563 22564 /*****************************************************************************/ 22565 /*! \brief SAT implementation for tdsaDiscoverySendIDDev. 22566 * 22567 * This function prepares identify device data FIS and sends it to SATA device. 22568 * 22569 * \param tiRoot: Pointer to TISA initiator driver/port instance. 22570 * \param tiIORequest: Pointer to TISA I/O request context for this I/O. 22571 * \param tiDeviceHandle: Pointer to TISA device handle for this I/O. 22572 * \param tiScsiRequest: Pointer to TISA SCSI I/O request and SGL list. 22573 * \param satIOContext_t: Pointer to the SAT IO Context 22574 * 22575 * \return If command is started successfully 22576 * - \e tiSuccess: I/O request successfully initiated. 22577 * - \e tiBusy: No resources available, try again later. 22578 * - \e tiIONoDevice: Invalid device handle. 22579 * - \e tiError: Other errors. 22580 */ 22581 /*****************************************************************************/ 22582 GLOBAL bit32 22583 tdsaDiscoverySendIDDev(tiRoot_t *tiRoot, 22584 tiIORequest_t *tiIORequest, 22585 tiDeviceHandle_t *tiDeviceHandle, 22586 tiScsiInitiatorRequest_t *tiScsiRequest, 22587 satIOContext_t *satIOContext 22588 ) 22589 { 22590 bit32 status; 22591 bit32 agRequestType; 22592 satDeviceData_t *pSatDevData; 22593 agsaFisRegHostToDevice_t *fis; 22594 #ifdef TD_DEBUG_ENABLE 22595 tdIORequestBody_t *tdIORequestBody; 22596 satInternalIo_t *satIntIoContext; 22597 #endif 22598 22599 pSatDevData = satIOContext->pSatDevData; 22600 fis = satIOContext->pFis; 22601 TI_DBG3(("tdsaDiscoverySendIDDev: start\n")); 22602 #ifdef TD_DEBUG_ENABLE 22603 satIntIoContext = satIOContext->satIntIoContext; 22604 tdIORequestBody = satIntIoContext->satIntRequestBody; 22605 #endif 22606 TI_DBG5(("tdsaDiscoverySendIDDev: satIOContext %p tdIORequestBody %p\n", satIOContext, tdIORequestBody)); 22607 22608 fis->h.fisType = 0x27; /* Reg host to device */ 22609 fis->h.c_pmPort = 0x80; /* C Bit is set */ 22610 if (pSatDevData->satDeviceType == SATA_ATAPI_DEVICE) 22611 fis->h.command = SAT_IDENTIFY_PACKET_DEVICE; /* 0xA1 */ 22612 else 22613 fis->h.command = SAT_IDENTIFY_DEVICE; /* 0xEC */ 22614 fis->h.features = 0; /* FIS reserve */ 22615 fis->d.lbaLow = 0; /* FIS LBA (7 :0 ) */ 22616 fis->d.lbaMid = 0; /* FIS LBA (15:8 ) */ 22617 fis->d.lbaHigh = 0; /* FIS LBA (23:16) */ 22618 fis->d.device = 0; /* FIS LBA mode */ 22619 fis->d.lbaLowExp = 0; 22620 fis->d.lbaMidExp = 0; 22621 fis->d.lbaHighExp = 0; 22622 fis->d.featuresExp = 0; 22623 fis->d.sectorCount = 0; /* FIS sector count (7:0) */ 22624 fis->d.sectorCountExp = 0; 22625 fis->d.reserved4 = 0; 22626 fis->d.control = 0; /* FIS HOB bit clear */ 22627 fis->d.reserved5 = 0; 22628 22629 agRequestType = AGSA_SATA_PROTOCOL_PIO_READ; 22630 22631 /* Initialize CB for SATA completion. 22632 */ 22633 satIOContext->satCompleteCB = &tdsaDiscoveryStartIDDevCB; 22634 22635 /* 22636 * Prepare SGL and send FIS to LL layer. 22637 */ 22638 satIOContext->reqType = agRequestType; /* Save it */ 22639 22640 #ifdef TD_INTERNAL_DEBUG 22641 tdhexdump("tdsaDiscoverySendIDDev", (bit8 *)satIOContext->pFis, sizeof(agsaFisRegHostToDevice_t)); 22642 #ifdef TD_DEBUG_ENABLE 22643 tdhexdump("tdsaDiscoverySendIDDev LL", (bit8 *)&(tdIORequestBody->transport.SATA.agSATARequestBody.fis.fisRegHostToDev), sizeof(agsaFisRegHostToDevice_t)); 22644 #endif 22645 #endif 22646 status = sataLLIOStart( tiRoot, 22647 tiIORequest, 22648 tiDeviceHandle, 22649 tiScsiRequest, 22650 satIOContext); 22651 TI_DBG3(("tdsaDiscoverySendIDDev: end status %d\n", status)); 22652 return status; 22653 } 22654 22655 22656 /***************************************************************************** 22657 *! \brief tdsaDiscoveryStartIDDevCB 22658 * 22659 * This routine is a callback function for tdsaDiscoverySendIDDev() 22660 * Using Identify Device Data, this function finds whether devicedata is 22661 * new or old. If new, add it to the devicelist. This is done as a part 22662 * of discovery. 22663 * 22664 * \param agRoot: Handles for this instance of SAS/SATA hardware 22665 * \param agIORequest: Pointer to the LL I/O request context for this I/O. 22666 * \param agIOStatus: Status of completed I/O. 22667 * \param agFirstDword:Pointer to the four bytes of FIS. 22668 * \param agIOInfoLen: Length in bytes of overrun/underrun residual or FIS 22669 * length. 22670 * \param agParam: Additional info based on status. 22671 * \param ioContext: Pointer to satIOContext_t. 22672 * 22673 * \return: none 22674 * 22675 *****************************************************************************/ 22676 void tdsaDiscoveryStartIDDevCB( 22677 agsaRoot_t *agRoot, 22678 agsaIORequest_t *agIORequest, 22679 bit32 agIOStatus, 22680 agsaFisHeader_t *agFirstDword, 22681 bit32 agIOInfoLen, 22682 void *agParam, 22683 void *ioContext 22684 ) 22685 { 22686 /* 22687 In the process of SAT_IDENTIFY_DEVICE during discovery 22688 */ 22689 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 22690 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 22691 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 22692 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 22693 tdIORequestBody_t *tdIORequestBody; 22694 tdIORequestBody_t *tdOrgIORequestBody; 22695 satIOContext_t *satIOContext; 22696 satIOContext_t *satOrgIOContext; 22697 satIOContext_t *satNewIOContext; 22698 satInternalIo_t *satIntIo; 22699 satInternalIo_t *satNewIntIo = agNULL; 22700 satDeviceData_t *satDevData; 22701 tiIORequest_t *tiOrgIORequest = agNULL; 22702 22703 #ifdef TD_DEBUG_ENABLE 22704 bit32 ataStatus = 0; 22705 bit32 ataError; 22706 agsaFisPioSetupHeader_t *satPIOSetupHeader = agNULL; 22707 #endif 22708 agsaSATAIdentifyData_t *pSATAIdData; 22709 bit16 *tmpptr, tmpptr_tmp; 22710 bit32 x; 22711 tdsaDeviceData_t *oneDeviceData = agNULL; 22712 void *sglVirtualAddr; 22713 tdsaPortContext_t *onePortContext = agNULL; 22714 tiPortalContext_t *tiPortalContext = agNULL; 22715 bit32 retry_status; 22716 22717 TI_DBG3(("tdsaDiscoveryStartIDDevCB: start\n")); 22718 22719 tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData; 22720 satIOContext = (satIOContext_t *) ioContext; 22721 satIntIo = satIOContext->satIntIoContext; 22722 satDevData = satIOContext->pSatDevData; 22723 oneDeviceData = (tdsaDeviceData_t *)tdIORequestBody->tiDevHandle->tdData; 22724 TI_DBG3(("tdsaDiscoveryStartIDDevCB: did %d\n", oneDeviceData->id)); 22725 onePortContext = oneDeviceData->tdPortContext; 22726 if (onePortContext == agNULL) 22727 { 22728 TI_DBG1(("tdsaDiscoveryStartIDDevCB: onePortContext is NULL\n")); 22729 return; 22730 } 22731 tiPortalContext= onePortContext->tiPortalContext; 22732 22733 satDevData->IDDeviceValid = agFALSE; 22734 22735 if (satIntIo == agNULL) 22736 { 22737 TI_DBG1(("tdsaDiscoveryStartIDDevCB: External, OS generated\n")); 22738 TI_DBG1(("tdsaDiscoveryStartIDDevCB: Not possible case\n")); 22739 satOrgIOContext = satIOContext; 22740 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 22741 22742 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22743 22744 satFreeIntIoResource( tiRoot, 22745 satDevData, 22746 satIntIo); 22747 22748 /* clean up TD layer's IORequestBody */ 22749 ostiFreeMemory( 22750 tiRoot, 22751 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22752 sizeof(tdIORequestBody_t) 22753 ); 22754 return; 22755 } 22756 else 22757 { 22758 TI_DBG3(("tdsaDiscoveryStartIDDevCB: Internal, TD generated\n")); 22759 satOrgIOContext = satIOContext->satOrgIOContext; 22760 if (satOrgIOContext == agNULL) 22761 { 22762 TI_DBG6(("tdsaDiscoveryStartIDDevCB: satOrgIOContext is NULL\n")); 22763 return; 22764 } 22765 else 22766 { 22767 TI_DBG6(("tdsaDiscoveryStartIDDevCB: satOrgIOContext is NOT NULL\n")); 22768 tdOrgIORequestBody = (tdIORequestBody_t *)satOrgIOContext->tiRequestBody; 22769 sglVirtualAddr = satIntIo->satIntTiScsiXchg.sglVirtualAddr; 22770 } 22771 } 22772 22773 tiOrgIORequest = tdIORequestBody->tiIORequest; 22774 tdIORequestBody->ioCompleted = agTRUE; 22775 tdIORequestBody->ioStarted = agFALSE; 22776 22777 TI_DBG3(("tdsaDiscoveryStartIDDevCB: satOrgIOContext->pid %d\n", satOrgIOContext->pid)); 22778 22779 /* protect against double completion for old port */ 22780 if (satOrgIOContext->pid != oneDeviceData->tdPortContext->id) 22781 { 22782 TI_DBG3(("tdsaDiscoveryStartIDDevCB: incorrect pid\n")); 22783 TI_DBG3(("tdsaDiscoveryStartIDDevCB: satOrgIOContext->pid %d\n", satOrgIOContext->pid)); 22784 TI_DBG3(("tdsaDiscoveryStartIDDevCB: tiPortalContext pid %d\n", oneDeviceData->tdPortContext->id)); 22785 22786 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22787 22788 satFreeIntIoResource( tiRoot, 22789 satDevData, 22790 satIntIo); 22791 22792 /* clean up TD layer's IORequestBody */ 22793 ostiFreeMemory( 22794 tiRoot, 22795 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22796 sizeof(tdIORequestBody_t) 22797 ); 22798 22799 return; 22800 } 22801 22802 /* completion after portcontext is invalidated */ 22803 if (onePortContext != agNULL) 22804 { 22805 if (onePortContext->valid == agFALSE) 22806 { 22807 TI_DBG1(("tdsaDiscoveryStartIDDevCB: portcontext is invalid\n")); 22808 TI_DBG1(("tdsaDiscoveryStartIDDevCB: onePortContext->id pid %d\n", onePortContext->id)); 22809 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22810 22811 satFreeIntIoResource( tiRoot, 22812 satDevData, 22813 satIntIo); 22814 22815 /* clean up TD layer's IORequestBody */ 22816 ostiFreeMemory( 22817 tiRoot, 22818 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22819 sizeof(tdIORequestBody_t) 22820 ); 22821 22822 /* no notification to OS layer */ 22823 return; 22824 } 22825 } 22826 22827 if (agFirstDword == agNULL && agIOStatus != OSSA_IO_SUCCESS) 22828 { 22829 TI_DBG1(("tdsaDiscoveryStartIDDevCB: agFirstDword is NULL when error, status %d\n", agIOStatus)); 22830 TI_DBG1(("tdsaDiscoveryStartIDDevCB: did %d\n", oneDeviceData->id)); 22831 22832 if (tdsaAllShared->ResetInDiscovery != 0 && satDevData->ID_Retries < SATA_ID_DEVICE_DATA_RETRIES) 22833 { 22834 satIOContext->pSatDevData->satPendingNONNCQIO--; 22835 satIOContext->pSatDevData->satPendingIO--; 22836 retry_status = sataLLIOStart(tiRoot, 22837 &satIntIo->satIntTiIORequest, 22838 &(oneDeviceData->tiDeviceHandle), 22839 satIOContext->tiScsiXchg, 22840 satIOContext); 22841 if (retry_status != tiSuccess) 22842 { 22843 /* simply give up */ 22844 satDevData->ID_Retries = 0; 22845 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22846 22847 satFreeIntIoResource( tiRoot, 22848 satDevData, 22849 satIntIo); 22850 22851 /* clean up TD layer's IORequestBody */ 22852 ostiFreeMemory( 22853 tiRoot, 22854 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22855 sizeof(tdIORequestBody_t) 22856 ); 22857 return; 22858 } 22859 satDevData->ID_Retries++; 22860 tdIORequestBody->ioCompleted = agFALSE; 22861 tdIORequestBody->ioStarted = agTRUE; 22862 return; 22863 } 22864 else 22865 { 22866 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22867 satFreeIntIoResource( tiRoot, 22868 satDevData, 22869 satIntIo); 22870 22871 /* clean up TD layer's IORequestBody */ 22872 ostiFreeMemory( 22873 tiRoot, 22874 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22875 sizeof(tdIORequestBody_t) 22876 ); 22877 if (tdsaAllShared->ResetInDiscovery != 0) 22878 { 22879 /* ResetInDiscovery in on */ 22880 if (satDevData->NumOfIDRetries <= 0) 22881 { 22882 satDevData->NumOfIDRetries++; 22883 satDevData->ID_Retries = 0; 22884 /* send link reset */ 22885 tdsaPhyControlSend(tiRoot, 22886 oneDeviceData, 22887 SMP_PHY_CONTROL_HARD_RESET, 22888 agNULL, 22889 tdsaRotateQnumber(tiRoot, oneDeviceData) 22890 ); 22891 } 22892 } 22893 return; 22894 } 22895 } 22896 22897 if (agIOStatus == OSSA_IO_ABORTED || 22898 agIOStatus == OSSA_IO_UNDERFLOW || 22899 agIOStatus == OSSA_IO_XFER_ERROR_BREAK || 22900 agIOStatus == OSSA_IO_XFER_ERROR_PHY_NOT_READY || 22901 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED || 22902 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BREAK || 22903 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS || 22904 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION || 22905 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED || 22906 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY || 22907 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION || 22908 agIOStatus == OSSA_IO_XFER_ERROR_NAK_RECEIVED || 22909 agIOStatus == OSSA_IO_XFER_ERROR_DMA || 22910 agIOStatus == OSSA_IO_XFER_ERROR_SATA_LINK_TIMEOUT || 22911 agIOStatus == OSSA_IO_XFER_ERROR_REJECTED_NCQ_MODE || 22912 agIOStatus == OSSA_IO_XFER_OPEN_RETRY_TIMEOUT || 22913 agIOStatus == OSSA_IO_NO_DEVICE || 22914 agIOStatus == OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION || 22915 agIOStatus == OSSA_IO_PORT_IN_RESET || 22916 agIOStatus == OSSA_IO_DS_NON_OPERATIONAL || 22917 agIOStatus == OSSA_IO_DS_IN_RECOVERY || 22918 agIOStatus == OSSA_IO_DS_IN_ERROR 22919 ) 22920 { 22921 TI_DBG1(("tdsaDiscoveryStartIDDevCB: OSSA_IO_OPEN_CNX_ERROR 0x%x\n", agIOStatus)); 22922 if (tdsaAllShared->ResetInDiscovery != 0 && satDevData->ID_Retries < SATA_ID_DEVICE_DATA_RETRIES) 22923 { 22924 satIOContext->pSatDevData->satPendingNONNCQIO--; 22925 satIOContext->pSatDevData->satPendingIO--; 22926 retry_status = sataLLIOStart(tiRoot, 22927 &satIntIo->satIntTiIORequest, 22928 &(oneDeviceData->tiDeviceHandle), 22929 satIOContext->tiScsiXchg, 22930 satIOContext); 22931 if (retry_status != tiSuccess) 22932 { 22933 /* simply give up */ 22934 satDevData->ID_Retries = 0; 22935 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22936 22937 satFreeIntIoResource( tiRoot, 22938 satDevData, 22939 satIntIo); 22940 22941 /* clean up TD layer's IORequestBody */ 22942 ostiFreeMemory( 22943 tiRoot, 22944 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22945 sizeof(tdIORequestBody_t) 22946 ); 22947 return; 22948 } 22949 satDevData->ID_Retries++; 22950 tdIORequestBody->ioCompleted = agFALSE; 22951 tdIORequestBody->ioStarted = agTRUE; 22952 return; 22953 } 22954 else 22955 { 22956 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 22957 satFreeIntIoResource( tiRoot, 22958 satDevData, 22959 satIntIo); 22960 22961 /* clean up TD layer's IORequestBody */ 22962 ostiFreeMemory( 22963 tiRoot, 22964 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 22965 sizeof(tdIORequestBody_t) 22966 ); 22967 if (tdsaAllShared->ResetInDiscovery != 0) 22968 { 22969 /* ResetInDiscovery in on */ 22970 if (satDevData->NumOfIDRetries <= 0) 22971 { 22972 satDevData->NumOfIDRetries++; 22973 satDevData->ID_Retries = 0; 22974 /* send link reset */ 22975 tdsaPhyControlSend(tiRoot, 22976 oneDeviceData, 22977 SMP_PHY_CONTROL_HARD_RESET, 22978 agNULL, 22979 tdsaRotateQnumber(tiRoot, oneDeviceData) 22980 ); 22981 } 22982 } 22983 return; 22984 } 22985 } 22986 22987 if ( agIOStatus != OSSA_IO_SUCCESS || 22988 (agIOStatus == OSSA_IO_SUCCESS && agFirstDword != agNULL && agIOInfoLen != 0) 22989 ) 22990 { 22991 #ifdef TD_DEBUG_ENABLE 22992 /* only agsaFisPioSetup_t is expected */ 22993 satPIOSetupHeader = (agsaFisPioSetupHeader_t *)&(agFirstDword->PioSetup); 22994 ataStatus = satPIOSetupHeader->status; /* ATA Status register */ 22995 ataError = satPIOSetupHeader->error; /* ATA Eror register */ 22996 #endif 22997 TI_DBG1(("tdsaDiscoveryStartIDDevCB: ataStatus 0x%x ataError 0x%x\n", ataStatus, ataError)); 22998 22999 if (tdsaAllShared->ResetInDiscovery != 0 && satDevData->ID_Retries < SATA_ID_DEVICE_DATA_RETRIES) 23000 { 23001 satIOContext->pSatDevData->satPendingNONNCQIO--; 23002 satIOContext->pSatDevData->satPendingIO--; 23003 retry_status = sataLLIOStart(tiRoot, 23004 &satIntIo->satIntTiIORequest, 23005 &(oneDeviceData->tiDeviceHandle), 23006 satIOContext->tiScsiXchg, 23007 satIOContext); 23008 if (retry_status != tiSuccess) 23009 { 23010 /* simply give up */ 23011 satDevData->ID_Retries = 0; 23012 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 23013 23014 satFreeIntIoResource( tiRoot, 23015 satDevData, 23016 satIntIo); 23017 23018 /* clean up TD layer's IORequestBody */ 23019 ostiFreeMemory( 23020 tiRoot, 23021 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 23022 sizeof(tdIORequestBody_t) 23023 ); 23024 return; 23025 } 23026 satDevData->ID_Retries++; 23027 tdIORequestBody->ioCompleted = agFALSE; 23028 tdIORequestBody->ioStarted = agTRUE; 23029 return; 23030 } 23031 else 23032 { 23033 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 23034 satFreeIntIoResource( tiRoot, 23035 satDevData, 23036 satIntIo); 23037 23038 /* clean up TD layer's IORequestBody */ 23039 ostiFreeMemory( 23040 tiRoot, 23041 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 23042 sizeof(tdIORequestBody_t) 23043 ); 23044 if (tdsaAllShared->ResetInDiscovery != 0) 23045 { 23046 /* ResetInDiscovery in on */ 23047 if (satDevData->NumOfIDRetries <= 0) 23048 { 23049 satDevData->NumOfIDRetries++; 23050 satDevData->ID_Retries = 0; 23051 /* send link reset */ 23052 tdsaPhyControlSend(tiRoot, 23053 oneDeviceData, 23054 SMP_PHY_CONTROL_HARD_RESET, 23055 agNULL, 23056 tdsaRotateQnumber(tiRoot, oneDeviceData) 23057 ); 23058 } 23059 } 23060 return; 23061 } 23062 } 23063 23064 23065 /* success */ 23066 TI_DBG3(("tdsaDiscoveryStartIDDevCB: Success\n")); 23067 TI_DBG3(("tdsaDiscoveryStartIDDevCB: Success did %d\n", oneDeviceData->id)); 23068 23069 /* Convert to host endian */ 23070 tmpptr = (bit16*)sglVirtualAddr; 23071 for (x=0; x < sizeof(agsaSATAIdentifyData_t)/sizeof(bit16); x++) 23072 { 23073 OSSA_READ_LE_16(AGROOT, &tmpptr_tmp, tmpptr, 0); 23074 *tmpptr = tmpptr_tmp; 23075 tmpptr++; 23076 } 23077 23078 pSATAIdData = (agsaSATAIdentifyData_t *)sglVirtualAddr; 23079 //tdhexdump("satAddSATAIDDevCB before", (bit8 *)pSATAIdData, sizeof(agsaSATAIdentifyData_t)); 23080 23081 TI_DBG5(("tdsaDiscoveryStartIDDevCB: OS satOrgIOContext %p \n", satOrgIOContext)); 23082 TI_DBG5(("tdsaDiscoveryStartIDDevCB: TD satIOContext %p \n", satIOContext)); 23083 TI_DBG5(("tdsaDiscoveryStartIDDevCB: OS tiScsiXchg %p \n", satOrgIOContext->tiScsiXchg)); 23084 TI_DBG5(("tdsaDiscoveryStartIDDevCB: TD tiScsiXchg %p \n", satIOContext->tiScsiXchg)); 23085 23086 23087 /* copy ID Dev data to satDevData */ 23088 satDevData->satIdentifyData = *pSATAIdData; 23089 satDevData->IDDeviceValid = agTRUE; 23090 23091 #ifdef TD_INTERNAL_DEBUG 23092 tdhexdump("tdsaDiscoveryStartIDDevCB ID Dev data",(bit8 *)pSATAIdData, sizeof(agsaSATAIdentifyData_t)); 23093 tdhexdump("tdsaDiscoveryStartIDDevCB Device ID Dev data",(bit8 *)&satDevData->satIdentifyData, sizeof(agsaSATAIdentifyData_t)); 23094 #endif 23095 23096 /* set satDevData fields from IndentifyData */ 23097 satSetDevInfo(satDevData,pSATAIdData); 23098 satDecrementPendingIO(tiRoot, tdsaAllShared, satIOContext); 23099 23100 satFreeIntIoResource( tiRoot, 23101 satDevData, 23102 satIntIo); 23103 23104 if (satDevData->satDeviceType == SATA_ATAPI_DEVICE) 23105 { 23106 /* send the Set Feature ATA command to ATAPI device for enbling PIO and DMA transfer mode*/ 23107 satNewIntIo = satAllocIntIoResource( tiRoot, 23108 tiOrgIORequest, 23109 satDevData, 23110 0, 23111 satNewIntIo); 23112 23113 if (satNewIntIo == agNULL) 23114 { 23115 TI_DBG1(("tdsaDiscoveryStartIDDevCB: momory allocation fails\n")); 23116 /* clean up TD layer's IORequestBody */ 23117 ostiFreeMemory( 23118 tiRoot, 23119 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 23120 sizeof(tdIORequestBody_t) 23121 ); 23122 return; 23123 } /* end memory allocation */ 23124 23125 satNewIOContext = satPrepareNewIO(satNewIntIo, 23126 tiOrgIORequest, 23127 satDevData, 23128 agNULL, 23129 satOrgIOContext 23130 ); 23131 /* enable PIO mode, then enable Ultra DMA mode in the satSetFeaturesCB callback function*/ 23132 retry_status = satSetFeatures(tiRoot, 23133 &satNewIntIo->satIntTiIORequest, 23134 satNewIOContext->ptiDeviceHandle, 23135 &satNewIntIo->satIntTiScsiXchg, /* orginal from OS layer */ 23136 satNewIOContext, 23137 agFALSE); 23138 if (retry_status != tiSuccess) 23139 { 23140 satFreeIntIoResource(tiRoot, satDevData, satIntIo); 23141 /* clean up TD layer's IORequestBody */ 23142 ostiFreeMemory( 23143 tiRoot, 23144 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 23145 sizeof(tdIORequestBody_t) 23146 ); 23147 } 23148 } 23149 else 23150 { 23151 /* clean up TD layer's IORequestBody */ 23152 ostiFreeMemory( 23153 tiRoot, 23154 tdOrgIORequestBody->IOType.InitiatorTMIO.osMemHandle, 23155 sizeof(tdIORequestBody_t) 23156 ); 23157 if (onePortContext != agNULL) 23158 { 23159 if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED) 23160 { 23161 TI_DBG1(("tdsaDiscoveryStartIDDevCB: ID completed after discovery is done; tiDeviceArrival\n")); 23162 /* in case registration is finished after discovery is finished */ 23163 ostiInitiatorEvent( 23164 tiRoot, 23165 tiPortalContext, 23166 agNULL, 23167 tiIntrEventTypeDeviceChange, 23168 tiDeviceArrival, 23169 agNULL 23170 ); 23171 } 23172 } 23173 else 23174 { 23175 TI_DBG1(("tdsaDiscoveryStartIDDevCB: onePortContext is NULL, wrong\n")); 23176 } 23177 } 23178 TI_DBG3(("tdsaDiscoveryStartIDDevCB: end\n")); 23179 return; 23180 } 23181 /***************************************************************************** 23182 *! \brief satAbort 23183 * 23184 * This routine does local abort for outstanding FIS. 23185 * 23186 * \param agRoot: Handles for this instance of SAS/SATA hardware 23187 * \param satIOContext: Pointer to satIOContext_t. 23188 * 23189 * \return: none 23190 * 23191 *****************************************************************************/ 23192 GLOBAL void satAbort(agsaRoot_t *agRoot, 23193 satIOContext_t *satIOContext) 23194 { 23195 tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData; 23196 tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot; 23197 tdIORequestBody_t *tdIORequestBody; /* io to be aborted */ 23198 tdIORequestBody_t *tdAbortIORequestBody; /* abort io itself */ 23199 agsaIORequest_t *agToBeAbortedIORequest; /* io to be aborted */ 23200 agsaIORequest_t *agAbortIORequest; /* abort io itself */ 23201 bit32 PhysUpper32; 23202 bit32 PhysLower32; 23203 bit32 memAllocStatus; 23204 void *osMemHandle; 23205 23206 TI_DBG1(("satAbort: start\n")); 23207 23208 if (satIOContext == agNULL) 23209 { 23210 TI_DBG1(("satAbort: satIOContext is NULL, wrong\n")); 23211 return; 23212 } 23213 tdIORequestBody = (tdIORequestBody_t *)satIOContext->tiRequestBody; 23214 agToBeAbortedIORequest = (agsaIORequest_t *)&(tdIORequestBody->agIORequest); 23215 /* allocating agIORequest for abort itself */ 23216 memAllocStatus = ostiAllocMemory( 23217 tiRoot, 23218 &osMemHandle, 23219 (void **)&tdAbortIORequestBody, 23220 &PhysUpper32, 23221 &PhysLower32, 23222 8, 23223 sizeof(tdIORequestBody_t), 23224 agTRUE 23225 ); 23226 23227 if (memAllocStatus != tiSuccess) 23228 { 23229 /* let os process IO */ 23230 TI_DBG1(("satAbort: ostiAllocMemory failed...\n")); 23231 return; 23232 } 23233 23234 if (tdAbortIORequestBody == agNULL) 23235 { 23236 /* let os process IO */ 23237 TI_DBG1(("satAbort: ostiAllocMemory returned NULL tdAbortIORequestBody\n")); 23238 return; 23239 } 23240 /* setup task management structure */ 23241 tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle; 23242 tdAbortIORequestBody->tiDevHandle = tdIORequestBody->tiDevHandle; 23243 23244 /* initialize agIORequest */ 23245 agAbortIORequest = &(tdAbortIORequestBody->agIORequest); 23246 agAbortIORequest->osData = (void *) tdAbortIORequestBody; 23247 agAbortIORequest->sdkData = agNULL; /* LL takes care of this */ 23248 23249 23250 /* 23251 * Issue abort 23252 */ 23253 saSATAAbort( agRoot, agAbortIORequest, 0, agNULL, 0, agToBeAbortedIORequest, agNULL ); 23254 23255 23256 TI_DBG1(("satAbort: end\n")); 23257 return; 23258 } 23259 23260 /***************************************************************************** 23261 *! \brief satSATADeviceReset 23262 * 23263 * This routine is called to reset all phys of port which a device belongs to 23264 * 23265 * \param tiRoot: Pointer to TISA initiator driver/port instance. 23266 * \param oneDeviceData: Pointer to the device data. 23267 * \param flag: reset flag 23268 * 23269 * \return: 23270 * 23271 * none 23272 * 23273 *****************************************************************************/ 23274 osGLOBAL void 23275 satSATADeviceReset( tiRoot_t *tiRoot, 23276 tdsaDeviceData_t *oneDeviceData, 23277 bit32 flag) 23278 { 23279 agsaRoot_t *agRoot; 23280 tdsaPortContext_t *onePortContext; 23281 bit32 i; 23282 23283 TI_DBG1(("satSATADeviceReset: start\n")); 23284 agRoot = oneDeviceData->agRoot; 23285 onePortContext = oneDeviceData->tdPortContext; 23286 23287 if (agRoot == agNULL) 23288 { 23289 TI_DBG1(("satSATADeviceReset: Error!!! agRoot is NULL\n")); 23290 return; 23291 } 23292 if (onePortContext == agNULL) 23293 { 23294 TI_DBG1(("satSATADeviceReset: Error!!! onePortContext is NULL\n")); 23295 return; 23296 } 23297 23298 for(i=0;i<TD_MAX_NUM_PHYS;i++) 23299 { 23300 if (onePortContext->PhyIDList[i] == agTRUE) 23301 { 23302 saLocalPhyControl(agRoot, agNULL, tdsaRotateQnumber(tiRoot, agNULL), i, flag, agNULL); 23303 } 23304 } 23305 23306 return; 23307 } 23308 23309 #endif /* #ifdef SATA_ENABLE */

Cache object: bc9901e73e76cec866ae0c804b3f2c78

FreeBSD/Linux Kernel Cross Reference sys/dev/pms/RefTisa/tisa/sassata/sata/host/sat.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/pms/RefTisa/tisa/sassata/sata/host/sat.c